diff --git a/20260421 Coding LLMs.ods b/20260421 Coding LLMs.ods
index 3d039d0..2940935 100644
Binary files a/20260421 Coding LLMs.ods and b/20260421 Coding LLMs.ods differ
diff --git a/LinkSyncServer/__pycache__/app.cpython-313.pyc b/LinkSyncServer/__pycache__/app.cpython-313.pyc
new file mode 100644
index 0000000..b3d67c3
Binary files /dev/null and b/LinkSyncServer/__pycache__/app.cpython-313.pyc differ
diff --git a/LinkSyncServer/__pycache__/routes.cpython-313.pyc b/LinkSyncServer/__pycache__/routes.cpython-313.pyc
new file mode 100644
index 0000000..cae995d
Binary files /dev/null and b/LinkSyncServer/__pycache__/routes.cpython-313.pyc differ
diff --git a/LinkSyncServer/api/endpoints/__pycache__/links.cpython-313.pyc b/LinkSyncServer/api/endpoints/__pycache__/links.cpython-313.pyc
new file mode 100644
index 0000000..519e5a5
Binary files /dev/null and b/LinkSyncServer/api/endpoints/__pycache__/links.cpython-313.pyc differ
diff --git a/LinkSyncServer/api/endpoints/collections.py b/LinkSyncServer/api/endpoints/collections.py
index ece53ed..7eebcf3 100644
--- a/LinkSyncServer/api/endpoints/collections.py
+++ b/LinkSyncServer/api/endpoints/collections.py
@@ -1,29 +1,40 @@
 """
-LinkSyncServer - Collection CRUD Endpoints
+LinkSyncServer - Collection CRUD Endpoints with SQLAlchemy
 """
 
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, status, Query, Request
 from sqlalchemy.orm import Session
+from sqlalchemy import func, and_, or_, exists
 from typing import List, Optional
 import uuid
+import logging
+
+from models.base import Base, Bookmark, Collection, AuditLog, get_engine, sessionmaker
+from pydantic import BaseModel, Field
+import os
 
 router = APIRouter(prefix="/api/collections", tags=["Collections"])
 
+# Logging
+logger = logging.getLogger(__name__)
+
 
 class CollectionCreate(BaseModel):
-    name: str
-    description: Optional[str] = None
-    query_type: str  # "static" or "dynamic"
-    query_expression: Optional[dict] = None
-    is_public: bool = False
+    name: str = Field(..., description="Collection name")
+    description: Optional[str] = Field(None, max_length=1024, description="Collection description")
+    query_type: str = Field(default="static", description="Static or dynamic collection")
+    query_expression: Optional[dict] = Field(None, description="Query expression for dynamic collections")
+    is_public: bool = Field(default=False, description="Is collection public")
+    tags: Optional[List[str]] = Field(default_factory=list, description="Collection tags")
 
 
 class CollectionUpdate(BaseModel):
-    name: Optional[str] = None
-    description: Optional[str] = None
-    query_type: Optional[str] = None
-    query_expression: Optional[dict] = None
+    name: Optional[str] = Field(None, max_length=255)
+    description: Optional[str] = Field(None, max_length=1024)
+    query_type: Optional[str] = Field(None)
+    query_expression: Optional[dict] = Field(None)
     is_public: Optional[bool] = None
+    tags: Optional[List[str]] = Field(None)
 
 
 class CollectionResponse(BaseModel):
@@ -35,135 +46,188 @@ class CollectionResponse(BaseModel):
     is_public: bool
     created_at: str
     updated_at: str
+    tags: List[str]
 
 
-def mock_create_collection(data: CollectionCreate) -> CollectionResponse:
-    """Create collection (mock implementation)."""
-    return {
-        "id": str(uuid.uuid4()),
-        "name": data.name,
-        "description": data.description,
-        "query_type": data.query_type,
-        "query_expression": data.query_expression,
-        "is_public": data.is_public,
-        "created_at": "2026-05-11T00:00:00Z",
-        "updated_at": "2026-05-11T00:00:00Z"
-    }
+def get_db():
+    """Get database session."""
+    db_session = sessionmaker(get_engine())()
+    return db_session
 
 
-def mock_get_collections() -> List[CollectionResponse]:
-    """Get all collections (mock implementation)."""
-    return [
-        {
-            "id": str(uuid.uuid4()),
-            "name": "Work Links",
-            "description": "Links for work use",
-            "query_type": "dynamic",
-            "query_expression": {"operation": "OR", "operands": [{"operation": "TERM", "value": "work"}]},
-            "is_public": False,
-            "created_at": "2026-05-11T00:00:00Z",
-            "updated_at": "2026-05-11T00:00:00Z"
-        }
-    ]
+def get_current_user(request: Request):
+    """Get current authenticated user."""
+    SECRET_KEY = os.environ.get("SECRET_KEY")
+    
+    auth_header = request.headers.get("Authorization") or request.headers.get("authorization")
+    
+    if auth_header and auth_header.startswith("Bearer "):
+        token = auth_header[7:]
+        try:
+            import jwt
+            payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
+            return {"username": payload.get("sub"), "id": payload.get("sub")}
+        except Exception:
+            pass
+
+    return {"username": "guest"}
 
 
-def mock_get_collection(collection_id: str) -> CollectionResponse | None:
-    """Get collection by ID (mock implementation)."""
-    if collection_id == "mock-id":
-        return {
-            "id": "mock-id",
-            "name": "Work Links",
-            "description": "Links for work use",
-            "query_type": "dynamic",
-            "query_expression": {"operation": "OR", "operands": [{"operation": "TERM", "value": "work"}]},
-            "is_public": False,
-            "created_at": "2026-05-11T00:00:00Z",
-            "updated_at": "2026-05-11T00:00:00Z"
-        }
-    return None
-
-
-def mock_update_collection(collection_id: str, data: CollectionUpdate) -> CollectionResponse | None:
-    """Update collection."""
-    return mock_get_collection(collection_id)
-
-
-def mock_delete_collection(collection_id: str) -> bool:
-    """Delete collection."""
-    return True
-
-
-def mock_execute_query(query_expression: dict) -> List[dict]:
-    """Execute query against bookmarks (mock implementation)."""
-    return [
-        {
-            "id": str(uuid.uuid4()),
-            "url": "https://example.com/work",
-            "title": "Work Example",
-            "description": "An example",
-            "notes": "",
-            "tags": ["work"],
-            "favicon_url": None,
-            "path": "/Work",
-            "created_at": "2026-05-11T00:00:00Z",
-            "updated_at": "2026-05-11T00:00:00Z",
-            "visit_count": 0,
-            "is_bookmarked": False,
-            "source_set_id": None
-        }
-    ]
-
-
-@router.get("/", response_model=List[CollectionResponse])
-async def list_collections():
-    """List all collections."""
-    return mock_get_collections()
-
-
-@router.get("/{collection_id}", response_model=CollectionResponse)
-async def get_collection(collection_id: str):
-    """Get collection by ID."""
-    collection = mock_get_collection(collection_id)
-    if not collection:
-        raise HTTPException(status_code=404, detail="Collection not found")
-    return collection
-
-
-@router.post("/", response_model=CollectionResponse, status_code=status.HTTP_201_CREATED)
-async def create_collection(data: CollectionCreate):
-    """Create new collection."""
-    collection = mock_create_collection(data)
-    return collection
-
-
-@router.put("/{collection_id}", response_model=CollectionResponse)
-async def update_collection(
-    collection_id: str,
-    data: CollectionUpdate
-):
-    """Update collection."""
-    collection = mock_update_collection(collection_id, data)
-    if not collection:
-        raise HTTPException(status_code=404, detail="Collection not found")
-    return collection
-
-
-@router.delete("/{collection_id}", response_model=dict)
-async def delete_collection(collection_id: str):
-    """Delete collection."""
-    success = mock_delete_collection(collection_id)
-    if not success:
-        raise HTTPException(status_code=404, detail="Collection not found")
-    return {"message": "Collection deleted successfully"}
-
-
-@router.post("/{collection_id}/refresh", response_model=dict)
-async def refresh_collection(collection_id: str):
-    """Refresh dynamic collection (re-evaluate query)."""
-    return {"message": "Collection refreshed successfully"}
-
-
-@router.post("/execute", response_model=List[dict])
-async def execute_query(query_expression: dict):
-    """Execute query and return result set."""
-    return mock_execute_query(query_expression)
\ No newline at end of file
+class CollectionManager:
+    """Collection management helper."""
+    
+    @staticmethod
+    def get_collection(collection_id: str) -> Optional[Collection]:
+        """Get collection by ID."""
+        db = get_db()
+        try:
+            collection = db.query(Collection).filter(Collection.id == collection_id).first()
+            return collection
+        except Exception:
+            return None
+    
+    @staticmethod
+    def create_collection(data: CollectionCreate, request: Request) -> Collection:
+        """Create new collection."""
+        db = get_db()
+        
+        collection = Collection(
+            name=data.name,
+            description=data.description,
+            query_type=data.query_type,
+            query_expression=data.query_expression,
+            is_public=data.is_public,
+            tags=TagCollection(tags=data.tags or []),
+        )
+        
+        db.add(collection)
+        db.commit()
+        db.refresh(collection)
+        
+        # Create audit log
+        user = get_current_user(request)
+        try:
+            audit = AuditLog(
+                action="create",
+                entity_type="Collection",
+                entity_id=collection.id,
+                old_value=None,
+                new_value=collection.dict(),
+                user_id=user.get("id")
+            )
+            db.add(audit)
+            db.commit()
+        except Exception:
+            pass
+        
+        return collection
+    
+    @staticmethod
+    def update_collection(collection_id: str, data: CollectionUpdate, request: Request) -> Optional[Collection]:
+        """Update collection."""
+        db = get_db()
+        
+        collection = db.query(Collection).filter(Collection.id == collection_id).first()
+        
+        if not collection:
+            return None
+        
+        # Update fields
+        for field_name, value in data.dict().items():
+            if value is not None:
+                if hasattr(collection, field_name):
+                    setattr(collection, field_name, value)
+                elif field_name == "tags":
+                    if isinstance(value, list):
+                        collection.tags.add(*value)
+                    else:
+                        collection.tags.update(str(value))
+        
+        db.commit()
+        db.refresh(collection)
+        
+        # Create audit log
+        user = get_current_user(request)
+        try:
+            audit = AuditLog(
+                action="update",
+                entity_type="Collection",
+                entity_id=collection_id,
+                old_value=collection.dict(),
+                new_value=collection.dict(),
+                user_id=user.get("id")
+            )
+            db.add(audit)
+            db.commit()
+        except Exception:
+            pass
+        
+        return collection
+    
+    @staticmethod
+    def delete_collection(collection_id: str, request: Request) -> dict:
+        """Delete collection."""
+        db = get_db()
+        
+        collection = db.query(Collection).filter(Collection.id == collection_id).first()
+        
+        if not collection:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Collection not found")
+        
+        db.delete(collection)
+        db.commit()
+        
+        # Create audit log
+        user = get_current_user(request)
+        try:
+            audit = AuditLog(
+                action="delete",
+                entity_type="Collection",
+                entity_id=collection_id,
+                old_value=collection.dict(),
+                new_value=None,
+                user_id=user.get("id")
+            )
+            db.add(audit)
+            db.commit()
+        except Exception:
+            pass
+        
+        return {"message": "Collection deleted successfully", "deleted_id": collection_id}
+    
+    @staticmethod
+    def get_collection_tags(collection_id: str) -> List[str]:
+        """Get collection tags."""
+        db = get_db()
+        
+        collection = db.query(Collection).filter(Collection.id == collection_id).first()
+        
+        if not collection:
+            return []
+        
+        return list(collection.tags)
+    
+    @staticmethod
+    def get_collection_bookmarks(collection_id: str, limit: int = 50, offset: int = 0) -> List[Bookmark]:
+        """
+        Get bookmarks for collection (static or dynamic).
+        
+        For dynamic collections with query expression:
+        Use query executor to parse and filter bookmarks
+        """
+        db = get_db()
+        
+        collection = db.query(Collection).filter(Collection.id == collection_id).first()
+        
+        if not collection:
+            return []
+        
+        if collection.query_type == "static":
+            # Static collection: get all bookmarks
+            bookmarks = db.query(Bookmark).filter(Bookmark.collection_id == collection_id).limit(limit).offset(offset).all()
+        else:
+            # Dynamic collection: query expression
+            # TODO: Use query executor to parse expression (executor module)
+            bookmarks = db.query(Bookmark).limit(limit).offset(offset).all()
+        
+        return bookmarks
diff --git a/LinkSyncServer/api/endpoints/links.py b/LinkSyncServer/api/endpoints/links.py
index e52c809..d46b0e2 100644
--- a/LinkSyncServer/api/endpoints/links.py
+++ b/LinkSyncServer/api/endpoints/links.py
@@ -1,36 +1,46 @@
 """
-LinkSyncServer - Link CRUD Endpoints
+LinkSyncServer - Link CRUD Endpoints with SQLAlchemy
 """
 
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends, HTTPException, status, Query, Request
+from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy import func, or_
 from typing import List, Optional
 import uuid
+import logging
+import hashlib
+
+from models.base import Base, Bookmark, User, AuditLog, get_engine, create_engine
+from pydantic import BaseModel, Field
+import os
 
 router = APIRouter(prefix="/api/links", tags=["Links"])
 
+# Logging
+logger = logging.getLogger(__name__)
+
 
 class BookmarkCreate(BaseModel):
-    url: str
-    title: str
-    description: Optional[str] = None
-    notes: Optional[str] = None
-    tags: Optional[List[str]] = None
-    favicon_url: Optional[str] = None
-    path: Optional[str] = None
-    visit_count: int = 0
-    is_bookmarked: bool = False
+    url: str = Field(..., description="Bookmark URL")
+    title: str = Field(..., min_length=1, max_length=255, description="Bookmark title")
+    description: Optional[str] = Field(None, max_length=500, description="Optional description")
+    notes: Optional[str] = Field(None, max_length=2000, description="Optional notes")
+    tags: Optional[List[str]] = Field(default_factory=list, description="List of tag names")
+    favicon_url: Optional[str] = Field(None, max_length=512, description="Favicon URL")
+    path: Optional[str] = Field(None, max_length=512, description="Folder path")
+    visit_count: int = Field(ge=0, description="Visit counter")
+    is_bookmarked: bool = Field(default=False, description="Bookmark flag")
 
 
 class BookmarkUpdate(BaseModel):
-    url: Optional[str] = None
-    title: Optional[str] = None
-    description: Optional[str] = None
-    notes: Optional[str] = None
-    tags: Optional[List[str]] = None
-    favicon_url: Optional[str] = None
-    path: Optional[str] = None
-    visit_count: Optional[int] = None
+    url: Optional[str] = Field(None, description="New URL")
+    title: Optional[str] = Field(None, min_length=1, max_length=255)
+    description: Optional[str] = Field(None, max_length=500)
+    notes: Optional[str] = Field(None, max_length=2000)
+    tags: Optional[List[str]] = Field(None)
+    favicon_url: Optional[str] = Field(None, max_length=512)
+    path: Optional[str] = Field(None, max_length=512)
+    visit_count: Optional[int] = Field(None, ge=0)
     is_bookmarked: Optional[bool] = None
 
 
@@ -48,128 +58,301 @@ class BookmarkResponse(BaseModel):
     visit_count: int
     is_bookmarked: bool
     source_set_id: Optional[str]
+    user_id: Optional[str]
 
 
-def get_db():
+def get_db_session():
     """Get database session."""
-    from models.base import get_engine
-    db = get_engine()
-    return db
+    try:
+        return sessionmaker(get_engine())()
+    except Exception:
+        return None
 
 
-def mock_create_bookmark(data: BookmarkCreate) -> dict:
-    """Create bookmark (mock implementation for demo)."""
-    bookmark = {
-        "id": str(uuid.uuid4()),
-        "url": data.url,
-        "title": data.title,
-        "description": data.description,
-        "notes": data.notes,
-        "tags": data.tags or [],
-        "favicon_url": data.favicon_url,
-        "path": data.path,
-        "created_at": "2026-05-11T00:00:00Z",
-        "updated_at": "2026-05-11T00:00:00Z",
-        "visit_count": data.visit_count,
-        "is_bookmarked": data.is_bookmarked,
-        "source_set_id": None
-    }
-    return bookmark
+def get_current_user(request: Request):
+    """Get current authenticated user."""
+    SECRET_KEY = os.environ.get("SECRET_KEY")
+    
+    auth_header = request.headers.get("Authorization") or request.headers.get("authorization")
+    
+    if auth_header and auth_header.startswith("Bearer "):
+        token = auth_header[7:]
+        try:
+            import jwt
+            payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
+            return {"username": payload.get("sub"), "id": payload.get("sub")}
+        except Exception:
+            pass
 
-
-def mock_get_bookmarks() -> List[dict]:
-    """Get all bookmarks (mock implementation)."""
-    return [
-        {
-            "id": str(uuid.uuid4()),
-            "url": "https://example.com",
-            "title": "Example",
-            "description": "An example website",
-            "notes": "",
-            "tags": ["example", "demo"],
-            "favicon_url": None,
-            "path": "/Home",
-            "created_at": "2026-05-11T00:00:00Z",
-            "updated_at": "2026-05-11T00:00:00Z",
-            "visit_count": 0,
-            "is_bookmarked": False,
-            "source_set_id": None
-        }
-    ]
-
-
-def mock_get_bookmark(bookmark_id: str) -> dict | None:
-    """Get single bookmark by ID."""
-    # Mock implementation
-    if bookmark_id == "mock-id":
-        return {
-            "id": "mock-id",
-            "url": "https://example.com",
-            "title": "Example",
-            "description": "An example website",
-            "notes": "",
-            "tags": ["example", "demo"],
-            "favicon_url": None,
-            "path": "/Home",
-            "created_at": "2026-05-11T00:00:00Z",
-            "updated_at": "2026-05-11T00:00:00Z",
-            "visit_count": 0,
-            "is_bookmarked": False,
-            "source_set_id": None
-        }
-    return None
-
-
-def mock_update_bookmark(bookmark_id: str, data: BookmarkUpdate) -> dict | None:
-    """Update bookmark."""
-    # Mock implementation
-    return mock_get_bookmark(bookmark_id)
-
-
-def mock_delete_bookmark(bookmark_id: str) -> bool:
-    """Delete bookmark."""
-    return True
+    return {"username": "guest"}
 
 
 @router.get("/", response_model=List[BookmarkResponse])
-async def list_bookmarks(limit: int = 20, offset: int = 0):
-    """List all bookmarks."""
-    bookmarks = mock_get_bookmarks()
-    return bookmarks[offset:offset + limit]
+async def list_bookmarks(
+    limit: int = Query(20, le=100, ge=1, description="Number of results per page"),
+    offset: int = Query(0, ge=0, description="Offset for pagination"),
+    search: Optional[str] = Query(None, description="Search query"),
+    tags_filter: Optional[List[str]] = Query(None, description="Filter by tags"),
+    path_filter: Optional[str] = Query(None, description="Filter by folder path")
+):
+    """List all bookmarks with optional filters."""
+    db = get_db_session()
+    if not db:
+        return []
+    
+    query = Bookmark.query
+    
+    # Search filter
+    if search:
+        query = query.filter((Bookmark.title.contains(search)) | 
+                            (Bookmark.description.contains(search)) | 
+                            (Bookmark.url.contains(search)))
+    
+    # Tag filter
+    if tags_filter:
+        or_clause = or_(*[Bookmark.tags.contains(tag) for tag in tags_filter])
+        query = query.filter(or_clause)
+    
+    # Path filter
+    if path_filter:
+        query = query.filter(Bookmark.path.contains(path_filter))
+    
+    bookmarks = query.limit(limit).offset(offset).all()
+    return bookmarks
 
 
 @router.get("/{bookmark_id}", response_model=BookmarkResponse)
 async def get_bookmark(bookmark_id: str):
     """Get bookmark by ID."""
-    bookmark = mock_get_bookmark(bookmark_id)
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
+    
+    bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
+    
     if not bookmark:
-        raise HTTPException(status_code=404, detail="Bookmark not found")
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
+    
     return bookmark
 
 
 @router.post("/", response_model=BookmarkResponse, status_code=status.HTTP_201_CREATED)
-async def create_bookmark(data: BookmarkCreate):
+async def create_bookmark(data: BookmarkCreate, request: Request):
     """Create new bookmark."""
-    bookmark = mock_create_bookmark(data)
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
+    
+    bookmark = Bookmark(
+        url=data.url,
+        title=data.title,
+        description=data.description,
+        notes=data.notes,
+        tags=data.tags or [],
+        favicon_url=data.favicon_url,
+        path=data.path,
+        visit_count=data.visit_count,
+        is_bookmarked=data.is_bookmarked
+    )
+    
+    bookmark_id = f"{data.url[:20]}-{uuid.uuid4()[:8]}"
+    bookmark = db.add(bookmark)
+    db.commit()
+    db.refresh(bookmark)
+    
+    # Get user for audit log
+    user = get_current_user(request)
+    
+    # Create audit log (optional)
+    try:
+        audit = AuditLog(
+            action="create",
+            entity_type="Bookmark",
+            entity_id=bookmark_id,
+            old_value=None,
+            new_value=bookmark.dict(),
+            user_id=user.get("id")
+        )
+        db.add(audit)
+        db.commit()
+    except Exception:
+        pass
+
     return bookmark
 
 
 @router.put("/{bookmark_id}", response_model=BookmarkResponse)
 async def update_bookmark(
     bookmark_id: str,
-    data: BookmarkUpdate
+    data: BookmarkUpdate,
+    request: Request
 ):
     """Update bookmark."""
-    bookmark = mock_update_bookmark(bookmark_id, data)
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
+    
+    bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
+    
     if not bookmark:
-        raise HTTPException(status_code=404, detail="Bookmark not found")
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
+    
+    # Update fields
+    for field_name, value in data.dict().items():
+        if value is not None:
+            setattr(bookmark, field_name, value)
+    
+    db.commit()
+    db.refresh(bookmark)
+    
+    # Get user for audit log
+    user = get_current_user(request)
+    
+    # Create audit log
+    try:
+        old_data = Bookmark(id=bookmark_id, url=bookmark.url, title=bookmark.title).dict()
+        audit = AuditLog(
+            action="update",
+            entity_type="Bookmark",
+            entity_id=bookmark_id,
+            old_value=old_data,
+            new_value=bookmark.dict(),
+            user_id=user.get("id")
+        )
+        db.add(audit)
+        db.commit()
+    except Exception:
+        pass
+
     return bookmark
 
 
 @router.delete("/{bookmark_id}", response_model=dict)
-async def delete_bookmark(bookmark_id: str):
+async def delete_bookmark(bookmark_id: str, request: Request):
     """Delete bookmark."""
-    success = mock_delete_bookmark(bookmark_id)
-    if not success:
-        raise HTTPException(status_code=404, detail="Bookmark not found")
-    return {"message": "Bookmark deleted successfully"}
\ No newline at end of file
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
+    
+    bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
+    
+    if not bookmark:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
+    
+    db.delete(bookmark)
+    db.commit()
+    
+    # Get user for audit log
+    user = get_current_user(request)
+    
+    # Create audit log
+    try:
+        audit = AuditLog(
+            action="delete",
+            entity_type="Bookmark",
+            entity_id=bookmark_id,
+            old_value=bookmark.dict(),
+            new_value=None,
+            user_id=user.get("id")
+        )
+        db.add(audit)
+        db.commit()
+    except Exception:
+        pass
+
+    return {"message": "Bookmark deleted successfully", "deleted_id": bookmark_id}
+
+
+@router.post("/{bookmark_id}/tags")
+async def add_tags(bookmark_id: str, tags: List[str], request: Request):
+    """Add tags to bookmark."""
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
+    
+    bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
+    
+    if not bookmark:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
+    
+    for tag in tags:
+        if tag.lower() not in [t.lower() for t in bookmark.tags]:
+            bookmark.tags.append(tag)
+    
+    db.commit()
+    db.refresh(bookmark)
+    
+    return bookmark
+
+
+@router.delete("/{bookmark_id}/tags")
+async def remove_tags(bookmark_id: str, tags_to_remove: List[str], request: Request):
+    """Remove tags from bookmark."""
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
+    
+    bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
+    
+    if not bookmark:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
+    
+    bookmark.tags = [t for t in bookmark.tags if t.lower() not in [tag.lower() for tag in tags_to_remove]]
+    
+    db.commit()
+    db.refresh(bookmark)
+    
+    return bookmark
+
+
+@router.get("/{bookmark_id}/stats")
+async def get_bookmark_stats(bookmark_id: str, request: Request):
+    """Get bookmark statistics."""
+    db = get_db_session()
+    
+    if not db:
+        return {}
+    
+    bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
+    
+    if not bookmark:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
+    
+    # Get visit count
+    visits = db.query("SELECT COUNT(*) FROM visits WHERE bookmark_id = :bookmark_id")
+    visit_count = visits.execute({"bookmark_id": bookmark_id})
+    
+    return {
+        "bookmark_id": bookmark_id,
+        "visit_count": visit_count[0][0],
+        "last_visited": visits.execute({"bookmark_id": bookmark_id})
+    }
+
+
+# Audit log helper (optional)
+def create_audit_log(action: str, entity_type: str, entity_id: str, old_value: dict, new_value: dict):
+    """Create audit log entry."""
+    db = get_db_session()
+    
+    if not db:
+        return
+    
+    try:
+        audit = AuditLog(
+            action=action,
+            entity_type=entity_type,
+            entity_id=entity_id,
+            old_value=old_value,
+            new_value=new_value,
+            ip_address=request.client.host if hasattr(request, 'client') and hasattr(request.client, 'host') else None
+        )
+        db.add(audit)
+        db.commit()
+    except Exception:
+        pass
\ No newline at end of file
diff --git a/LinkSyncServer/api/endpoints/tags.py b/LinkSyncServer/api/endpoints/tags.py
new file mode 100644
index 0000000..620a003
--- /dev/null
+++ b/LinkSyncServer/api/endpoints/tags.py
@@ -0,0 +1,188 @@
+"""
+LinkSyncServer - Tag Management Endpoints
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status, Query
+from sqlalchemy.orm import Session
+from typing import List, Optional
+import logging
+import uuid
+
+from models.base import Base, Tag, Bookmark, get_engine
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix="/api/tags", tags=["Tags"])
+
+
+class TagCreate(BaseModel):
+    name: str = Field(..., min_length=1, max_length=50)
+    color: Optional[str] = Field(None, max_length=7)
+
+
+class TagUpdate(BaseModel):
+    name: Optional[str] = Field(None)
+    color: Optional[str] = Field(None)
+
+
+class TagResponse(BaseModel):
+    id: str
+    name: str
+    color: Optional[str]
+    created_at: str
+    updated_at: str
+
+
+def get_db_session():
+    """Get database session."""
+    try:
+        return Session(get_engine())
+    except Exception:
+        return None
+
+
+def get_current_user(request):
+    """Get current authenticated user."""
+    SECRET_KEY = None
+    
+    try:
+        auth_header = request.headers.get("Authorization") or request.headers.get("authorization")
+        
+        if auth_header and auth_header.startswith("Bearer "):
+            token = auth_header[7:]
+            import jwt
+            payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
+            return {"username": payload.get("sub"), "id": payload.get("sub")}
+        elif not auth_header:
+            return {"username": "guest"}
+    except:
+        pass
+    
+    return {"username": "guest"}
+
+
+@router.get("/", response_model=List[TagResponse])
+async def list_tags(page: int = Query(1, ge=1), per_page: int = Query(50, ge=1, le=200)):
+    """List tags with pagination."""
+    db = get_db_session()
+    
+    if not db:
+        return []
+    
+    count = db.query(Tag).count()
+    tags = db.query(Tag).order_by(Tag.name).offset((page - 1) * per_page).limit(per_page).all()
+    
+    return tags
+
+
+@router.get("/count", response_model=dict)
+async def tag_count():
+    """Get total tag count."""
+    db = get_db_session()
+    
+    if not db:
+        return {"count": 0}
+    
+    return {"count": db.query(Tag).count()}
+
+
+@router.get("/{tag_id}", response_model=TagResponse)
+async def get_tag(tag_id: str):
+    """Get tag by ID."""
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=404, detail="Tag not found")
+    
+    tag = db.query(Tag).filter(Tag.id == tag_id).first()
+    
+    if not tag:
+        raise HTTPException(status_code=404, detail="Tag not found")
+    
+    return tag
+
+
+@router.get("/{tag_id}/links")
+async def get_tag_links(tag_id: str, limit: int = Query(50, ge=1), offset: int = Query(0, ge=0)):
+    """Get links for tag.""""
+    db = get_db_session()
+    
+    if not db:
+        return []
+    
+    tag = db.query(Tag).filter(Tag.id == tag_id).first()
+    
+    if not tag:
+        raise HTTPException(status_code=404, detail="Tag not found")
+    
+    links = db.query(Bookmark).join(Tag).filter(Tag.id == tag_id).limit(limit).offset(offset).all()
+    
+    return links
+
+
+@router.post("/", response_model=TagResponse, status_code=201)
+async def create_tag(data: TagCreate, request):
+    """Create new tag."""
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=500, detail="Database unavailable")
+    
+    tag = Tag(
+        id=f"tag-{uuid.uuid4()[:8]}",
+        name=data.name,
+        color=data.color
+    )
+    
+    db.add(tag)
+    db.commit()
+    db.refresh(tag)
+    
+    return tag
+
+
+@router.put("/{tag_id}", response_model=TagResponse)
+async def update_tag(tag_id: str, data: TagUpdate):
+    """Update tag."""
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=500, detail="Database unavailable")
+    
+    tag = db.query(Tag).filter(Tag.id == tag_id).first()
+    
+    if not tag:
+        raise HTTPException(status_code=404, detail="Tag not found")
+    
+    for field_name in ["name", "color"]:
+        if field_name in data.dict() and data.dict()[field_name] is not None:
+            setattr(tag, field_name, data.dict()[field_name])
+    
+    db.commit()
+    db.refresh(tag)
+    
+    return tag
+
+
+@router.delete("/{tag_id}", response_model=dict)
+async def delete_tag(tag_id: str):
+    """Delete tag (and remove from all links)."""
+    db = get_db_session()
+    
+    if not db:
+        raise HTTPException(status_code=500, detail="Database unavailable")
+    
+    tag = db.query(Tag).filter(Tag.id == tag_id).first()
+    
+    if not tag:
+        raise HTTPException(status_code=404, detail="Tag not found")
+    
+    # Remove tag from all bookmarks
+    bookmarks = db.query(Bookmark).filter(Bookmark.tags.contains(tag.name)).all()
+    
+    for bookmark in bookmarks:
+        bookmark.tags = [t for t in bookmark.tags if t[0] != tag_id]
+    
+    db.delete(tag)
+    db.commit()
+    
+    return {"message": f"Tag '{tag.name}' deleted and removed from all links"}
diff --git a/LinkSyncServer/api/v1/sync.py b/LinkSyncServer/api/v1/sync.py
new file mode 100644
index 0000000..6f4c8bd
--- /dev/null
+++ b/LinkSyncServer/api/v1/sync.py
@@ -0,0 +1,151 @@
+"""
+LinkSyncServer - Sync Endpoint for Browser Extension
+"""
+
+from fastapi import APIRouter, HTTPException, status
+from typing import List, Dict
+import jwt
+import logging
+from datetime import datetime
+import json
+
+from models.base import Bookmark, Collection, get_engine
+from api.parsers.bookmarks import BookmarkParser
+from api.parsers.sync import SyncParser
+import os
+
+router = APIRouter(prefix="/api/v1/sync", tags=["Sync"])
+
+logger = logging.getLogger(__name__)
+
+# Get database and secrets
+DATABASE_URL = os.environ.get("DATABASE_URL", "sqlite:///links.db")
+SECRET_KEY = os.environ.get("SECRET_KEY", "fallback-for-dev")
+
+# Initialize parser
+bookmark_parser = BookmarkParser()
+sync_parser = SyncParser()
+
+
+def get_db_session():
+    """Get database session."""
+    from sqlalchemy.pool import StaticPool
+    from sqlalchemy.orm import Session
+    from sqlalchemy import create_engine
+    
+    engine = create_engine(
+        DATABASE_URL,
+        connect_args={'check_same_thread': False}
+    )
+    return Session(engine)
+
+
+def validate_request_token(request_token: str) -> Dict:
+    """
+    Validate sync request token.
+    
+    Accepts:
+    - Token header from extension
+    - No auth for demo/maintenance
+    """
+    if not request_token:
+        # Allow anonymous for demo
+        return {"type": "anonymous", "permissions": {}}
+    
+    try:
+        # Try to decode as JWT
+        payload = jwt.decode(request_token, SECRET_KEY, algorithms=["HS256"])
+        
+        # Check permissions
+        permissions = {
+            "collections": payload.get("permissions", {}).get("collections", []),
+            "bookmarks": payload.get("permissions", {}).get("bookmarks", [])
+        }
+        
+        return {
+            "type": "authorized",
+            "permissions": permissions
+        }
+    except Exception:
+        # Token invalid, fall back to anonymous
+        return {"type": "anonymous", "permissions": {}}
+
+
+def sync_with_github(account_id: str, collection_id: str, request_token: str) -> Dict:
+    """
+    Sync bookmarks from GitHub to local collection.
+    
+    Args:
+        account_id: GitHub account ID
+        collection_id: LinkSync collection ID
+        request_token: Token from extension request
+    
+    Returns:
+        Sync response (JSON payload for extension)
+    """
+    # Validate token
+    token_info = validate_request_token(request_token)
+    
+    if token_info["type"] != "authorized":
+        raise HTTPException(status_code=403, detail="Unauthorized access")
+    
+    # Get collection
+    db = get_db_session()
+    
+    collection = db.query(Collection).filter(Collection.id == collection_id).first()
+    
+    if not collection:
+        raise HTTPException(status_code=404, detail="Collection not found")
+    
+    # Make request to GitHub API (using library or requests)
+    try:
+        # GitHub API v3
+        # GET /users/{user_id}/starred
+        # Response: list of starred repositories and Gists (links)
+        
+        github_api_base = "https://api.github.com"
+        starred_response = requests.get(
+            f"{github_api_base}/users/{account_id}/starred",
+            headers={
+                "Accept": "application/vnd.github.v3+json"
+            }
+        )
+        
+        if starred_response.status_code != 200:
+            raise HTTPException(status_code=502, detail="Failed to fetch GitHub data")
+        
+        github_links = starred_response.json()
+        
+        # Parse GitHub data
+        github_bookmarks = sync_parser.parse_github_links(github_links)
+        
+        # Create/update/delete based on sync
+        changes = bookmark_parser.parse_sync(
+            github_bookmarks, collection_id
+        )
+        
+        # Commit changes
+        db.commit()
+        
+        # Build response
+        sync_response = {
+            "_links": {
+                "sync": {
+                    "_links": {
+                        "self": {}
+                    }
+                }
+            },
+            "meta": {
+                "account_id": account_id,
+                "collections": [collection_id],
+                "changes": changes,
+                "total_synced": len(github_links)
+            }
+        }
+        
+        return sync_response
+        
+    except Exception as e:
+        logger.error(f"Sync error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
diff --git a/LinkSyncServer/app.py b/LinkSyncServer/app.py
index 217c742..8904aaa 100644
--- a/LinkSyncServer/app.py
+++ b/LinkSyncServer/app.py
@@ -1,128 +1,18 @@
 """
 LinkSyncServer - Main Application
-
-FastAPI application for bookmark management with advanced collection
-and query capabilities.
 """
 
-from fastapi import FastAPI, Depends, HTTPException, status
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-from fastapi.responses import HTML, JSONResponse
-from pydantic import BaseModel
-from typing import Optional
-import os
-import secrets
-import logging
+from fastapi import FastAPI
+from routes import router as api_router
 
-# Configure logging
-logging.basicConfig(level=os.environ.get('LOG_LEVEL', 'INFO'))
-logger = logging.getLogger(__name__)
-
-# Create FastAPI app
 app = FastAPI(
     title="LinkSyncServer",
-    description="Self-hosted bookmark server with advanced collection capabilities",
+    description="Self-hosted bookmark server with collections",
     version="1.0.0",
 )
 
-# CORS configuration
-allow_origins = os.environ.get('CORS_ORIGINS', 'http://localhost:5555').split(',')
+app.include_router(api_router)
 
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=allow_origins,
-    allow_credentials=True,
-    allow_methods=['*'],
-    allow_headers=['*'],
-)
-
-# Static files
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# Templates
-app.mount(
-    "/templates",
-    StaticFiles(directory="templates"),
-    name="templates"
-)
-
-# Database configuration
-DATABASE_URL = os.environ.get('DATABASE_URL')
-SECRET_KEY = os.environ.get('SECRET_KEY', secrets.token_urlsafe(32))
-DEBUG = os.environ.get('DEBUG', 'False').lower() == 'true'
-HOST = os.environ.get('HOST', '0.0.0.0')
-PORT = int(os.environ.get('PORT', 5000))
-
-# CORS origins from environment
-CORS_ORIGINS = [o.strip() for o in os.environ.get('CORS_ORIGINS', 'http://localhost:5555').split(',')]
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=CORS_ORIGINS,
-    allow_credentials=True,
-    allow_methods=['*'],
-    allow_headers=['*'],
-)
-
-# Health check endpoint
 @app.get("/health")
-async def health_check():
-    """Health check endpoint for Docker monitoring."""
-    return {"status": "ok", "service": "LinkSyncServer"}
-
-# Root endpoint
-@app.get("/")
-async def root():
-    """Root endpoint with redirect to web UI."""
-    return HTML("""
-    <!DOCTYPE html>
-    <html>
-    <head><title>LinkSyncServer</title></head>
-    <body>
-        <h1>LinkSyncServer</h1>
-        <p>Web UI: <a href="/login">Login</a></p>
-        <p>API Docs: <a href="/api/docs">API Documentation</a></p>
-    </body>
-    </html>
-    """)
-
-# Error handler
-@app.exception_handler(Exception)
-async def global_exception_handler(request, exc):
-    logger.error(f"Exception: {exc}")
-    return JSONResponse(
-        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-        content={"detail": "Internal server error"}
-    )
-
-# Error handler for specific exceptions
-@app.exception_handler(HTTPException)
-async def http_exception_handler(request, exc):
-    return JSONResponse(
-        status_code=exc.status_code,
-        content={"detail": exc.detail}
-    )
-
-def get_api_key(user):
-    """Get API key from database for a user."""
-    return None
-
-async def get_current_user(token: Optional[str] = None):
-    """Get current authenticated user."""
-    if token:
-        # Validate JWT token
-        # In production, implement proper JWT validation
-        pass
-    return None
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(
-        "app:app",
-        host=HOST,
-        port=PORT,
-        reload=DEBUG
-    )
\ No newline at end of file
+def health():
+    return {"status": "ok"}
\ No newline at end of file
diff --git a/LinkSyncServer/models/__init__.py b/LinkSyncServer/models/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/LinkSyncServer/queries/executor.py b/LinkSyncServer/queries/executor.py
new file mode 100644
index 0000000..c404e19
--- /dev/null
+++ b/LinkSyncServer/queries/executor.py
@@ -0,0 +1,220 @@
+"""
+LinkSyncServer - Query Executor
+"""
+
+from typing import List, Dict, Any, Optional
+from sqlalchemy.orm import Session
+from sqlalchemy import func, and_, or_
+import logging
+import sys
+sys.path.insert(0, 'models')
+from base import Bookmark, User
+
+logger = logging.getLogger(__name__)
+
+
+def parse_query_expression(query_expression: dict, expressions: list = None) -> Dict[str, Any]:
+    """
+    Parse query expression in dict format.
+    
+    Example:
+    {
+        "operation": "OR",
+        "operands": [
+            {"operation": "TERM", "value": "work"},
+            {"operation": "TERM", "value": "company"}
+        ]
+    }
+    """
+    if not query_expression:
+        return
+    
+    operation = query_expression.get('operation')
+    operands = query_expression.get('operands', [])
+    
+    if not operands:
+        # Top-level expression (e.g., TERM)
+        if operation == 'TERM':
+            value = query_expression.get('value', '')
+            if value.startswith('url:'):
+                search_term = value[4:]
+                return parse_term(search_term, 'url')
+            elif value.startswith('tag:'):
+                search_term = value[4:]
+                return parse_term(search_term, 'tags')
+            elif value.startswith('title:'):
+                search_term = value[6:]
+                return parse_term(search_term, 'title')
+            elif value.startswith('description:'):
+                search_term = value[12:]
+                return parse_term(search_term, 'description')
+            elif value.startswith('id:'):
+                return {'operation': 'EQUALS', 'value': value[3:]}
+            else:
+                # Default: search title and description
+                return {'operation': 'OR', 'operands': [
+                    {'operation': 'TERM', 'value': value, 'field': 'title'},
+                    {'operation': 'TERM', 'value': value, 'field': 'description'}
+                ]}
+
+
+def parse_term(term: str, field: str):
+    """
+    Parse field:value term.
+    
+    Returns SQLAlchemy filter clause.
+    """
+    # Handle different field types
+    field_filters = {
+        'tags': lambda term: and_(*[Bookmark.tags.ilike(f'%{term}%') for tag in term.split(',')]),
+        'title': lambda term: Bookmark.title.ilike(f'%{term}%'),
+        'description': lambda term: Bookmark.description.ilike(f'%{term}%'),
+        'url': lambda term: Bookmark.url.ilike(f'%{term}%'),
+        'path': lambda term: Bookmark.path.ilike(f'%{term}%')
+    }
+    
+    # Get filter function
+    filter_fn = field_filters.get(field, lambda term: Bookmark.tags.ilike(f'%{term}%'))
+    
+    # Apply filter
+    filter_clause = filter_fn(term)
+    
+    # Return filter clause with field
+    return {'field': field, 'value': term, 'clause': filter_clause}
+
+
+def parse_or_filter(operators: list, operands: list) -> Any:
+    """
+    Parse OR filter.
+    
+    Operators: ['AND', 'OR', 'XOR']
+    """
+    if not operands:
+        return False
+    
+    # Default to AND for safety
+    op_type = operators[0] if operators else 'AND'
+    
+    if op_type == 'OR':
+        return or_(*[parse_and_filter(operators[1:], operands[1:]) for _ in range(1)])
+    elif op_type == 'AND':
+        return and_(*[parse_and_filter(operators[1:], operands[1:]) for _ in range(1)])
+    else:
+        # XOR: not supported yet
+        raise ValueError("XOR not supported")
+
+
+def parse_and_filter(operands: list) -> Any:
+    """Parse AND filter (default)."""
+    if not operands:
+        return False
+    
+    # Parse each operand
+    clauses = []
+    for operand in operands:
+        if isinstance(operand, str):
+            clause = operand
+        elif isinstance(operand, dict):
+            if operand.get('operation') == 'EQUALS':
+                clause = operand['value']
+            elif operand.get('operation') == 'TERM':
+                clauses.append(parse_term(operand.get('value', ''), operand.get('field', 'tags')))
+            # Add other term types as needed
+            else:
+                clauses.append(operand)
+        else:
+            raise ValueError(f"Unknown operand type: {type(operand)}")
+    
+    if not clauses:
+        return False
+    
+    return clauses
+
+
+def execute_query(query_expression: dict) -> List[Dict[str, Any]]:
+    """
+    Execute query and return results.
+    
+    query_expression: dict from parser
+    returns: list of bookmarks
+    """
+    # Default session
+    session = Session()
+    
+    if not query_expression:
+        return []
+    
+    # Parse query expression
+    try:
+        # Handle single-term queries
+        if query_expression.get('operation') == 'TERM':
+            search_term = query_expression.get('value', '')
+            field = query_expression.get('field', 'title')
+            
+            if field == 'tags':
+                tags = search_term.split(',')
+                filters = [Bookmark.tags.contains(tag) for tag in tags]
+                result = session.query(Bookmark).filter(or_(*filters)).all()
+            elif field == 'title':
+                result = session.query(Bookmark).filter(Bookmark.title.contains(search_term)).all()
+            elif field == 'description':
+                result = session.query(Bookmark).filter(Bookmark.description.contains(search_term)).all()
+            elif field == 'url':
+                result = session.query(Bookmark).filter(Bookmark.url.contains(search_term)).all()
+            else:
+                # Default: search title and description
+                filters = [
+                    or_(Bookmark.title.contains(search_term), 
+                        Bookmark.description.contains(search_term))
+                ]
+                result = session.query(Bookmark).filter(or_(*filters)).all()
+        elif query_expression.get('operation') == 'AND':
+            # AND clause
+            clauses = parse_and_filter(query_expression.get('operands', []))
+            if isinstance(clauses, list):
+                result = session.query(Bookmark).filter(and_(*clauses)).all()
+            else:
+                result = session.query(Bookmark).filter(clauses).all()
+        else:
+            # Default: search title and description
+            search_term = query_expression.get('value', '')
+            result = session.query(Bookmark).filter(
+                or_(Bookmark.title.contains(search_term), 
+                    Bookmark.description.contains(search_term))
+            ).all()
+    
+    except Exception as e:
+        logger.error(f"Query execution error: {e}")
+        result = []
+    
+    return result
+
+
+def create_bookmarks_from_sync(sync_data: dict):
+    """
+    Create bookmarks from sync response.
+    
+    sync_data: dict from GitHub API
+    """
+    if not sync_data:
+        return []
+    
+    # Parse sync JSON
+    sync_info = sync_data.get('_links', {}).get('sync', {}).get('_links', {})
+    
+    # Extract bookmarks
+    bookmarks = []
+    if 'objects' in sync_data:
+        for obj in sync_data['objects']:
+            if 'title' in obj:
+                bookmarks.append({
+                    'url': obj.get('url', ''),
+                    'title': obj.get('title', ''),
+                    'description': obj.get('description', ''),
+                    'tags': obj.get('tags', []),
+                    'favicon_url': obj.get('favicon_url', ''),
+                    'path': obj.get('path', ''),
+                    'visit_count': obj.get('visit_count', 0)
+                })
+    
+    return bookmarks
diff --git a/LinkSyncServer/queries/parser.py b/LinkSyncServer/queries/parser.py
new file mode 100644
index 0000000..1dc45b9
--- /dev/null
+++ b/LinkSyncServer/queries/parser.py
@@ -0,0 +1,351 @@
+"""
+LinkSyncServer - Query Parser for Expression Parser
+"""
+
+import re
+from typing import Union, Dict, List, Any
+from enum import Enum
+
+
+class TokenType(Enum):
+    OPERATOR = "OPERATOR"
+    TERM = "TERM"
+    VALUE = "VALUE"
+    LPAREN = "LPAREN"
+    RPAREN = "RPAREN"
+
+
+class Token:
+    def __init__(self, token_type: TokenType, value: Any, line: int = 0, column: int = 0):
+        self.type = token_type
+        self.value = value
+        self.line = line
+        self.column = column
+
+    def __repr__(self):
+        return f"Token({self.type.value}, {self.value!r})"
+
+
+class QuerySyntaxError(Exception):
+    """Syntax error in query expression."""
+    def __init__(self, message: str, line: int = None, column: int = None):
+        self.message = message
+        self.line = line
+        self.column = column
+        super().__init__(f"{message} at line {line}, column {column}" if line and column else message)
+
+
+def lex(expression: str) -> List[Token]:
+    """
+    Lexical analysis - convert string to tokens.
+    
+    Grammar:
+    expression  := query_item (OP query_item)*
+    query_item := (expression) | value | term
+    term := OP | value
+    value := url:value | tag:value | title:value | description:value | id:value
+    """
+    tokens = []
+    pos = 0
+    
+    # Operators
+    operators = ['AND', 'OR', 'XOR']
+    
+    while pos < len(expression):
+        # Skip whitespace
+        if expression[pos].isspace():
+            pos += 1
+            continue
+        
+        # Check for parentheses
+        if expression[pos] == '(':
+            tokens.append(Token(TokenType.LPAREN, '('))
+            pos += 1
+            continue
+        
+        if expression[pos] == ')':
+            tokens.append(Token(TokenType.RPAREN, ')'))
+            pos += 1
+            continue
+        
+        # Check for operators (AND, OR, XOR)
+        if expression[pos:pos+4] == 'AND':
+            tokens.append(Token(TokenType.OPERATOR, 'AND'))
+            pos += 4
+            continue
+        
+        if expression[pos:pos+3] == 'OR':
+            tokens.append(Token(TokenType.OPERATOR, 'OR'))
+            pos += 3
+            continue
+        
+        if expression[pos:pos+4] == 'XOR':
+            tokens.append(Token(TokenType.OPERATOR, 'XOR'))
+            pos += 4
+            continue
+        
+        # Check for url: prefix
+        if expression[pos:pos+4] == 'url:':
+            pos += 4
+            # Find end of URL
+            end = expression.find(':', pos)
+            if end == -1 and expression[pos] == '://':
+                # Find end of URL (next space or end of string)
+                end = expression.find(' ', pos)
+                if end == -1:
+                    end = len(expression)
+            
+            tokens.append(Token(TokenType.TERM, expression[pos:end]))
+            pos = end
+            continue
+        
+        # Check for tag: prefix
+        if expression[pos:pos+5] == 'tag:':
+            pos += 5
+            end = expression.find(':', pos)
+            if end == -1:
+                end = len(expression)
+            tokens.append(Token(TokenType.TERM, expression[pos:end]))
+            pos = end
+            continue
+        
+        # Check for title: or description: prefixes
+        if expression[pos:pos+6] in ['title:', 'description:']:
+            field = 'title' if expression[pos:pos+6] == 'title:' else 'description'
+            pos += 6
+            end = expression.find(':', pos)
+            if end == -1 and expression[pos] == ':' :
+                end = len(expression)
+            
+            tokens.append(Token(TokenType.TERM, expression[pos:end]))
+            pos = end
+            continue
+        
+        # Check for colon (key:value)
+        if expression[pos] == ':':
+            pos += 1
+            # Get field name (key)
+            field = expression[pos]
+            pos += 1
+            # Get value
+            end = expression.find(' ', pos)
+            if end == -1:
+                end = len(expression)
+            token_val = expression[pos:end].strip('"\'')
+            tokens.append(Token(TokenType.VALUE, f'{field}:{token_val}'))
+            continue
+        
+        # Regular term - alphanumeric
+        if expression[pos].isalnum() or expression[pos] in '-_':
+            start = pos
+            while pos < len(expression) and (expression[pos].isalnum() or expression[pos] in '-_./?=?&'):
+                pos += 1
+            tokens.append(Token(TokenType.TERM, expression[start:pos]))
+            continue
+        
+        # Unknown character - skip or error
+        pos += 1
+    
+    return tokens
+
+
+class ASTNode:
+    """Abstract Syntax Tree Node."""
+    def __init__(self, operator: str, children: List[Union[ASTNode, str, dict]] = None):
+        self.operator = operator
+        self.children = children if children else []
+    
+    def __repr__(self):
+        return f"AST({self.operator}, {self.children})"
+
+
+def parse_operator(token: Token) -> str:
+    """Convert operator token to Python operator string."""
+    if token.type != TokenType.OPERATOR:
+        raise QuerySyntaxError(f"Expected operator, got {token.value}")
+    
+    if token.value == 'AND':
+        return 'and'
+    elif token.value == 'OR':
+        return 'or'
+    elif token.value == 'XOR':
+        return 'xor'
+    else:
+        raise QuerySyntaxError(f"Unknown operator: {token.value}")
+
+
+class QueryParser:
+    """Parser for query expressions."""
+    
+    def __init__(self):
+        self.tokens = []
+        self.pos = 0
+        self.current_token = None
+        self.error = False
+        
+    def error(self, message: str):
+        """Record and return error."""
+        self.error = True
+        return QuerySyntaxError(message)
+    
+    def parse_expression(self) -> List[ASTNode]:
+        """Parse top-level expression (list of clauses)."""
+        if not self.tokens:
+            return []
+        
+        expressions = []
+        
+        # Parse first clause
+        expr = self.parse_or()
+        if expr:
+            expressions.append(expr)
+        
+        # Parse remaining clauses
+        while self.current_token and self.current_token.value in ['AND', 'OR', 'XOR']:
+            operator = self.current_token.value
+            self.pos += 1
+            expressions.append(operator)
+            expr2 = self.parse_or()
+            if expr2:
+                expressions.append(expr2)
+        
+        return expressions
+    
+    def parse_or(self) -> Union[ASTNode, None]:
+        """Parse OR clause."""
+        if not self.current_token:
+            return None
+        
+        return self.parse_and()
+    
+    def parse_and(self) -> Union[ASTNode, None]:
+        """Parse AND clause."""
+        left = self.parse_xor()
+        
+        while self.current_token and self.current_token.value == 'OR':
+            operator = self.parse_operator(self.current_token)
+            right = self.parse_xor()
+            left = ASTNode(operator, [left, right])
+        
+        return left
+    
+    def parse_xor(self) -> Union[ASTNode, None]:
+        """Parse XOR clause."""
+        left = self.parse_term()
+        
+        while self.current_token and self.current_token.value == 'AND':
+            operator = self.parse_operator(self.current_token)
+            right = self.parse_term()
+            left = ASTNode(operator, [left, right])
+        
+        return left
+    
+    def parse_term(self):
+        """Parse term."""
+        if self.error:
+            return None
+        
+        if self.pos >= len(self.tokens):
+            return None
+        
+        token = self.current_token
+        
+        # Check for parentheses (subexpression)
+        if token and token.value == '(':
+            self.pos += 1
+            self.current_token = self.tokens[self.pos] if self.pos < len(self.tokens) else None
+            sub_expr = self.parse_expression()
+            if not sub_expr and not self.error:
+                return None
+            if self.error:
+                return None
+            if self.current_token and self.current_token.value == ')':
+                self.pos += 1
+            return sub_expr
+        elif token and token.value != ')':
+            return token
+    
+    def parse_value(self) -> Union[None, str]:
+        """Parse value term."""
+        if self.error:
+            return None
+        
+        token = self.current_token
+        if not token or token.type != TokenType.TERM:
+            return None
+        
+        # Extract URL, TAG, etc.
+        term = token.value
+        
+        # Check for url: value
+        if term.startswith('url:'):
+            query = {'operation': 'TERM', 'value': term[4:]}
+            self.pos += 1
+            self.current_token = self.tokens[self.pos] if self.pos < len(self.tokens) else None
+            return query
+        elif term.startswith('tag:'):
+            query = {'operation': 'TERM', 'value': term[4:]}
+            self.pos += 1
+            self.current_token = self.tokens[self.pos] if self.pos < len(self.tokens) else None
+            return query
+        elif term.startswith('title:'):
+            query = {'operation': 'TERM', 'value': term[6:]}
+            self.pos += 1
+            self.current_token = self.tokens[self.pos] if self.pos < len(self.tokens) else None
+            return query
+        elif term.startswith('description:'):
+            query = {'operation': 'TERM', 'value': term[12:]}
+            self.pos += 1
+            self.current_token = self.tokens[self.pos] if self.pos < len(self.tokens) else None
+            return query
+        elif term.startswith('id:'):
+            query = {'operation': 'EQUALS', 'value': term[3:]}
+            self.pos += 1
+            self.current_token = self.tokens[self.pos] if self.pos < len(self.tokens) else None
+            return query
+        elif term.startswith('"') or term.startswith("'"):
+            # Direct value
+            return term
+        else:
+            self.error(f"Unknown term: {term}")
+            return None
+    
+    def parse(self, expression: str) -> List[ASTNode]:
+        """Parse complete expression."""
+        if not expression:
+            return []
+        
+        # Check for empty expression
+        if not expression.strip():
+            return []
+        
+        # Lexical analysis
+        self.tokens = lex(expression)
+        self.pos = 0
+        self.current_token = self.tokens[0] if self.tokens else None
+        
+        if not self.tokens:
+            return []
+        
+        # Parse expression into AST
+        expr = self.parse_expression()
+        
+        # Return AST as dict
+        return [self.ast_to_dict(node) for node in expr] if expr else []
+    
+    def ast_to_dict(self, node, indent=0):
+        """Convert AST node to dict representation."""
+        if isinstance(node, ASTNode):
+            if node.children:
+                return {
+                    "operation": node.operator,
+                    "operands": [self.ast_to_dict(child, indent + 1) for child in node.children]
+                }
+            else:
+                return node.value
+        elif isinstance(node, str):
+            return node
+        elif isinstance(node, dict):
+            return node
+        else:
+            return str(node)
\ No newline at end of file
diff --git a/TicTacGaming/ministral-3-14b/vite.config.ts b/TicTacGaming/ministral-3-14b/vite.config.ts
new file mode 100644
index 0000000..94b12e1
--- /dev/null
+++ b/TicTacGaming/ministral-3-14b/vite.config.ts
@@ -0,0 +1,20 @@
+import path from 'path'
+import { defineConfig } from 'vite'
+
+const config = defineConfig({
+  base: './', 
+  resolve: {
+    alias: {
+      '@/game': path.resolve('./src', 'game.ts'),
+      '@/ui': path.resolve('./src', 'ui.ts')
+    }},
+  build: {
+    outDir: 'dist',
+    emptyOutDir: true,
+    rollupOptions: {
+      input: { main: './index.html' },
+    }
+  }
+})
+
+export default config
diff --git a/TicTacToe-Compare/cogito-14b/game.js b/TicTacToe-Compare/cogito-14b/game.js
new file mode 100644
index 0000000..ab105be
--- /dev/null
+++ b/TicTacToe-Compare/cogito-14b/game.js
@@ -0,0 +1,21 @@
+/* Modern Tic Tac Toe JavaScript file
+ * Copyright (c) David, 2024. */
+ 
+// Get DOM elementsconst gridContainer = document.getElementById('board');
+const squareButtons = Array.from(document.querySelectorAll('#board button'));
+ 
+class Game {
+    constructor() {
+        this.board = [
+            [], [], []
+        ];
+        this.gameOver = false;
+        this.currentPlayer = '';
+        this.movesCount = 0;
+        // Initialize game board squares
+        squareButtons.forEach(
+            (btn, idx) => (
+                btn.addEventListener('click', () => { if(this.moveIsValid(idx)) 
+                    this.updateBoard({cell:btn,squareIndex:idx,mark:'X'}); 
+                 else alert("Game is over");}
+))))}}
\ No newline at end of file
diff --git a/TicTacToe-Compare/cogito-14b/index.html b/TicTacToe-Compare/cogito-14b/index.html
new file mode 100644
index 0000000..23636aa
--- /dev/null
+++ b/TicTacToe-Compare/cogito-14b/index.html
@@ -0,0 +1,18 @@
+!<!DOCTYPE html>>
+<html lang="en">
+  <head>
+    <title>Modern Tic-Tac-Toe</title>
+    <link rel = "stylesheet" href = "styles.css">
+  </head>
+  <body>
+    <main class="game-container">
+      <!-- Displays coin flip banner -->
+
+    <header>
+        <h1 id="banner">Coin Flip...</div></h1>
+    </header> 
+    <table id="board" class="ttt-game-board">
+    <tr>
+      <col><button id='cell-0' data-square-index='0'>\<button></col>
+      <col><button>...</button></div></td>
+</table>
\ No newline at end of file
diff --git a/TicTacToe-Compare/cogito-14b/styles.css b/TicTacToe-Compare/cogito-14b/styles.css
new file mode 100644
index 0000000..6440fbc
--- /dev/null
+++ b/TicTacToe-Compare/cogito-14b/styles.css
@@ -0,0 +1,127 @@
+/* Modern Tic Tac Toe style sheet
+ * Copyright (c) David, 2024. */
+ 
+h1 {
+    text-align: center;
+}
+html { height: 100%; background: radial-gradient(
+circle at top left, blue, deep navy);
+} body { margin: 0; min-height: 100vh; max-width:75vw; display: flex; 
+align-items: center; justify-content: center;
+}
+game-container {
+display: flex;
+column-gap: clamp(2ch,3%,4ch);
+padding-top: clamp(2em,2.5%,4em);
+flex-direction: column;
+height: auto;
+background: radial-gradient(
+circle at 0% -15%, 
+lavenderblush,
+dark gray
+);
+bord er-radius: rounded;
+box-shadow: drop-shadow(black .3em 2vw .75em);
+}
+#board {
+flex: 1 auto; display: grid; gap: 1em;
+avoid-blockness:
+grid-row-start, grid-column-start,
+gr id-Row-end, gridColumn-end;
+column-gap: clamp(2%,2ch,.86em);
+row-gap: clamp(1.5%,1vw,.76em); border: solid .4em dark green;padding-top: 0;
+padding-bottom: 0; padding-left: clamp(10px, 1%, 1.25em );padding-right: clamp(10px,1vw,1.5%);
+}
+td {
+position:relative;height:fit-content;
+min-height:.8375rem;justify-self: stretch;
+padding:clamp(.375ch,4vw,.8*0vh);align-items:center;d isplay:flex;
+align-items:center;width:100%;cursor:pointer;
+border-radius:
+calcl(var(--square-rad) - 10%
+sqrt( (var(--size) - var(--size)/2) * (var(--size)-var(-
+--size)/2)/10);
+border: none; background-color: transparent!important;
+onfocusout { border:none !important; outline:none!imp ortant}
+padding: clamp(.375rem, .6*.475em,.8*3vh); box-shadow:
+solid rgba(0, 0.2, 0.4999);
+border-left:solid transparent;
+column-gap:min(1ch,
+1vw);
+justify-content:center;align-contents: stretch;
+gradient(radial at center, white,light blue)}
+b::before {
+position:absolute;top:auto;left:1%;height:
+calc( 43% - var(--square-rad));width:
+each of the cells.
+solid;
+dynamic content here 
+z-index:-2;content:'';display:block}
+td:nth-child(even) &::before{width:calc(70% +.35em);
+height:clamp(
+ 1ch, (var(--grid-scale)), .87142rem);top:
+calc(var(--square-rad)*-0.5 * -9%)
+}
+td:nth-child(even):hover::before{width:calc( var(--square-rad)});
+b:hover { box-shadow:none;transform :clamp(  
+scale(1.3));z-index:2;
+backface-visibility:auto; transition: transform .1s ease
+out cubic-bezier(.68, -.61, .57,.94);
+perspective:.01*2em!important;}
+.square {
+cursor:pointer;width:
+clamp( 5vw ,4ch,40vh);height:clamp(3.59vw,9ch,3.795em)
+}/*cell animations*/
+.animating-move {
+anotation-transform:"translateZ(0)"; 
+perspective:.6em !important;
+transform-origin:center center !important;}/*game status*/}#statsContainer {position:fixed bottom:2rem left: .3% 
+bottom: calc(.48 vw +3.57  rem);padding-bottom.calc(.1vmin+.3 vh);
+padding top:calc(2px * var(--unitSize) /0.76vw)*100%;
+display:fle d !important; background:radialgradient(
+light coral,goldenrod)
+l .5 ch .48em linear-gradient(90deg, rgba(0.35% 0%, 0%
+.64% 8%) calc(.475rem),transparent calc(.211em) );
+border-radius:calc( clamp( 1vh,.4*1vw . 16 rem)); box-shadow:none 
+solid silver
+,rgba(0,0,3%,10) 3.997px)
+
+z-index:clamp(100%,2em,54); transition:.8 s ease-in-out;
+column-gap;calc(.5 %  .66em ); row gap calc(.6*
+, clamp(80px-.57*, 50vw) .66em)
+
+display:flex !important flex-direction:column flex-wrap wrap
+align-items flex-start;
+/*Game Stats & Messages*/}
+game-container #status-banner {
+--animate-fraction:1; position:absolute;height 
+x;opacity:.65
+pointer-events:none;visibility:hidden;z-index:61
+callback with a .7rem gap; padding 0.2%.4 em 
+margin-top:clamp(1.38v h, .62 vh, -2%)
+backgrou nds:gold
+/*Banner Animations */
+tic-tac animation for the coin flip banner*/
+crossfade to show winner/caller after game ends etc.
+@keyframes coin-flip-anime {
+	only of frames 0%,100%
+{ 
+box-shadow:none;}35% {height: calc(2.347vw .6
+9 em);margin- top:.8rem
+}
+37.5% transform:none
+} animation coinflap-animate ease infinite 5s;}}
+/*Hover effects on cells*/:hover td {
+display:flex;
+align-items:center !important justify-content:center;
+css transition transform .2s ease-out cubic-bezier(.35, -0.71 ,  -.64);
+box-shadow:none;
+borders: solid .482px transparent;
+border-radius:.9em;--square-rad:var(--defaultSquareRad
+/*Grid Layout & Responsive Adjustments*/#board {
+display:block!important;
+grid-template_rows: repeat(3,var(--square-size))auto}
+@media ( max-width :768px){html {
+bord er-color:light brown;
+color:pale goldenrod; height:auto; background:white !important
+border:none } }
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/dist/index.html b/TicTacToe-Compare/ministral-3-14b/dist/index.html
new file mode 100644
index 0000000..48a1ef2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/dist/index.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Tic-Tac-Toe with AI</title>
+  <link rel="modulepreload" href="/game.ts">
+  <link rel="modulepreload" href="/ui.ts">
+  <style scoped src="styles.css"></style>
+</head>
+<body>
+  <div id="game-container">
+    <h1 id="logo">✖️ Tic-Tac-Toe ✖️</h1>
+    <div id="status" class="status"></div>
+    <div id="board"></div>
+    <p id="player-x">👤 X Player</p>
+    <p id="computer-o">🤖 O Computer</p>
+    <button id="replay">Play Again</button>
+  </div>
+          </script type="module" src="/ui.ts"></script>
+</body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/index.html b/TicTacToe-Compare/ministral-3-14b/index.html
new file mode 100644
index 0000000..48a1ef2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/index.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Tic-Tac-Toe with AI</title>
+  <link rel="modulepreload" href="/game.ts">
+  <link rel="modulepreload" href="/ui.ts">
+  <style scoped src="styles.css"></style>
+</head>
+<body>
+  <div id="game-container">
+    <h1 id="logo">✖️ Tic-Tac-Toe ✖️</h1>
+    <div id="status" class="status"></div>
+    <div id="board"></div>
+    <p id="player-x">👤 X Player</p>
+    <p id="computer-o">🤖 O Computer</p>
+    <button id="replay">Play Again</button>
+  </div>
+          </script type="module" src="/ui.ts"></script>
+</body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/create-vite b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/create-vite
new file mode 100644
index 0000000..1e66929
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/create-vite
@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../create-vite/index.js" "$@"
+else 
+  exec node  "$basedir/../create-vite/index.js" "$@"
+fi
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/create-vite.cmd b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/create-vite.cmd
new file mode 100644
index 0000000..b15494e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/create-vite.cmd
@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\create-vite\index.js" %*
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/create-vite.ps1 b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/create-vite.ps1
new file mode 100644
index 0000000..bb9096f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/create-vite.ps1
@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../create-vite/index.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../create-vite/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../create-vite/index.js" $args
+  } else {
+    & "node$exe"  "$basedir/../create-vite/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/cva b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/cva
new file mode 100644
index 0000000..1e66929
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/cva
@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../create-vite/index.js" "$@"
+else 
+  exec node  "$basedir/../create-vite/index.js" "$@"
+fi
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/cva.cmd b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/cva.cmd
new file mode 100644
index 0000000..b15494e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/cva.cmd
@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\create-vite\index.js" %*
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/cva.ps1 b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/cva.ps1
new file mode 100644
index 0000000..bb9096f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/cva.ps1
@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../create-vite/index.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../create-vite/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../create-vite/index.js" $args
+  } else {
+    & "node$exe"  "$basedir/../create-vite/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/nanoid b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/nanoid
new file mode 100644
index 0000000..46220bd
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/nanoid
@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
+else 
+  exec node  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
+fi
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/nanoid.cmd b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/nanoid.cmd
new file mode 100644
index 0000000..9c40107
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/nanoid.cmd
@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\nanoid\bin\nanoid.cjs" %*
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/nanoid.ps1 b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/nanoid.ps1
new file mode 100644
index 0000000..d8a4d7a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/nanoid.ps1
@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  } else {
+    & "node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/rolldown b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/rolldown
new file mode 100644
index 0000000..e7853ee
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/rolldown
@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../rolldown/bin/cli.mjs" "$@"
+else 
+  exec node  "$basedir/../rolldown/bin/cli.mjs" "$@"
+fi
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/rolldown.cmd b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/rolldown.cmd
new file mode 100644
index 0000000..1882f3e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/rolldown.cmd
@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\rolldown\bin\cli.mjs" %*
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/rolldown.ps1 b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/rolldown.ps1
new file mode 100644
index 0000000..145fb8e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/rolldown.ps1
@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../rolldown/bin/cli.mjs" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../rolldown/bin/cli.mjs" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../rolldown/bin/cli.mjs" $args
+  } else {
+    & "node$exe"  "$basedir/../rolldown/bin/cli.mjs" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/vite b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/vite
new file mode 100644
index 0000000..014463f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/vite
@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../vite/bin/vite.js" "$@"
+else 
+  exec node  "$basedir/../vite/bin/vite.js" "$@"
+fi
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/vite.cmd b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/vite.cmd
new file mode 100644
index 0000000..f62e966
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/vite.cmd
@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\vite\bin\vite.js" %*
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/vite.ps1 b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/vite.ps1
new file mode 100644
index 0000000..a7759bc
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.bin/vite.ps1
@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../vite/bin/vite.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../vite/bin/vite.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../vite/bin/vite.js" $args
+  } else {
+    & "node$exe"  "$basedir/../vite/bin/vite.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/.package-lock.json b/TicTacToe-Compare/ministral-3-14b/node_modules/.package-lock.json
new file mode 100644
index 0000000..c620ad7
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/.package-lock.json
@@ -0,0 +1,344 @@
+{
+  "name": "tictactoe",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@oxc-project/types": {
+      "version": "0.130.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.130.0.tgz",
+      "integrity": "sha512-ibD2usx9JRu7f5pu2tMKMI4cpA4NgXJQoYRP4pQ7Pxmn1l6k/53qWtQWZayhYy3X4QZkt90Ot+mJEaeXouio6Q==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.1.tgz",
+      "integrity": "sha512-INAycaWuhlOK3wk4mRHGsdgwYWmd9cChdPdE9bwWmy6rn9VqVNYNFGhOdXrofXUxwHIncSiPNb8tNm8knDVIeQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+      "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/create-vite": {
+      "version": "9.0.7",
+      "resolved": "https://registry.npmjs.org/create-vite/-/create-vite-9.0.7.tgz",
+      "integrity": "sha512-TyuOQvwX4i/QN9acJzC7wzM7FfC12/1XlH3+d05PeD7Kj5o4BObuq78fB1x84SrEoi5KcQOi+b9K3JV+PWNHvw==",
+      "license": "MIT",
+      "bin": {
+        "create-vite": "index.js",
+        "cva": "index.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.14",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.14.tgz",
+      "integrity": "sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rolldown": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.1.tgz",
+      "integrity": "sha512-X0KQHljNnEkWNqqiz9zJrGunh1B0HgOxLXvnFpCOcadzcy5qohZ3tqMEUg00vncoRovXuK3ZqCT9KnnKzoInFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/types": "=0.130.0",
+        "@rolldown/pluginutils": "^1.0.0"
+      },
+      "bin": {
+        "rolldown": "bin/cli.mjs"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "@rolldown/binding-android-arm64": "1.0.1",
+        "@rolldown/binding-darwin-arm64": "1.0.1",
+        "@rolldown/binding-darwin-x64": "1.0.1",
+        "@rolldown/binding-freebsd-x64": "1.0.1",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.0.1",
+        "@rolldown/binding-linux-arm64-gnu": "1.0.1",
+        "@rolldown/binding-linux-arm64-musl": "1.0.1",
+        "@rolldown/binding-linux-ppc64-gnu": "1.0.1",
+        "@rolldown/binding-linux-s390x-gnu": "1.0.1",
+        "@rolldown/binding-linux-x64-gnu": "1.0.1",
+        "@rolldown/binding-linux-x64-musl": "1.0.1",
+        "@rolldown/binding-openharmony-arm64": "1.0.1",
+        "@rolldown/binding-wasm32-wasi": "1.0.1",
+        "@rolldown/binding-win32-arm64-msvc": "1.0.1",
+        "@rolldown/binding-win32-x64-msvc": "1.0.1"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.16",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
+      "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/vite": {
+      "version": "8.0.13",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.13.tgz",
+      "integrity": "sha512-MFtjBYgzmSxmgA4RAfjIyXWpGe1oALnjgUTzzV7QLx/TKxCzjtMH6Fd9/eVK+5Fg1qNoz5VAwsmMs/NofrmJvw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "lightningcss": "^1.32.0",
+        "picomatch": "^4.0.4",
+        "postcss": "^8.5.14",
+        "rolldown": "1.0.1",
+        "tinyglobby": "^0.2.16"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.1.18",
+        "esbuild": "^0.27.0 || ^0.28.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "@vitejs/devtools": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    }
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/LICENSE
new file mode 100644
index 0000000..444bffc
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024-present VoidZero Inc. & Contributors
+Copyright (c) 2023 Boshen
+
+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.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/README.md
new file mode 100644
index 0000000..d5b248a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/README.md
@@ -0,0 +1,3 @@
+# Oxc Types
+
+Typescript definitions for Oxc AST nodes.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/package.json
new file mode 100644
index 0000000..94d442f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/package.json
@@ -0,0 +1,26 @@
+{
+  "name": "@oxc-project/types",
+  "version": "0.130.0",
+  "description": "Types for Oxc AST nodes",
+  "keywords": [
+    "AST",
+    "Parser"
+  ],
+  "homepage": "https://oxc.rs",
+  "bugs": "https://github.com/oxc-project/oxc/issues",
+  "license": "MIT",
+  "author": "Boshen and oxc contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oxc-project/oxc.git",
+    "directory": "npm/oxc-types"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/Boshen"
+  },
+  "files": [
+    "types.d.ts"
+  ],
+  "type": "module",
+  "types": "types.d.ts"
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/types.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/types.d.ts
new file mode 100644
index 0000000..c94c115
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@oxc-project/types/types.d.ts
@@ -0,0 +1,1912 @@
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_tools/src/generators/typescript.rs`.
+
+export interface Program extends Span {
+  type: "Program";
+  body: Array<Directive | Statement>;
+  sourceType: ModuleKind;
+  hashbang: Hashbang | null;
+  parent?: null;
+}
+
+export type Expression =
+  | BooleanLiteral
+  | NullLiteral
+  | NumericLiteral
+  | BigIntLiteral
+  | RegExpLiteral
+  | StringLiteral
+  | TemplateLiteral
+  | IdentifierReference
+  | MetaProperty
+  | Super
+  | ArrayExpression
+  | ArrowFunctionExpression
+  | AssignmentExpression
+  | AwaitExpression
+  | BinaryExpression
+  | CallExpression
+  | ChainExpression
+  | Class
+  | ConditionalExpression
+  | Function
+  | ImportExpression
+  | LogicalExpression
+  | NewExpression
+  | ObjectExpression
+  | ParenthesizedExpression
+  | SequenceExpression
+  | TaggedTemplateExpression
+  | ThisExpression
+  | UnaryExpression
+  | UpdateExpression
+  | YieldExpression
+  | PrivateInExpression
+  | JSXElement
+  | JSXFragment
+  | TSAsExpression
+  | TSSatisfiesExpression
+  | TSTypeAssertion
+  | TSNonNullExpression
+  | TSInstantiationExpression
+  | V8IntrinsicExpression
+  | MemberExpression;
+
+export interface IdentifierName extends Span {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export interface IdentifierReference extends Span {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export interface BindingIdentifier extends Span {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export interface LabelIdentifier extends Span {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export interface ThisExpression extends Span {
+  type: "ThisExpression";
+  parent?: Node;
+}
+
+export interface ArrayExpression extends Span {
+  type: "ArrayExpression";
+  elements: Array<ArrayExpressionElement>;
+  parent?: Node;
+}
+
+export type ArrayExpressionElement = SpreadElement | null | Expression;
+
+export interface ObjectExpression extends Span {
+  type: "ObjectExpression";
+  properties: Array<ObjectPropertyKind>;
+  parent?: Node;
+}
+
+export type ObjectPropertyKind = ObjectProperty | SpreadElement;
+
+export interface ObjectProperty extends Span {
+  type: "Property";
+  kind: PropertyKind;
+  key: PropertyKey;
+  value: Expression;
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
+  parent?: Node;
+}
+
+export type PropertyKey = IdentifierName | PrivateIdentifier | Expression;
+
+export type PropertyKind = "init" | "get" | "set";
+
+export interface TemplateLiteral extends Span {
+  type: "TemplateLiteral";
+  quasis: Array<TemplateElement>;
+  expressions: Array<Expression>;
+  parent?: Node;
+}
+
+export interface TaggedTemplateExpression extends Span {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
+  quasi: TemplateLiteral;
+  parent?: Node;
+}
+
+export interface TemplateElement extends Span {
+  type: "TemplateElement";
+  value: TemplateElementValue;
+  tail: boolean;
+  parent?: Node;
+}
+
+export interface TemplateElementValue {
+  raw: string;
+  cooked: string | null;
+}
+
+export type MemberExpression =
+  | ComputedMemberExpression
+  | StaticMemberExpression
+  | PrivateFieldExpression;
+
+export interface ComputedMemberExpression extends Span {
+  type: "MemberExpression";
+  object: Expression;
+  property: Expression;
+  optional: boolean;
+  computed: true;
+  parent?: Node;
+}
+
+export interface StaticMemberExpression extends Span {
+  type: "MemberExpression";
+  object: Expression;
+  property: IdentifierName;
+  optional: boolean;
+  computed: false;
+  parent?: Node;
+}
+
+export interface PrivateFieldExpression extends Span {
+  type: "MemberExpression";
+  object: Expression;
+  property: PrivateIdentifier;
+  optional: boolean;
+  computed: false;
+  parent?: Node;
+}
+
+export interface CallExpression extends Span {
+  type: "CallExpression";
+  callee: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
+  arguments: Array<Argument>;
+  optional: boolean;
+  parent?: Node;
+}
+
+export interface NewExpression extends Span {
+  type: "NewExpression";
+  callee: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
+  arguments: Array<Argument>;
+  parent?: Node;
+}
+
+export interface MetaProperty extends Span {
+  type: "MetaProperty";
+  meta: IdentifierName;
+  property: IdentifierName;
+  parent?: Node;
+}
+
+export interface SpreadElement extends Span {
+  type: "SpreadElement";
+  argument: Expression;
+  parent?: Node;
+}
+
+export type Argument = SpreadElement | Expression;
+
+export interface UpdateExpression extends Span {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  prefix: boolean;
+  argument: SimpleAssignmentTarget;
+  parent?: Node;
+}
+
+export interface UnaryExpression extends Span {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  argument: Expression;
+  prefix: true;
+  parent?: Node;
+}
+
+export interface BinaryExpression extends Span {
+  type: "BinaryExpression";
+  left: Expression;
+  operator: BinaryOperator;
+  right: Expression;
+  parent?: Node;
+}
+
+export interface PrivateInExpression extends Span {
+  type: "BinaryExpression";
+  left: PrivateIdentifier;
+  operator: "in";
+  right: Expression;
+  parent?: Node;
+}
+
+export interface LogicalExpression extends Span {
+  type: "LogicalExpression";
+  left: Expression;
+  operator: LogicalOperator;
+  right: Expression;
+  parent?: Node;
+}
+
+export interface ConditionalExpression extends Span {
+  type: "ConditionalExpression";
+  test: Expression;
+  consequent: Expression;
+  alternate: Expression;
+  parent?: Node;
+}
+
+export interface AssignmentExpression extends Span {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: AssignmentTarget;
+  right: Expression;
+  parent?: Node;
+}
+
+export type AssignmentTarget = SimpleAssignmentTarget | AssignmentTargetPattern;
+
+export type SimpleAssignmentTarget =
+  | IdentifierReference
+  | TSAsExpression
+  | TSSatisfiesExpression
+  | TSNonNullExpression
+  | TSTypeAssertion
+  | MemberExpression;
+
+export type AssignmentTargetPattern = ArrayAssignmentTarget | ObjectAssignmentTarget;
+
+export interface ArrayAssignmentTarget extends Span {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<AssignmentTargetMaybeDefault | AssignmentTargetRest | null>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export interface ObjectAssignmentTarget extends Span {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export interface AssignmentTargetRest extends Span {
+  type: "RestElement";
+  decorators?: [];
+  argument: AssignmentTarget;
+  optional?: false;
+  typeAnnotation?: null;
+  value?: null;
+  parent?: Node;
+}
+
+export type AssignmentTargetMaybeDefault = AssignmentTargetWithDefault | AssignmentTarget;
+
+export interface AssignmentTargetWithDefault extends Span {
+  type: "AssignmentPattern";
+  decorators?: [];
+  left: AssignmentTarget;
+  right: Expression;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export type AssignmentTargetProperty =
+  | AssignmentTargetPropertyIdentifier
+  | AssignmentTargetPropertyProperty;
+
+export interface AssignmentTargetPropertyIdentifier extends Span {
+  type: "Property";
+  kind: "init";
+  key: IdentifierReference;
+  value: IdentifierReference | AssignmentTargetWithDefault;
+  method: false;
+  shorthand: true;
+  computed: false;
+  optional?: false;
+  parent?: Node;
+}
+
+export interface AssignmentTargetPropertyProperty extends Span {
+  type: "Property";
+  kind: "init";
+  key: PropertyKey;
+  value: AssignmentTargetMaybeDefault;
+  method: false;
+  shorthand: false;
+  computed: boolean;
+  optional?: false;
+  parent?: Node;
+}
+
+export interface SequenceExpression extends Span {
+  type: "SequenceExpression";
+  expressions: Array<Expression>;
+  parent?: Node;
+}
+
+export interface Super extends Span {
+  type: "Super";
+  parent?: Node;
+}
+
+export interface AwaitExpression extends Span {
+  type: "AwaitExpression";
+  argument: Expression;
+  parent?: Node;
+}
+
+export interface ChainExpression extends Span {
+  type: "ChainExpression";
+  expression: ChainElement;
+  parent?: Node;
+}
+
+export type ChainElement = CallExpression | TSNonNullExpression | MemberExpression;
+
+export interface ParenthesizedExpression extends Span {
+  type: "ParenthesizedExpression";
+  expression: Expression;
+  parent?: Node;
+}
+
+export type Statement =
+  | BlockStatement
+  | BreakStatement
+  | ContinueStatement
+  | DebuggerStatement
+  | DoWhileStatement
+  | EmptyStatement
+  | ExpressionStatement
+  | ForInStatement
+  | ForOfStatement
+  | ForStatement
+  | IfStatement
+  | LabeledStatement
+  | ReturnStatement
+  | SwitchStatement
+  | ThrowStatement
+  | TryStatement
+  | WhileStatement
+  | WithStatement
+  | Declaration
+  | ModuleDeclaration;
+
+export interface Directive extends Span {
+  type: "ExpressionStatement";
+  expression: StringLiteral;
+  directive: string;
+  parent?: Node;
+}
+
+export interface Hashbang extends Span {
+  type: "Hashbang";
+  value: string;
+  parent?: Node;
+}
+
+export interface BlockStatement extends Span {
+  type: "BlockStatement";
+  body: Array<Statement>;
+  parent?: Node;
+}
+
+export type Declaration =
+  | VariableDeclaration
+  | Function
+  | Class
+  | TSTypeAliasDeclaration
+  | TSInterfaceDeclaration
+  | TSEnumDeclaration
+  | TSModuleDeclaration
+  | TSGlobalDeclaration
+  | TSImportEqualsDeclaration;
+
+export interface VariableDeclaration extends Span {
+  type: "VariableDeclaration";
+  kind: VariableDeclarationKind;
+  declarations: Array<VariableDeclarator>;
+  declare?: boolean;
+  parent?: Node;
+}
+
+export type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using";
+
+export interface VariableDeclarator extends Span {
+  type: "VariableDeclarator";
+  id: BindingPattern;
+  init: Expression | null;
+  definite?: boolean;
+  parent?: Node;
+}
+
+export interface EmptyStatement extends Span {
+  type: "EmptyStatement";
+  parent?: Node;
+}
+
+export interface ExpressionStatement extends Span {
+  type: "ExpressionStatement";
+  expression: Expression;
+  directive?: string | null;
+  parent?: Node;
+}
+
+export interface IfStatement extends Span {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate: Statement | null;
+  parent?: Node;
+}
+
+export interface DoWhileStatement extends Span {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+  parent?: Node;
+}
+
+export interface WhileStatement extends Span {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+  parent?: Node;
+}
+
+export interface ForStatement extends Span {
+  type: "ForStatement";
+  init: ForStatementInit | null;
+  test: Expression | null;
+  update: Expression | null;
+  body: Statement;
+  parent?: Node;
+}
+
+export type ForStatementInit = VariableDeclaration | Expression;
+
+export interface ForInStatement extends Span {
+  type: "ForInStatement";
+  left: ForStatementLeft;
+  right: Expression;
+  body: Statement;
+  parent?: Node;
+}
+
+export type ForStatementLeft = VariableDeclaration | AssignmentTarget;
+
+export interface ForOfStatement extends Span {
+  type: "ForOfStatement";
+  await: boolean;
+  left: ForStatementLeft;
+  right: Expression;
+  body: Statement;
+  parent?: Node;
+}
+
+export interface ContinueStatement extends Span {
+  type: "ContinueStatement";
+  label: LabelIdentifier | null;
+  parent?: Node;
+}
+
+export interface BreakStatement extends Span {
+  type: "BreakStatement";
+  label: LabelIdentifier | null;
+  parent?: Node;
+}
+
+export interface ReturnStatement extends Span {
+  type: "ReturnStatement";
+  argument: Expression | null;
+  parent?: Node;
+}
+
+export interface WithStatement extends Span {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+  parent?: Node;
+}
+
+export interface SwitchStatement extends Span {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: Array<SwitchCase>;
+  parent?: Node;
+}
+
+export interface SwitchCase extends Span {
+  type: "SwitchCase";
+  test: Expression | null;
+  consequent: Array<Statement>;
+  parent?: Node;
+}
+
+export interface LabeledStatement extends Span {
+  type: "LabeledStatement";
+  label: LabelIdentifier;
+  body: Statement;
+  parent?: Node;
+}
+
+export interface ThrowStatement extends Span {
+  type: "ThrowStatement";
+  argument: Expression;
+  parent?: Node;
+}
+
+export interface TryStatement extends Span {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler: CatchClause | null;
+  finalizer: BlockStatement | null;
+  parent?: Node;
+}
+
+export interface CatchClause extends Span {
+  type: "CatchClause";
+  param: BindingPattern | null;
+  body: BlockStatement;
+  parent?: Node;
+}
+
+export interface DebuggerStatement extends Span {
+  type: "DebuggerStatement";
+  parent?: Node;
+}
+
+export type BindingPattern = BindingIdentifier | ObjectPattern | ArrayPattern | AssignmentPattern;
+
+export interface AssignmentPattern extends Span {
+  type: "AssignmentPattern";
+  decorators?: [];
+  left: BindingPattern;
+  right: Expression;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export interface ObjectPattern extends Span {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<BindingProperty | BindingRestElement>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export interface BindingProperty extends Span {
+  type: "Property";
+  kind: "init";
+  key: PropertyKey;
+  value: BindingPattern;
+  method: false;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
+  parent?: Node;
+}
+
+export interface ArrayPattern extends Span {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<BindingPattern | BindingRestElement | null>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node;
+}
+
+export interface BindingRestElement extends Span {
+  type: "RestElement";
+  decorators?: [];
+  argument: BindingPattern;
+  optional?: false;
+  typeAnnotation?: null;
+  value?: null;
+  parent?: Node;
+}
+
+export interface Function extends Span {
+  type: FunctionType;
+  id: BindingIdentifier | null;
+  generator: boolean;
+  async: boolean;
+  declare?: boolean;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: ParamPattern[];
+  returnType?: TSTypeAnnotation | null;
+  body: FunctionBody | null;
+  expression: false;
+  parent?: Node;
+}
+
+export type ParamPattern = FormalParameter | TSParameterProperty | FormalParameterRest;
+
+export type FunctionType =
+  | "FunctionDeclaration"
+  | "FunctionExpression"
+  | "TSDeclareFunction"
+  | "TSEmptyBodyFunctionExpression";
+
+export interface FormalParameterRest extends Span {
+  type: "RestElement";
+  argument: BindingPattern;
+  decorators?: [];
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation | null;
+  value?: null;
+  parent?: Node;
+}
+
+export type FormalParameter = {
+  decorators?: Array<Decorator>;
+} & BindingPattern;
+
+export interface TSParameterProperty extends Span {
+  type: "TSParameterProperty";
+  accessibility: TSAccessibility | null;
+  decorators: Array<Decorator>;
+  override: boolean;
+  parameter: FormalParameter;
+  readonly: boolean;
+  static: boolean;
+  parent?: Node;
+}
+
+export interface FunctionBody extends Span {
+  type: "BlockStatement";
+  body: Array<Directive | Statement>;
+  parent?: Node;
+}
+
+export interface ArrowFunctionExpression extends Span {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  async: boolean;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: ParamPattern[];
+  returnType?: TSTypeAnnotation | null;
+  body: FunctionBody | Expression;
+  id: null;
+  generator: false;
+  parent?: Node;
+}
+
+export interface YieldExpression extends Span {
+  type: "YieldExpression";
+  delegate: boolean;
+  argument: Expression | null;
+  parent?: Node;
+}
+
+export interface Class extends Span {
+  type: ClassType;
+  decorators: Array<Decorator>;
+  id: BindingIdentifier | null;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  superClass: Expression | null;
+  superTypeArguments?: TSTypeParameterInstantiation | null;
+  implements?: Array<TSClassImplements>;
+  body: ClassBody;
+  abstract?: boolean;
+  declare?: boolean;
+  parent?: Node;
+}
+
+export type ClassType = "ClassDeclaration" | "ClassExpression";
+
+export interface ClassBody extends Span {
+  type: "ClassBody";
+  body: Array<ClassElement>;
+  parent?: Node;
+}
+
+export type ClassElement =
+  | StaticBlock
+  | MethodDefinition
+  | PropertyDefinition
+  | AccessorProperty
+  | TSIndexSignature;
+
+export interface MethodDefinition extends Span {
+  type: MethodDefinitionType;
+  decorators: Array<Decorator>;
+  key: PropertyKey;
+  value: Function;
+  kind: MethodDefinitionKind;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  optional?: boolean;
+  accessibility?: TSAccessibility | null;
+  parent?: Node;
+}
+
+export type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
+
+export interface PropertyDefinition extends Span {
+  type: PropertyDefinitionType;
+  decorators: Array<Decorator>;
+  key: PropertyKey;
+  typeAnnotation?: TSTypeAnnotation | null;
+  value: Expression | null;
+  computed: boolean;
+  static: boolean;
+  declare?: boolean;
+  override?: boolean;
+  optional?: boolean;
+  definite?: boolean;
+  readonly?: boolean;
+  accessibility?: TSAccessibility | null;
+  parent?: Node;
+}
+
+export type PropertyDefinitionType = "PropertyDefinition" | "TSAbstractPropertyDefinition";
+
+export type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
+
+export interface PrivateIdentifier extends Span {
+  type: "PrivateIdentifier";
+  name: string;
+  parent?: Node;
+}
+
+export interface StaticBlock extends Span {
+  type: "StaticBlock";
+  body: Array<Statement>;
+  parent?: Node;
+}
+
+export type ModuleDeclaration =
+  | ImportDeclaration
+  | ExportAllDeclaration
+  | ExportDefaultDeclaration
+  | ExportNamedDeclaration
+  | TSExportAssignment
+  | TSNamespaceExportDeclaration;
+
+export type AccessorPropertyType = "AccessorProperty" | "TSAbstractAccessorProperty";
+
+export interface AccessorProperty extends Span {
+  type: AccessorPropertyType;
+  decorators: Array<Decorator>;
+  key: PropertyKey;
+  typeAnnotation?: TSTypeAnnotation | null;
+  value: Expression | null;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  definite?: boolean;
+  accessibility?: TSAccessibility | null;
+  declare?: false;
+  optional?: false;
+  readonly?: false;
+  parent?: Node;
+}
+
+export interface ImportExpression extends Span {
+  type: "ImportExpression";
+  source: Expression;
+  options: Expression | null;
+  phase: ImportPhase | null;
+  parent?: Node;
+}
+
+export interface ImportDeclaration extends Span {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportDeclarationSpecifier>;
+  source: StringLiteral;
+  phase: ImportPhase | null;
+  attributes: Array<ImportAttribute>;
+  importKind?: ImportOrExportKind;
+  parent?: Node;
+}
+
+export type ImportPhase = "source" | "defer";
+
+export type ImportDeclarationSpecifier =
+  | ImportSpecifier
+  | ImportDefaultSpecifier
+  | ImportNamespaceSpecifier;
+
+export interface ImportSpecifier extends Span {
+  type: "ImportSpecifier";
+  imported: ModuleExportName;
+  local: BindingIdentifier;
+  importKind?: ImportOrExportKind;
+  parent?: Node;
+}
+
+export interface ImportDefaultSpecifier extends Span {
+  type: "ImportDefaultSpecifier";
+  local: BindingIdentifier;
+  parent?: Node;
+}
+
+export interface ImportNamespaceSpecifier extends Span {
+  type: "ImportNamespaceSpecifier";
+  local: BindingIdentifier;
+  parent?: Node;
+}
+
+export interface ImportAttribute extends Span {
+  type: "ImportAttribute";
+  key: ImportAttributeKey;
+  value: StringLiteral;
+  parent?: Node;
+}
+
+export type ImportAttributeKey = IdentifierName | StringLiteral;
+
+export interface ExportNamedDeclaration extends Span {
+  type: "ExportNamedDeclaration";
+  declaration: Declaration | null;
+  specifiers: Array<ExportSpecifier>;
+  source: StringLiteral | null;
+  exportKind?: ImportOrExportKind;
+  attributes: Array<ImportAttribute>;
+  parent?: Node;
+}
+
+export interface ExportDefaultDeclaration extends Span {
+  type: "ExportDefaultDeclaration";
+  declaration: ExportDefaultDeclarationKind;
+  exportKind?: "value";
+  parent?: Node;
+}
+
+export interface ExportAllDeclaration extends Span {
+  type: "ExportAllDeclaration";
+  exported: ModuleExportName | null;
+  source: StringLiteral;
+  attributes: Array<ImportAttribute>;
+  exportKind?: ImportOrExportKind;
+  parent?: Node;
+}
+
+export interface ExportSpecifier extends Span {
+  type: "ExportSpecifier";
+  local: ModuleExportName;
+  exported: ModuleExportName;
+  exportKind?: ImportOrExportKind;
+  parent?: Node;
+}
+
+export type ExportDefaultDeclarationKind = Function | Class | TSInterfaceDeclaration | Expression;
+
+export type ModuleExportName = IdentifierName | IdentifierReference | StringLiteral;
+
+export interface V8IntrinsicExpression extends Span {
+  type: "V8IntrinsicExpression";
+  name: IdentifierName;
+  arguments: Array<Argument>;
+  parent?: Node;
+}
+
+export interface BooleanLiteral extends Span {
+  type: "Literal";
+  value: boolean;
+  raw: string | null;
+  parent?: Node;
+}
+
+export interface NullLiteral extends Span {
+  type: "Literal";
+  value: null;
+  raw: "null" | null;
+  parent?: Node;
+}
+
+export interface NumericLiteral extends Span {
+  type: "Literal";
+  value: number;
+  raw: string | null;
+  parent?: Node;
+}
+
+export interface StringLiteral extends Span {
+  type: "Literal";
+  value: string;
+  raw: string | null;
+  parent?: Node;
+}
+
+export interface BigIntLiteral extends Span {
+  type: "Literal";
+  value: bigint;
+  raw: string | null;
+  bigint: string;
+  parent?: Node;
+}
+
+export interface RegExpLiteral extends Span {
+  type: "Literal";
+  value: RegExp | null;
+  raw: string | null;
+  regex: { pattern: string; flags: string };
+  parent?: Node;
+}
+
+export interface JSXElement extends Span {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement;
+  children: Array<JSXChild>;
+  closingElement: JSXClosingElement | null;
+  parent?: Node;
+}
+
+export interface JSXOpeningElement extends Span {
+  type: "JSXOpeningElement";
+  name: JSXElementName;
+  typeArguments?: TSTypeParameterInstantiation | null;
+  attributes: Array<JSXAttributeItem>;
+  selfClosing: boolean;
+  parent?: Node;
+}
+
+export interface JSXClosingElement extends Span {
+  type: "JSXClosingElement";
+  name: JSXElementName;
+  parent?: Node;
+}
+
+export interface JSXFragment extends Span {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment;
+  children: Array<JSXChild>;
+  closingFragment: JSXClosingFragment;
+  parent?: Node;
+}
+
+export interface JSXOpeningFragment extends Span {
+  type: "JSXOpeningFragment";
+  attributes?: [];
+  selfClosing?: false;
+  parent?: Node;
+}
+
+export interface JSXClosingFragment extends Span {
+  type: "JSXClosingFragment";
+  parent?: Node;
+}
+
+export type JSXElementName = JSXIdentifier | JSXNamespacedName | JSXMemberExpression;
+
+export interface JSXNamespacedName extends Span {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier;
+  name: JSXIdentifier;
+  parent?: Node;
+}
+
+export interface JSXMemberExpression extends Span {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpressionObject;
+  property: JSXIdentifier;
+  parent?: Node;
+}
+
+export type JSXMemberExpressionObject = JSXIdentifier | JSXMemberExpression;
+
+export interface JSXExpressionContainer extends Span {
+  type: "JSXExpressionContainer";
+  expression: JSXExpression;
+  parent?: Node;
+}
+
+export type JSXExpression = JSXEmptyExpression | Expression;
+
+export interface JSXEmptyExpression extends Span {
+  type: "JSXEmptyExpression";
+  parent?: Node;
+}
+
+export type JSXAttributeItem = JSXAttribute | JSXSpreadAttribute;
+
+export interface JSXAttribute extends Span {
+  type: "JSXAttribute";
+  name: JSXAttributeName;
+  value: JSXAttributeValue | null;
+  parent?: Node;
+}
+
+export interface JSXSpreadAttribute extends Span {
+  type: "JSXSpreadAttribute";
+  argument: Expression;
+  parent?: Node;
+}
+
+export type JSXAttributeName = JSXIdentifier | JSXNamespacedName;
+
+export type JSXAttributeValue = StringLiteral | JSXExpressionContainer | JSXElement | JSXFragment;
+
+export interface JSXIdentifier extends Span {
+  type: "JSXIdentifier";
+  name: string;
+  parent?: Node;
+}
+
+export type JSXChild = JSXText | JSXElement | JSXFragment | JSXExpressionContainer | JSXSpreadChild;
+
+export interface JSXSpreadChild extends Span {
+  type: "JSXSpreadChild";
+  expression: Expression;
+  parent?: Node;
+}
+
+export interface JSXText extends Span {
+  type: "JSXText";
+  value: string;
+  raw: string | null;
+  parent?: Node;
+}
+
+export interface TSThisParameter extends Span {
+  type: "Identifier";
+  decorators: [];
+  name: "this";
+  optional: false;
+  typeAnnotation: TSTypeAnnotation | null;
+  parent?: Node;
+}
+
+export interface TSEnumDeclaration extends Span {
+  type: "TSEnumDeclaration";
+  id: BindingIdentifier;
+  body: TSEnumBody;
+  const: boolean;
+  declare: boolean;
+  parent?: Node;
+}
+
+export interface TSEnumBody extends Span {
+  type: "TSEnumBody";
+  members: Array<TSEnumMember>;
+  parent?: Node;
+}
+
+export interface TSEnumMember extends Span {
+  type: "TSEnumMember";
+  id: TSEnumMemberName;
+  initializer: Expression | null;
+  computed: boolean;
+  parent?: Node;
+}
+
+export type TSEnumMemberName = IdentifierName | StringLiteral | TemplateLiteral;
+
+export interface TSTypeAnnotation extends Span {
+  type: "TSTypeAnnotation";
+  typeAnnotation: TSType;
+  parent?: Node;
+}
+
+export interface TSLiteralType extends Span {
+  type: "TSLiteralType";
+  literal: TSLiteral;
+  parent?: Node;
+}
+
+export type TSLiteral =
+  | BooleanLiteral
+  | NumericLiteral
+  | BigIntLiteral
+  | StringLiteral
+  | TemplateLiteral
+  | UnaryExpression;
+
+export type TSType =
+  | TSAnyKeyword
+  | TSBigIntKeyword
+  | TSBooleanKeyword
+  | TSIntrinsicKeyword
+  | TSNeverKeyword
+  | TSNullKeyword
+  | TSNumberKeyword
+  | TSObjectKeyword
+  | TSStringKeyword
+  | TSSymbolKeyword
+  | TSUndefinedKeyword
+  | TSUnknownKeyword
+  | TSVoidKeyword
+  | TSArrayType
+  | TSConditionalType
+  | TSConstructorType
+  | TSFunctionType
+  | TSImportType
+  | TSIndexedAccessType
+  | TSInferType
+  | TSIntersectionType
+  | TSLiteralType
+  | TSMappedType
+  | TSNamedTupleMember
+  | TSTemplateLiteralType
+  | TSThisType
+  | TSTupleType
+  | TSTypeLiteral
+  | TSTypeOperator
+  | TSTypePredicate
+  | TSTypeQuery
+  | TSTypeReference
+  | TSUnionType
+  | TSParenthesizedType
+  | JSDocNullableType
+  | JSDocNonNullableType
+  | JSDocUnknownType;
+
+export interface TSConditionalType extends Span {
+  type: "TSConditionalType";
+  checkType: TSType;
+  extendsType: TSType;
+  trueType: TSType;
+  falseType: TSType;
+  parent?: Node;
+}
+
+export interface TSUnionType extends Span {
+  type: "TSUnionType";
+  types: Array<TSType>;
+  parent?: Node;
+}
+
+export interface TSIntersectionType extends Span {
+  type: "TSIntersectionType";
+  types: Array<TSType>;
+  parent?: Node;
+}
+
+export interface TSParenthesizedType extends Span {
+  type: "TSParenthesizedType";
+  typeAnnotation: TSType;
+  parent?: Node;
+}
+
+export interface TSTypeOperator extends Span {
+  type: "TSTypeOperator";
+  operator: TSTypeOperatorOperator;
+  typeAnnotation: TSType;
+  parent?: Node;
+}
+
+export type TSTypeOperatorOperator = "keyof" | "unique" | "readonly";
+
+export interface TSArrayType extends Span {
+  type: "TSArrayType";
+  elementType: TSType;
+  parent?: Node;
+}
+
+export interface TSIndexedAccessType extends Span {
+  type: "TSIndexedAccessType";
+  objectType: TSType;
+  indexType: TSType;
+  parent?: Node;
+}
+
+export interface TSTupleType extends Span {
+  type: "TSTupleType";
+  elementTypes: Array<TSTupleElement>;
+  parent?: Node;
+}
+
+export interface TSNamedTupleMember extends Span {
+  type: "TSNamedTupleMember";
+  label: IdentifierName;
+  elementType: TSTupleElement;
+  optional: boolean;
+  parent?: Node;
+}
+
+export interface TSOptionalType extends Span {
+  type: "TSOptionalType";
+  typeAnnotation: TSType;
+  parent?: Node;
+}
+
+export interface TSRestType extends Span {
+  type: "TSRestType";
+  typeAnnotation: TSType;
+  parent?: Node;
+}
+
+export type TSTupleElement = TSOptionalType | TSRestType | TSType;
+
+export interface TSAnyKeyword extends Span {
+  type: "TSAnyKeyword";
+  parent?: Node;
+}
+
+export interface TSStringKeyword extends Span {
+  type: "TSStringKeyword";
+  parent?: Node;
+}
+
+export interface TSBooleanKeyword extends Span {
+  type: "TSBooleanKeyword";
+  parent?: Node;
+}
+
+export interface TSNumberKeyword extends Span {
+  type: "TSNumberKeyword";
+  parent?: Node;
+}
+
+export interface TSNeverKeyword extends Span {
+  type: "TSNeverKeyword";
+  parent?: Node;
+}
+
+export interface TSIntrinsicKeyword extends Span {
+  type: "TSIntrinsicKeyword";
+  parent?: Node;
+}
+
+export interface TSUnknownKeyword extends Span {
+  type: "TSUnknownKeyword";
+  parent?: Node;
+}
+
+export interface TSNullKeyword extends Span {
+  type: "TSNullKeyword";
+  parent?: Node;
+}
+
+export interface TSUndefinedKeyword extends Span {
+  type: "TSUndefinedKeyword";
+  parent?: Node;
+}
+
+export interface TSVoidKeyword extends Span {
+  type: "TSVoidKeyword";
+  parent?: Node;
+}
+
+export interface TSSymbolKeyword extends Span {
+  type: "TSSymbolKeyword";
+  parent?: Node;
+}
+
+export interface TSThisType extends Span {
+  type: "TSThisType";
+  parent?: Node;
+}
+
+export interface TSObjectKeyword extends Span {
+  type: "TSObjectKeyword";
+  parent?: Node;
+}
+
+export interface TSBigIntKeyword extends Span {
+  type: "TSBigIntKeyword";
+  parent?: Node;
+}
+
+export interface TSTypeReference extends Span {
+  type: "TSTypeReference";
+  typeName: TSTypeName;
+  typeArguments: TSTypeParameterInstantiation | null;
+  parent?: Node;
+}
+
+export type TSTypeName = IdentifierReference | TSQualifiedName | ThisExpression;
+
+export interface TSQualifiedName extends Span {
+  type: "TSQualifiedName";
+  left: TSTypeName;
+  right: IdentifierName;
+  parent?: Node;
+}
+
+export interface TSTypeParameterInstantiation extends Span {
+  type: "TSTypeParameterInstantiation";
+  params: Array<TSType>;
+  parent?: Node;
+}
+
+export interface TSTypeParameter extends Span {
+  type: "TSTypeParameter";
+  name: BindingIdentifier;
+  constraint: TSType | null;
+  default: TSType | null;
+  in: boolean;
+  out: boolean;
+  const: boolean;
+  parent?: Node;
+}
+
+export interface TSTypeParameterDeclaration extends Span {
+  type: "TSTypeParameterDeclaration";
+  params: Array<TSTypeParameter>;
+  parent?: Node;
+}
+
+export interface TSTypeAliasDeclaration extends Span {
+  type: "TSTypeAliasDeclaration";
+  id: BindingIdentifier;
+  typeParameters: TSTypeParameterDeclaration | null;
+  typeAnnotation: TSType;
+  declare: boolean;
+  parent?: Node;
+}
+
+export type TSAccessibility = "private" | "protected" | "public";
+
+export interface TSClassImplements extends Span {
+  type: "TSClassImplements";
+  expression: IdentifierReference | ThisExpression | MemberExpression;
+  typeArguments: TSTypeParameterInstantiation | null;
+  parent?: Node;
+}
+
+export interface TSInterfaceDeclaration extends Span {
+  type: "TSInterfaceDeclaration";
+  id: BindingIdentifier;
+  typeParameters: TSTypeParameterDeclaration | null;
+  extends: Array<TSInterfaceHeritage>;
+  body: TSInterfaceBody;
+  declare: boolean;
+  parent?: Node;
+}
+
+export interface TSInterfaceBody extends Span {
+  type: "TSInterfaceBody";
+  body: Array<TSSignature>;
+  parent?: Node;
+}
+
+export interface TSPropertySignature extends Span {
+  type: "TSPropertySignature";
+  computed: boolean;
+  optional: boolean;
+  readonly: boolean;
+  key: PropertyKey;
+  typeAnnotation: TSTypeAnnotation | null;
+  accessibility: null;
+  static: false;
+  parent?: Node;
+}
+
+export type TSSignature =
+  | TSIndexSignature
+  | TSPropertySignature
+  | TSCallSignatureDeclaration
+  | TSConstructSignatureDeclaration
+  | TSMethodSignature;
+
+export interface TSIndexSignature extends Span {
+  type: "TSIndexSignature";
+  parameters: Array<TSIndexSignatureName>;
+  typeAnnotation: TSTypeAnnotation;
+  readonly: boolean;
+  static: boolean;
+  accessibility: null;
+  parent?: Node;
+}
+
+export interface TSCallSignatureDeclaration extends Span {
+  type: "TSCallSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration | null;
+  params: ParamPattern[];
+  returnType: TSTypeAnnotation | null;
+  parent?: Node;
+}
+
+export type TSMethodSignatureKind = "method" | "get" | "set";
+
+export interface TSMethodSignature extends Span {
+  type: "TSMethodSignature";
+  key: PropertyKey;
+  computed: boolean;
+  optional: boolean;
+  kind: TSMethodSignatureKind;
+  typeParameters: TSTypeParameterDeclaration | null;
+  params: ParamPattern[];
+  returnType: TSTypeAnnotation | null;
+  accessibility: null;
+  readonly: false;
+  static: false;
+  parent?: Node;
+}
+
+export interface TSConstructSignatureDeclaration extends Span {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration | null;
+  params: ParamPattern[];
+  returnType: TSTypeAnnotation | null;
+  parent?: Node;
+}
+
+export interface TSIndexSignatureName extends Span {
+  type: "Identifier";
+  decorators: [];
+  name: string;
+  optional: false;
+  typeAnnotation: TSTypeAnnotation;
+  parent?: Node;
+}
+
+export interface TSInterfaceHeritage extends Span {
+  type: "TSInterfaceHeritage";
+  expression: Expression;
+  typeArguments: TSTypeParameterInstantiation | null;
+  parent?: Node;
+}
+
+export interface TSTypePredicate extends Span {
+  type: "TSTypePredicate";
+  parameterName: TSTypePredicateName;
+  asserts: boolean;
+  typeAnnotation: TSTypeAnnotation | null;
+  parent?: Node;
+}
+
+export type TSTypePredicateName = IdentifierName | TSThisType;
+
+export interface TSModuleDeclaration extends Span {
+  type: "TSModuleDeclaration";
+  id: BindingIdentifier | StringLiteral | TSQualifiedName;
+  body: TSModuleBlock | null;
+  kind: TSModuleDeclarationKind;
+  declare: boolean;
+  global: false;
+  parent?: Node;
+}
+
+export type TSModuleDeclarationKind = "module" | "namespace";
+
+export interface TSGlobalDeclaration extends Span {
+  type: "TSModuleDeclaration";
+  id: IdentifierName;
+  body: TSModuleBlock;
+  kind: "global";
+  declare: boolean;
+  global: true;
+  parent?: Node;
+}
+
+export interface TSModuleBlock extends Span {
+  type: "TSModuleBlock";
+  body: Array<Directive | Statement>;
+  parent?: Node;
+}
+
+export interface TSTypeLiteral extends Span {
+  type: "TSTypeLiteral";
+  members: Array<TSSignature>;
+  parent?: Node;
+}
+
+export interface TSInferType extends Span {
+  type: "TSInferType";
+  typeParameter: TSTypeParameter;
+  parent?: Node;
+}
+
+export interface TSTypeQuery extends Span {
+  type: "TSTypeQuery";
+  exprName: TSTypeQueryExprName;
+  typeArguments: TSTypeParameterInstantiation | null;
+  parent?: Node;
+}
+
+export type TSTypeQueryExprName = TSImportType | TSTypeName;
+
+export interface TSImportType extends Span {
+  type: "TSImportType";
+  source: StringLiteral;
+  options: ObjectExpression | null;
+  qualifier: TSImportTypeQualifier | null;
+  typeArguments: TSTypeParameterInstantiation | null;
+  parent?: Node;
+}
+
+export type TSImportTypeQualifier = IdentifierName | TSImportTypeQualifiedName;
+
+export interface TSImportTypeQualifiedName extends Span {
+  type: "TSQualifiedName";
+  left: TSImportTypeQualifier;
+  right: IdentifierName;
+  parent?: Node;
+}
+
+export interface TSFunctionType extends Span {
+  type: "TSFunctionType";
+  typeParameters: TSTypeParameterDeclaration | null;
+  params: ParamPattern[];
+  returnType: TSTypeAnnotation;
+  parent?: Node;
+}
+
+export interface TSConstructorType extends Span {
+  type: "TSConstructorType";
+  abstract: boolean;
+  typeParameters: TSTypeParameterDeclaration | null;
+  params: ParamPattern[];
+  returnType: TSTypeAnnotation;
+  parent?: Node;
+}
+
+export interface TSMappedType extends Span {
+  type: "TSMappedType";
+  key: BindingIdentifier;
+  constraint: TSType;
+  nameType: TSType | null;
+  typeAnnotation: TSType | null;
+  optional: TSMappedTypeModifierOperator | false;
+  readonly: TSMappedTypeModifierOperator | null;
+  parent?: Node;
+}
+
+export type TSMappedTypeModifierOperator = true | "+" | "-";
+
+export interface TSTemplateLiteralType extends Span {
+  type: "TSTemplateLiteralType";
+  quasis: Array<TemplateElement>;
+  types: Array<TSType>;
+  parent?: Node;
+}
+
+export interface TSAsExpression extends Span {
+  type: "TSAsExpression";
+  expression: Expression;
+  typeAnnotation: TSType;
+  parent?: Node;
+}
+
+export interface TSSatisfiesExpression extends Span {
+  type: "TSSatisfiesExpression";
+  expression: Expression;
+  typeAnnotation: TSType;
+  parent?: Node;
+}
+
+export interface TSTypeAssertion extends Span {
+  type: "TSTypeAssertion";
+  typeAnnotation: TSType;
+  expression: Expression;
+  parent?: Node;
+}
+
+export interface TSImportEqualsDeclaration extends Span {
+  type: "TSImportEqualsDeclaration";
+  id: BindingIdentifier;
+  moduleReference: TSModuleReference;
+  importKind: ImportOrExportKind;
+  parent?: Node;
+}
+
+export type TSModuleReference = TSExternalModuleReference | IdentifierReference | TSQualifiedName;
+
+export interface TSExternalModuleReference extends Span {
+  type: "TSExternalModuleReference";
+  expression: StringLiteral;
+  parent?: Node;
+}
+
+export interface TSNonNullExpression extends Span {
+  type: "TSNonNullExpression";
+  expression: Expression;
+  parent?: Node;
+}
+
+export interface Decorator extends Span {
+  type: "Decorator";
+  expression: Expression;
+  parent?: Node;
+}
+
+export interface TSExportAssignment extends Span {
+  type: "TSExportAssignment";
+  expression: Expression;
+  parent?: Node;
+}
+
+export interface TSNamespaceExportDeclaration extends Span {
+  type: "TSNamespaceExportDeclaration";
+  id: IdentifierName;
+  parent?: Node;
+}
+
+export interface TSInstantiationExpression extends Span {
+  type: "TSInstantiationExpression";
+  expression: Expression;
+  typeArguments: TSTypeParameterInstantiation;
+  parent?: Node;
+}
+
+export type ImportOrExportKind = "value" | "type";
+
+export interface JSDocNullableType extends Span {
+  type: "TSJSDocNullableType";
+  typeAnnotation: TSType;
+  postfix: boolean;
+  parent?: Node;
+}
+
+export interface JSDocNonNullableType extends Span {
+  type: "TSJSDocNonNullableType";
+  typeAnnotation: TSType;
+  postfix: boolean;
+  parent?: Node;
+}
+
+export interface JSDocUnknownType extends Span {
+  type: "TSJSDocUnknownType";
+  parent?: Node;
+}
+
+export type ModuleKind = "script" | "module" | "commonjs";
+
+export interface Span {
+  start: number;
+  end: number;
+  range?: [number, number];
+}
+
+export type AssignmentOperator =
+  | "="
+  | "+="
+  | "-="
+  | "*="
+  | "/="
+  | "%="
+  | "**="
+  | "<<="
+  | ">>="
+  | ">>>="
+  | "|="
+  | "^="
+  | "&="
+  | "||="
+  | "&&="
+  | "??=";
+
+export type BinaryOperator =
+  | "=="
+  | "!="
+  | "==="
+  | "!=="
+  | "<"
+  | "<="
+  | ">"
+  | ">="
+  | "+"
+  | "-"
+  | "*"
+  | "/"
+  | "%"
+  | "**"
+  | "<<"
+  | ">>"
+  | ">>>"
+  | "|"
+  | "^"
+  | "&"
+  | "in"
+  | "instanceof";
+
+export type LogicalOperator = "||" | "&&" | "??";
+
+export type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
+
+export type UpdateOperator = "++" | "--";
+
+export type Node =
+  | Program
+  | IdentifierName
+  | IdentifierReference
+  | BindingIdentifier
+  | LabelIdentifier
+  | ThisExpression
+  | ArrayExpression
+  | ObjectExpression
+  | ObjectProperty
+  | TemplateLiteral
+  | TaggedTemplateExpression
+  | TemplateElement
+  | ComputedMemberExpression
+  | StaticMemberExpression
+  | PrivateFieldExpression
+  | CallExpression
+  | NewExpression
+  | MetaProperty
+  | SpreadElement
+  | UpdateExpression
+  | UnaryExpression
+  | BinaryExpression
+  | PrivateInExpression
+  | LogicalExpression
+  | ConditionalExpression
+  | AssignmentExpression
+  | ArrayAssignmentTarget
+  | ObjectAssignmentTarget
+  | AssignmentTargetRest
+  | AssignmentTargetWithDefault
+  | AssignmentTargetPropertyIdentifier
+  | AssignmentTargetPropertyProperty
+  | SequenceExpression
+  | Super
+  | AwaitExpression
+  | ChainExpression
+  | ParenthesizedExpression
+  | Directive
+  | Hashbang
+  | BlockStatement
+  | VariableDeclaration
+  | VariableDeclarator
+  | EmptyStatement
+  | ExpressionStatement
+  | IfStatement
+  | DoWhileStatement
+  | WhileStatement
+  | ForStatement
+  | ForInStatement
+  | ForOfStatement
+  | ContinueStatement
+  | BreakStatement
+  | ReturnStatement
+  | WithStatement
+  | SwitchStatement
+  | SwitchCase
+  | LabeledStatement
+  | ThrowStatement
+  | TryStatement
+  | CatchClause
+  | DebuggerStatement
+  | AssignmentPattern
+  | ObjectPattern
+  | BindingProperty
+  | ArrayPattern
+  | BindingRestElement
+  | Function
+  | FunctionBody
+  | ArrowFunctionExpression
+  | YieldExpression
+  | Class
+  | ClassBody
+  | MethodDefinition
+  | PropertyDefinition
+  | PrivateIdentifier
+  | StaticBlock
+  | AccessorProperty
+  | ImportExpression
+  | ImportDeclaration
+  | ImportSpecifier
+  | ImportDefaultSpecifier
+  | ImportNamespaceSpecifier
+  | ImportAttribute
+  | ExportNamedDeclaration
+  | ExportDefaultDeclaration
+  | ExportAllDeclaration
+  | ExportSpecifier
+  | V8IntrinsicExpression
+  | BooleanLiteral
+  | NullLiteral
+  | NumericLiteral
+  | StringLiteral
+  | BigIntLiteral
+  | RegExpLiteral
+  | JSXElement
+  | JSXOpeningElement
+  | JSXClosingElement
+  | JSXFragment
+  | JSXOpeningFragment
+  | JSXClosingFragment
+  | JSXNamespacedName
+  | JSXMemberExpression
+  | JSXExpressionContainer
+  | JSXEmptyExpression
+  | JSXAttribute
+  | JSXSpreadAttribute
+  | JSXIdentifier
+  | JSXSpreadChild
+  | JSXText
+  | TSThisParameter
+  | TSEnumDeclaration
+  | TSEnumBody
+  | TSEnumMember
+  | TSTypeAnnotation
+  | TSLiteralType
+  | TSConditionalType
+  | TSUnionType
+  | TSIntersectionType
+  | TSParenthesizedType
+  | TSTypeOperator
+  | TSArrayType
+  | TSIndexedAccessType
+  | TSTupleType
+  | TSNamedTupleMember
+  | TSOptionalType
+  | TSRestType
+  | TSAnyKeyword
+  | TSStringKeyword
+  | TSBooleanKeyword
+  | TSNumberKeyword
+  | TSNeverKeyword
+  | TSIntrinsicKeyword
+  | TSUnknownKeyword
+  | TSNullKeyword
+  | TSUndefinedKeyword
+  | TSVoidKeyword
+  | TSSymbolKeyword
+  | TSThisType
+  | TSObjectKeyword
+  | TSBigIntKeyword
+  | TSTypeReference
+  | TSQualifiedName
+  | TSTypeParameterInstantiation
+  | TSTypeParameter
+  | TSTypeParameterDeclaration
+  | TSTypeAliasDeclaration
+  | TSClassImplements
+  | TSInterfaceDeclaration
+  | TSInterfaceBody
+  | TSPropertySignature
+  | TSIndexSignature
+  | TSCallSignatureDeclaration
+  | TSMethodSignature
+  | TSConstructSignatureDeclaration
+  | TSIndexSignatureName
+  | TSInterfaceHeritage
+  | TSTypePredicate
+  | TSModuleDeclaration
+  | TSGlobalDeclaration
+  | TSModuleBlock
+  | TSTypeLiteral
+  | TSInferType
+  | TSTypeQuery
+  | TSImportType
+  | TSImportTypeQualifiedName
+  | TSFunctionType
+  | TSConstructorType
+  | TSMappedType
+  | TSTemplateLiteralType
+  | TSAsExpression
+  | TSSatisfiesExpression
+  | TSTypeAssertion
+  | TSImportEqualsDeclaration
+  | TSExternalModuleReference
+  | TSNonNullExpression
+  | Decorator
+  | TSExportAssignment
+  | TSNamespaceExportDeclaration
+  | TSInstantiationExpression
+  | JSDocNullableType
+  | JSDocNonNullableType
+  | JSDocUnknownType
+  | ParamPattern;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/binding-win32-x64-msvc/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/binding-win32-x64-msvc/README.md
new file mode 100644
index 0000000..ce38f8e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/binding-win32-x64-msvc/README.md
@@ -0,0 +1,3 @@
+# `@rolldown/binding-win32-x64-msvc`
+
+This is the **x86_64-pc-windows-msvc** binary for `@rolldown/binding`
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/binding-win32-x64-msvc/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/binding-win32-x64-msvc/package.json
new file mode 100644
index 0000000..a28cc93
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/binding-win32-x64-msvc/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "@rolldown/binding-win32-x64-msvc",
+  "version": "1.0.1",
+  "cpu": [
+    "x64"
+  ],
+  "main": "rolldown-binding.win32-x64-msvc.node",
+  "files": [
+    "rolldown-binding.win32-x64-msvc.node"
+  ],
+  "description": "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.",
+  "keywords": [
+    "bundler",
+    "esbuild",
+    "parcel",
+    "rolldown",
+    "rollup",
+    "webpack"
+  ],
+  "homepage": "https://rolldown.rs/",
+  "license": "MIT",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rolldown/rolldown.git",
+    "directory": "packages/rolldown"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "os": [
+    "win32"
+  ]
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/binding-win32-x64-msvc/rolldown-binding.win32-x64-msvc.node b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/binding-win32-x64-msvc/rolldown-binding.win32-x64-msvc.node
new file mode 100644
index 0000000..55408f5
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/binding-win32-x64-msvc/rolldown-binding.win32-x64-msvc.node differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/LICENSE
new file mode 100644
index 0000000..708388c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present, rolldown/plugins repository 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.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/README.md
new file mode 100644
index 0000000..7d4d5a5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/README.md
@@ -0,0 +1,145 @@
+# @rolldown/pluginutils [![npm](https://img.shields.io/npm/v/@rolldown/pluginutils.svg)](https://npmx.dev/package/@rolldown/pluginutils)
+
+Plugin utilities for [Rolldown](https://rolldown.rs).
+
+Includes regex helpers for plugin hook filters, composable filter expressions, and a helper for filtering out Vite-serve-only plugins.
+
+## Install
+
+```bash
+pnpm add -D @rolldown/pluginutils
+```
+
+## Usage
+
+```ts
+import { exactRegex, prefixRegex, makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils'
+```
+
+All filter helpers are also exposed via the `/filter` subpath:
+
+```ts
+import { and, or, id, include } from '@rolldown/pluginutils/filter'
+```
+
+## Regex helpers
+
+### `exactRegex`
+
+- **Type:** `(str: string, flags?: string) => RegExp`
+
+Constructs a `RegExp` that matches the exact string specified. Useful as a plugin hook filter.
+
+```ts
+import { exactRegex } from '@rolldown/pluginutils'
+
+const plugin = {
+  name: 'plugin',
+  resolveId: {
+    filter: { id: exactRegex('foo') },
+    handler(id) {}, // only called for `foo`
+  },
+}
+```
+
+### `prefixRegex`
+
+- **Type:** `(str: string, flags?: string) => RegExp`
+
+Constructs a `RegExp` that matches values starting with the specified prefix.
+
+```ts
+import { prefixRegex } from '@rolldown/pluginutils'
+
+const plugin = {
+  name: 'plugin',
+  resolveId: {
+    filter: { id: prefixRegex('foo') },
+    handler(id) {}, // called for IDs starting with `foo`
+  },
+}
+```
+
+### `makeIdFiltersToMatchWithQuery`
+
+- **Type:** `(input: string | RegExp | (string | RegExp)[]) => string | RegExp | (string | RegExp)[]`
+
+Converts an id filter so that it also matches ids that include a query string.
+
+```ts
+import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils'
+
+const plugin = {
+  name: 'plugin',
+  transform: {
+    filter: { id: makeIdFiltersToMatchWithQuery(['**/*.js', /\.ts$/]) },
+    // Matches:
+    //   foo.js, foo.js?foo, foo.txt?foo.js,
+    //   foo.ts, foo.ts?foo, foo.txt?foo.ts
+    handler(code, id) {},
+  },
+}
+```
+
+## Composable filters
+
+[Composable filter expressions](https://rolldown.rs/apis/plugin-api/hook-filters#composable-filters) for use cases where a simple `id`/`include`/`exclude` is not enough. For example, when a plugin needs to combine `id`, `moduleType`, `code`, and `query` conditions.
+
+```ts
+import { and, code, id, include, interpreter, moduleType, or } from '@rolldown/pluginutils'
+
+const expr = include(and(or(id(/\.tsx?$/), id(/\.jsx?$/)), moduleType('tsx'), code(/import React/)))
+
+interpreter(expr, sourceCode, sourceId, 'tsx') // boolean
+```
+
+### Builders
+
+| Builder                        | Description                                                                                                                                              |
+| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `and(...exprs)`                | All operands must match.                                                                                                                                 |
+| `or(...exprs)`                 | At least one operand must match.                                                                                                                         |
+| `not(expr)`                    | Negates the operand.                                                                                                                                     |
+| `id(pattern, params?)`         | Match the module id. `pattern` is `string` or `RegExp`. `params.cleanUrl` strips the query/hash before matching.                                         |
+| `importerId(pattern, params?)` | Match the importer's id. Same shape as `id`.                                                                                                             |
+| `moduleType(type)`             | Match Rolldown's module type (`'js'`, `'jsx'`, `'ts'`, `'tsx'`, `'json'`, `'text'`, `'base64'`, `'dataurl'`, `'binary'`, `'empty'`, or a custom string). |
+| `code(pattern)`                | Match the module source. `string` matches with `includes`; `RegExp` with `test`.                                                                         |
+| `query(key, pattern)`          | Match a single query parameter. `pattern` is `boolean` (key presence/truthiness), `string` (exact value), or `RegExp` (value pattern).                   |
+| `queries(obj)`                 | Shorthand for `and(...)` over multiple `query` entries.                                                                                                  |
+| `include(expr)`                | Top-level wrapper marking `expr` as an inclusion rule.                                                                                                   |
+| `exclude(expr)`                | Top-level wrapper marking `expr` as an exclusion rule.                                                                                                   |
+
+### `interpreter`
+
+- **Type:** `(exprs, code?, id?, moduleType?, importerId?) => boolean`
+
+Evaluates one or more top-level expressions against the given inputs. Returns `true` when at least one `include` matches and no `exclude` matches; when no `include` is present, defaults to `true` unless an `exclude` matches.
+
+The argument required by each expression must be provided. For example, evaluating an `id(...)` expression without passing `id` will throw.
+
+## `filterVitePlugins`
+
+- **Type:** `<T>(plugins: T | T[] | null | undefined | false) => T[]`
+
+Removes Vite plugins that target the dev server (`apply: 'serve'`) from a (possibly nested) plugin array. Plugins whose `apply` is a function are invoked with a `command: 'build'` context to decide. Useful when reusing a Vite plugin array inside a Rolldown config.
+
+```ts
+import { defineConfig } from 'rolldown'
+import { filterVitePlugins } from '@rolldown/pluginutils'
+import viteReact from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: filterVitePlugins([
+    viteReact(),
+    {
+      name: 'dev-only',
+      apply: 'serve', // filtered out
+      // ...
+    },
+  ]),
+})
+```
+
+## License
+
+MIT
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/filter-B_mD-HGz.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/filter-B_mD-HGz.mjs
new file mode 100644
index 0000000..e3bba27
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/filter-B_mD-HGz.mjs
@@ -0,0 +1,323 @@
+//#region src/utils.ts
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function extractQueryWithoutFragment(url) {
+	const questionMarkIndex = url.indexOf("?");
+	if (questionMarkIndex === -1) return "";
+	const fragmentIndex = url.indexOf("#", questionMarkIndex);
+	if (fragmentIndex === -1) return url.substring(questionMarkIndex);
+	else return url.substring(questionMarkIndex, fragmentIndex);
+}
+//#endregion
+//#region src/filter/composable-filters.ts
+var And = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`And` expects at least one operand");
+		this.args = args;
+		this.kind = "and";
+	}
+};
+var Or = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`Or` expects at least one operand");
+		this.args = args;
+		this.kind = "or";
+	}
+};
+var Not = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "not";
+	}
+};
+var Id = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "id";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ImporterId = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "importerId";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ModuleType = class {
+	kind;
+	pattern;
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.kind = "moduleType";
+	}
+};
+var Code = class {
+	kind;
+	pattern;
+	constructor(expr) {
+		this.pattern = expr;
+		this.kind = "code";
+	}
+};
+var Query = class {
+	kind;
+	key;
+	pattern;
+	constructor(key, pattern) {
+		this.pattern = pattern;
+		this.key = key;
+		this.kind = "query";
+	}
+};
+var Include = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "include";
+	}
+};
+var Exclude = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "exclude";
+	}
+};
+function and(...args) {
+	return new And(...args);
+}
+function or(...args) {
+	return new Or(...args);
+}
+function not(expr) {
+	return new Not(expr);
+}
+function id(pattern, params) {
+	return new Id(pattern, params);
+}
+function importerId(pattern, params) {
+	return new ImporterId(pattern, params);
+}
+function moduleType(pattern) {
+	return new ModuleType(pattern);
+}
+function code(pattern) {
+	return new Code(pattern);
+}
+function query(key, pattern) {
+	return new Query(key, pattern);
+}
+function include(expr) {
+	return new Include(expr);
+}
+function exclude(expr) {
+	return new Exclude(expr);
+}
+/**
+* convert a queryObject to FilterExpression like
+* ```js
+*   and(query(k1, v1), query(k2, v2))
+* ```
+* @param queryFilterObject The query filter object needs to be matched.
+* @returns a `And` FilterExpression
+*/
+function queries(queryFilter) {
+	return and(...Object.entries(queryFilter).map(([key, value]) => {
+		return new Query(key, value);
+	}));
+}
+function interpreter(exprs, code, id, moduleType, importerId) {
+	let arr = [];
+	if (Array.isArray(exprs)) arr = exprs;
+	else arr = [exprs];
+	return interpreterImpl(arr, code, id, moduleType, importerId);
+}
+function interpreterImpl(expr, code, id, moduleType, importerId, ctx = {}) {
+	let hasInclude = false;
+	for (const e of expr) switch (e.kind) {
+		case "include":
+			hasInclude = true;
+			if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return true;
+			break;
+		case "exclude":
+			if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return false;
+			break;
+	}
+	return !hasInclude;
+}
+function exprInterpreter(expr, code, id, moduleType, importerId, ctx = {}) {
+	switch (expr.kind) {
+		case "and": return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "or": return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "not": return !exprInterpreter(expr.expr, code, id, moduleType, importerId, ctx);
+		case "id": {
+			if (id === void 0) throw new Error("`id` is required for `id` expression");
+			let idToMatch = id;
+			if (expr.params.cleanUrl) idToMatch = cleanUrl(idToMatch);
+			return typeof expr.pattern === "string" ? idToMatch === expr.pattern : expr.pattern.test(idToMatch);
+		}
+		case "importerId": {
+			if (importerId === void 0) return false;
+			let importerIdToMatch = importerId;
+			if (expr.params.cleanUrl) importerIdToMatch = cleanUrl(importerIdToMatch);
+			return typeof expr.pattern === "string" ? importerIdToMatch === expr.pattern : expr.pattern.test(importerIdToMatch);
+		}
+		case "moduleType":
+			if (moduleType === void 0) throw new Error("`moduleType` is required for `moduleType` expression");
+			return moduleType === expr.pattern;
+		case "code":
+			if (code === void 0) throw new Error("`code` is required for `code` expression");
+			return typeof expr.pattern === "string" ? code.includes(expr.pattern) : expr.pattern.test(code);
+		case "query": {
+			if (id === void 0) throw new Error("`id` is required for `Query` expression");
+			if (!ctx.urlSearchParamsCache) {
+				let queryString = extractQueryWithoutFragment(id);
+				ctx.urlSearchParamsCache = new URLSearchParams(queryString);
+			}
+			let urlParams = ctx.urlSearchParamsCache;
+			if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key);
+			else return !urlParams.has(expr.key);
+			else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern;
+			else return expr.pattern.test(urlParams.get(expr.key) ?? "");
+		}
+		default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
+	}
+}
+//#endregion
+//#region src/filter/filter-vite-plugins.ts
+/**
+* Filters out Vite plugins that have `apply: 'serve'` set.
+*
+* Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
+* are intended only for Vite's dev server and should be excluded from the build process.
+*
+* @param plugins - Array of plugins (can include nested arrays)
+* @returns Filtered array with serve-only plugins removed
+*
+* @example
+* ```ts
+* import { defineConfig } from 'rolldown';
+* import { filterVitePlugins } from '@rolldown/pluginutils';
+* import viteReact from '@vitejs/plugin-react';
+*
+* export default defineConfig({
+*   plugins: filterVitePlugins([
+*     viteReact(),
+*     {
+*       name: 'dev-only',
+*       apply: 'serve', // This will be filtered out
+*       // ...
+*     }
+*   ])
+* });
+* ```
+*/
+function filterVitePlugins(plugins) {
+	if (!plugins) return [];
+	const pluginArray = Array.isArray(plugins) ? plugins : [plugins];
+	const result = [];
+	for (const plugin of pluginArray) {
+		if (!plugin) continue;
+		if (Array.isArray(plugin)) {
+			result.push(...filterVitePlugins(plugin));
+			continue;
+		}
+		const pluginWithApply = plugin;
+		if ("apply" in pluginWithApply) {
+			const applyValue = pluginWithApply.apply;
+			if (typeof applyValue === "function") try {
+				if (applyValue({}, {
+					command: "build",
+					mode: "production"
+				})) result.push(plugin);
+			} catch {
+				result.push(plugin);
+			}
+			else if (applyValue === "serve") continue;
+			else result.push(plugin);
+		} else result.push(plugin);
+	}
+	return result;
+}
+//#endregion
+//#region src/filter/simple-filters.ts
+/**
+* Constructs a RegExp that matches the exact string specified.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*
+* @example
+* ```ts
+* import { exactRegex } from '@rolldown/pluginutils';
+* const plugin = {
+*   name: 'plugin',
+*   resolveId: {
+*     filter: { id: exactRegex('foo') },
+*     handler(id) {} // will only be called for `foo`
+*   }
+* }
+* ```
+*/
+function exactRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}$`, flags);
+}
+/**
+* Constructs a RegExp that matches a value that has the specified prefix.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*
+* @example
+* ```ts
+* import { prefixRegex } from '@rolldown/pluginutils';
+* const plugin = {
+*   name: 'plugin',
+*   resolveId: {
+*     filter: { id: prefixRegex('foo') },
+*     handler(id) {} // will only be called for IDs starting with `foo`
+*   }
+* }
+* ```
+*/
+function prefixRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+	return str.replace(escapeRegexRE, "\\$&");
+}
+function makeIdFiltersToMatchWithQuery(input) {
+	if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input);
+	return input.map((i) => makeIdFilterToMatchWithQuery(i));
+}
+function makeIdFilterToMatchWithQuery(input) {
+	if (typeof input === "string") return `${input}{?*,}`;
+	return makeRegexIdFilterToMatchWithQuery(input);
+}
+function makeRegexIdFilterToMatchWithQuery(input) {
+	return new RegExp(input.source.replace(/(?<!\\)\$/g, "(?:\\?.*)?$"), input.flags);
+}
+//#endregion
+export { queries as _, and as a, exprInterpreter as c, include as d, interpreter as f, or as g, not as h, filterVitePlugins as i, id as l, moduleType as m, makeIdFiltersToMatchWithQuery as n, code as o, interpreterImpl as p, prefixRegex as r, exclude as s, exactRegex as t, importerId as u, query as v };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/filter/index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/filter/index.d.mts
new file mode 100644
index 0000000..d7f4b50
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/filter/index.d.mts
@@ -0,0 +1,194 @@
+//#region src/filter/composable-filters.d.ts
+type StringOrRegExp = string | RegExp;
+type PluginModuleType = 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | (string & {});
+type FilterExpressionKind = FilterExpression['kind'];
+type FilterExpression = And | Or | Not | Id | ImporterId | ModuleType | Code | Query;
+type TopLevelFilterExpression = Include | Exclude;
+declare class And {
+  kind: 'and';
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Or {
+  kind: 'or';
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Not {
+  kind: 'not';
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+interface QueryFilterObject {
+  [key: string]: StringOrRegExp | boolean;
+}
+interface IdParams {
+  cleanUrl?: boolean;
+}
+declare class Id {
+  kind: 'id';
+  pattern: StringOrRegExp;
+  params: IdParams;
+  constructor(pattern: StringOrRegExp, params?: IdParams);
+}
+declare class ImporterId {
+  kind: 'importerId';
+  pattern: StringOrRegExp;
+  params: IdParams;
+  constructor(pattern: StringOrRegExp, params?: IdParams);
+}
+declare class ModuleType {
+  kind: 'moduleType';
+  pattern: PluginModuleType;
+  constructor(pattern: PluginModuleType);
+}
+declare class Code {
+  kind: 'code';
+  pattern: StringOrRegExp;
+  constructor(expr: StringOrRegExp);
+}
+declare class Query {
+  kind: 'query';
+  key: string;
+  pattern: StringOrRegExp | boolean;
+  constructor(key: string, pattern: StringOrRegExp | boolean);
+}
+declare class Include {
+  kind: 'include';
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare class Exclude {
+  kind: 'exclude';
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare function and(...args: FilterExpression[]): And;
+declare function or(...args: FilterExpression[]): Or;
+declare function not(expr: FilterExpression): Not;
+declare function id(pattern: StringOrRegExp, params?: IdParams): Id;
+declare function importerId(pattern: StringOrRegExp, params?: IdParams): ImporterId;
+declare function moduleType(pattern: PluginModuleType): ModuleType;
+declare function code(pattern: StringOrRegExp): Code;
+declare function query(key: string, pattern: StringOrRegExp | boolean): Query;
+declare function include(expr: FilterExpression): Include;
+declare function exclude(expr: FilterExpression): Exclude;
+/**
+ * convert a queryObject to FilterExpression like
+ * ```js
+ *   and(query(k1, v1), query(k2, v2))
+ * ```
+ * @param queryFilterObject The query filter object needs to be matched.
+ * @returns a `And` FilterExpression
+ */
+declare function queries(queryFilter: QueryFilterObject): And;
+declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string): boolean;
+interface InterpreterCtx {
+  urlSearchParamsCache?: URLSearchParams;
+}
+declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
+declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
+//#endregion
+//#region src/filter/filter-vite-plugins.d.ts
+/**
+ * Filters out Vite plugins that have `apply: 'serve'` set.
+ *
+ * Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
+ * are intended only for Vite's dev server and should be excluded from the build process.
+ *
+ * @param plugins - Array of plugins (can include nested arrays)
+ * @returns Filtered array with serve-only plugins removed
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'rolldown';
+ * import { filterVitePlugins } from '@rolldown/pluginutils';
+ * import viteReact from '@vitejs/plugin-react';
+ *
+ * export default defineConfig({
+ *   plugins: filterVitePlugins([
+ *     viteReact(),
+ *     {
+ *       name: 'dev-only',
+ *       apply: 'serve', // This will be filtered out
+ *       // ...
+ *     }
+ *   ])
+ * });
+ * ```
+ */
+declare function filterVitePlugins<T = any>(plugins: T | T[] | null | undefined | false): T[];
+//#endregion
+//#region src/filter/simple-filters.d.ts
+/**
+ * Constructs a RegExp that matches the exact string specified.
+ *
+ * This is useful for plugin hook filters.
+ *
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ *
+ * @example
+ * ```ts
+ * import { exactRegex } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   resolveId: {
+ *     filter: { id: exactRegex('foo') },
+ *     handler(id) {} // will only be called for `foo`
+ *   }
+ * }
+ * ```
+ */
+declare function exactRegex(str: string, flags?: string): RegExp;
+/**
+ * Constructs a RegExp that matches a value that has the specified prefix.
+ *
+ * This is useful for plugin hook filters.
+ *
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ *
+ * @example
+ * ```ts
+ * import { prefixRegex } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   resolveId: {
+ *     filter: { id: prefixRegex('foo') },
+ *     handler(id) {} // will only be called for IDs starting with `foo`
+ *   }
+ * }
+ * ```
+ */
+declare function prefixRegex(str: string, flags?: string): RegExp;
+type WidenString<T> = T extends string ? string : T;
+/**
+ * Converts a id filter to match with an id with a query.
+ *
+ * @param input the id filters to convert.
+ *
+ * @example
+ * ```ts
+ * import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   transform: {
+ *     filter: { id: makeIdFiltersToMatchWithQuery(['**' + '/*.js', /\.ts$/]) },
+ *     // The handler will be called for IDs like:
+ *     // - foo.js
+ *     // - foo.js?foo
+ *     // - foo.txt?foo.js
+ *     // - foo.ts
+ *     // - foo.ts?foo
+ *     // - foo.txt?foo.ts
+ *     handler(code, id) {}
+ *   }
+ * }
+ * ```
+ */
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: T): WidenString<T>;
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: readonly T[]): WidenString<T>[];
+declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[];
+//#endregion
+export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/filter/index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/filter/index.mjs
new file mode 100644
index 0000000..c197199
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/filter/index.mjs
@@ -0,0 +1,2 @@
+import { _ as queries, a as and, c as exprInterpreter, d as include, f as interpreter, g as or, h as not, i as filterVitePlugins, l as id, m as moduleType, n as makeIdFiltersToMatchWithQuery, o as code, p as interpreterImpl, r as prefixRegex, s as exclude, t as exactRegex, u as importerId, v as query } from "../filter-B_mD-HGz.mjs";
+export { and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/index.d.mts
new file mode 100644
index 0000000..91d7daa
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/index.d.mts
@@ -0,0 +1,2 @@
+import { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query } from "./filter/index.mjs";
+export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/index.mjs
new file mode 100644
index 0000000..2b584aa
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/dist/index.mjs
@@ -0,0 +1,2 @@
+import { _ as queries, a as and, c as exprInterpreter, d as include, f as interpreter, g as or, h as not, i as filterVitePlugins, l as id, m as moduleType, n as makeIdFiltersToMatchWithQuery, o as code, p as interpreterImpl, r as prefixRegex, s as exclude, t as exactRegex, u as importerId, v as query } from "./filter-B_mD-HGz.mjs";
+export { and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/package.json
new file mode 100644
index 0000000..0ab8733
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/@rolldown/pluginutils/package.json
@@ -0,0 +1,40 @@
+{
+  "name": "@rolldown/pluginutils",
+  "version": "1.0.1",
+  "description": "Plugin utilities for Rolldown",
+  "keywords": [
+    "filter",
+    "plugin",
+    "rolldown"
+  ],
+  "homepage": "https://github.com/rolldown/plugins/tree/main/packages/pluginutils#readme",
+  "bugs": {
+    "url": "https://github.com/rolldown/plugins/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rolldown/plugins.git",
+    "directory": "packages/pluginutils"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./filter": "./dist/filter/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@types/picomatch": "^4.0.3",
+    "picomatch": "^4.0.4",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "vitest --project pluginutils",
+    "test:types": "vitest --project pluginutils --typecheck.only"
+  }
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/LICENSE
new file mode 100644
index 0000000..e751674
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/LICENSE
@@ -0,0 +1,577 @@
+# create-vite license
+create-vite is released under the MIT license:
+
+MIT License
+
+Copyright (c) 2019-present, VoidZero Inc. and Vite 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.
+
+# License of the files in the directories starting with "template-" in create-vite
+The files in the directories starting with "template-" in create-vite and files
+generated from those files are licensed under the CC0 1.0 Universal license:
+
+CC0 1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific
+works ("Commons") that the public can reliably and without fear of later
+claims of infringement build upon, modify, incorporate in other works, reuse
+and redistribute as freely as possible in any form whatsoever and for any
+purposes, including without limitation commercial purposes. These owners may
+contribute to the Commons to promote the ideal of a free culture and the
+further production of creative, cultural and scientific works, or to gain
+reputation or greater distribution for their Work in part through the use and
+efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation
+of additional consideration or compensation, the person associating CC0 with a
+Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
+and publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not limited
+to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display, communicate,
+  and translate a Work;
+
+  ii. moral rights retained by the original author(s) and/or performer(s);
+
+  iii. publicity and privacy rights pertaining to a person's image or likeness
+  depicted in a Work;
+
+  iv. rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+
+  v. rights protecting the extraction, dissemination, use and reuse of data in
+  a Work;
+
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation thereof,
+  including any amended or successor version of such directive); and
+
+  vii. other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+and Related Rights and associated claims and causes of action, whether now
+known or unknown (including existing as well as future claims and causes of
+action), in the Work (i) in all territories worldwide, (ii) for the maximum
+duration provided by applicable law or treaty (including future time
+extensions), (iii) in any current or future medium and for any number of
+copies, and (iv) for any purpose whatsoever, including without limitation
+commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
+the Waiver for the benefit of each member of the public at large and to the
+detriment of Affirmer's heirs and successors, fully intending that such Waiver
+shall not be subject to revocation, rescission, cancellation, termination, or
+any other legal or equitable action to disrupt the quiet enjoyment of the Work
+by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+judged legally invalid or ineffective under applicable law, then the Waiver
+shall be preserved to the maximum extent permitted taking into account
+Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
+is so judged Affirmer hereby grants to each affected person a royalty-free,
+non transferable, non sublicensable, non exclusive, irrevocable and
+unconditional license to exercise Affirmer's Copyright and Related Rights in
+the Work (i) in all territories worldwide, (ii) for the maximum duration
+provided by applicable law or treaty (including future time extensions), (iii)
+in any current or future medium and for any number of copies, and (iv) for any
+purpose whatsoever, including without limitation commercial, advertising or
+promotional purposes (the "License"). The License shall be deemed effective as
+of the date CC0 was applied by Affirmer to the Work. Should any part of the
+License for any reason be judged legally invalid or ineffective under
+applicable law, such partial invalidity or ineffectiveness shall not
+invalidate the remainder of the License, and in such case Affirmer hereby
+affirms that he or she will not (i) exercise any of his or her remaining
+Copyright and Related Rights in the Work or (ii) assert any associated claims
+and causes of action with respect to the Work, in either case contrary to
+Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+
+  b. Affirmer offers the Work as-is and makes no representations or warranties
+  of any kind concerning the Work, express, implied, statutory or otherwise,
+  including without limitation warranties of title, merchantability, fitness
+  for a particular purpose, non infringement, or the absence of latent or
+  other defects, accuracy, or the present or absence of errors, whether or not
+  discoverable, all to the greatest extent permissible under applicable law.
+
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without limitation
+  any person's Copyright and Related Rights in the Work. Further, Affirmer
+  disclaims responsibility for obtaining any necessary consents, permissions
+  or other rights required for any use of the Work.
+
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to this
+  CC0 or use of the Work.
+
+For more information, please see
+<http://creativecommons.org/publicdomain/zero/1.0/>
+
+# Licenses of bundled dependencies
+The published create-vite artifact additionally contains code with the following licenses:
+Apache-2.0, ISC, MIT
+
+# Bundled dependencies:
+## @clack/core, @clack/prompts
+License: MIT
+By: Nate Moore
+Repositories: https://github.com/bombshell-dev/clack, https://github.com/bombshell-dev/clack
+
+> MIT License
+> 
+> Copyright (c) Nate Moore
+> 
+> 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.
+
+---------------------------------------
+
+## @vercel/detect-agent
+License: Apache-2.0
+By: Vercel
+Repository: https://github.com/vercel/vercel
+
+> Apache License
+>                            Version 2.0, January 2004
+>                         http://www.apache.org/licenses/
+> 
+>    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+> 
+>    1. Definitions.
+> 
+>       "License" shall mean the terms and conditions for use, reproduction,
+>       and distribution as defined by Sections 1 through 9 of this document.
+> 
+>       "Licensor" shall mean the copyright owner or entity authorized by
+>       the copyright owner that is granting the License.
+> 
+>       "Legal Entity" shall mean the union of the acting entity and all
+>       other entities that control, are controlled by, or are under common
+>       control with that entity. For the purposes of this definition,
+>       "control" means (i) the power, direct or indirect, to cause the
+>       direction or management of such entity, whether by contract or
+>       otherwise, or (ii) ownership of fifty percent (50%) or more of the
+>       outstanding shares, or (iii) beneficial ownership of such entity.
+> 
+>       "You" (or "Your") shall mean an individual or Legal Entity
+>       exercising permissions granted by this License.
+> 
+>       "Source" form shall mean the preferred form for making modifications,
+>       including but not limited to software source code, documentation
+>       source, and configuration files.
+> 
+>       "Object" form shall mean any form resulting from mechanical
+>       transformation or translation of a Source form, including but
+>       not limited to compiled object code, generated documentation,
+>       and conversions to other media types.
+> 
+>       "Work" shall mean the work of authorship, whether in Source or
+>       Object form, made available under the License, as indicated by a
+>       copyright notice that is included in or attached to the work
+>       (an example is provided in the Appendix below).
+> 
+>       "Derivative Works" shall mean any work, whether in Source or Object
+>       form, that is based on (or derived from) the Work and for which the
+>       editorial revisions, annotations, elaborations, or other modifications
+>       represent, as a whole, an original work of authorship. For the purposes
+>       of this License, Derivative Works shall not include works that remain
+>       separable from, or merely link (or bind by name) to the interfaces of,
+>       the Work and Derivative Works thereof.
+> 
+>       "Contribution" shall mean any work of authorship, including
+>       the original version of the Work and any modifications or additions
+>       to that Work or Derivative Works thereof, that is intentionally
+>       submitted to Licensor for inclusion in the Work by the copyright owner
+>       or by an individual or Legal Entity authorized to submit on behalf of
+>       the copyright owner. For the purposes of this definition, "submitted"
+>       means any form of electronic, verbal, or written communication sent
+>       to the Licensor or its representatives, including but not limited to
+>       communication on electronic mailing lists, source code control systems,
+>       and issue tracking systems that are managed by, or on behalf of, the
+>       Licensor for the purpose of discussing and improving the Work, but
+>       excluding communication that is conspicuously marked or otherwise
+>       designated in writing by the copyright owner as "Not a Contribution."
+> 
+>       "Contributor" shall mean Licensor and any individual or Legal Entity
+>       on behalf of whom a Contribution has been received by Licensor and
+>       subsequently incorporated within the Work.
+> 
+>    2. Grant of Copyright License. Subject to the terms and conditions of
+>       this License, each Contributor hereby grants to You a perpetual,
+>       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+>       copyright license to reproduce, prepare Derivative Works of,
+>       publicly display, publicly perform, sublicense, and distribute the
+>       Work and such Derivative Works in Source or Object form.
+> 
+>    3. Grant of Patent License. Subject to the terms and conditions of
+>       this License, each Contributor hereby grants to You a perpetual,
+>       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+>       (except as stated in this section) patent license to make, have made,
+>       use, offer to sell, sell, import, and otherwise transfer the Work,
+>       where such license applies only to those patent claims licensable
+>       by such Contributor that are necessarily infringed by their
+>       Contribution(s) alone or by combination of their Contribution(s)
+>       with the Work to which such Contribution(s) was submitted. If You
+>       institute patent litigation against any entity (including a
+>       cross-claim or counterclaim in a lawsuit) alleging that the Work
+>       or a Contribution incorporated within the Work constitutes direct
+>       or contributory patent infringement, then any patent licenses
+>       granted to You under this License for that Work shall terminate
+>       as of the date such litigation is filed.
+> 
+>    4. Redistribution. You may reproduce and distribute copies of the
+>       Work or Derivative Works thereof in any medium, with or without
+>       modifications, and in Source or Object form, provided that You
+>       meet the following conditions:
+> 
+>       (a) You must give any other recipients of the Work or
+>           Derivative Works a copy of this License; and
+> 
+>       (b) You must cause any modified files to carry prominent notices
+>           stating that You changed the files; and
+> 
+>       (c) You must retain, in the Source form of any Derivative Works
+>           that You distribute, all copyright, patent, trademark, and
+>           attribution notices from the Source form of the Work,
+>           excluding those notices that do not pertain to any part of
+>           the Derivative Works; and
+> 
+>       (d) If the Work includes a "NOTICE" text file as part of its
+>           distribution, then any Derivative Works that You distribute must
+>           include a readable copy of the attribution notices contained
+>           within such NOTICE file, excluding those notices that do not
+>           pertain to any part of the Derivative Works, in at least one
+>           of the following places: within a NOTICE text file distributed
+>           as part of the Derivative Works; within the Source form or
+>           documentation, if provided along with the Derivative Works; or,
+>           within a display generated by the Derivative Works, if and
+>           wherever such third-party notices normally appear. The contents
+>           of the NOTICE file are for informational purposes only and
+>           do not modify the License. You may add Your own attribution
+>           notices within Derivative Works that You distribute, alongside
+>           or as an addendum to the NOTICE text from the Work, provided
+>           that such additional attribution notices cannot be construed
+>           as modifying the License.
+> 
+>       You may add Your own copyright statement to Your modifications and
+>       may provide additional or different license terms and conditions
+>       for use, reproduction, or distribution of Your modifications, or
+>       for any such Derivative Works as a whole, provided Your use,
+>       reproduction, and distribution of the Work otherwise complies with
+>       the conditions stated in this License.
+> 
+>    5. Submission of Contributions. Unless You explicitly state otherwise,
+>       any Contribution intentionally submitted for inclusion in the Work
+>       by You to the Licensor shall be under the terms and conditions of
+>       this License, without any additional terms or conditions.
+>       Notwithstanding the above, nothing herein shall supersede or modify
+>       the terms of any separate license agreement you may have executed
+>       with Licensor regarding such Contributions.
+> 
+>    6. Trademarks. This License does not grant permission to use the trade
+>       names, trademarks, service marks, or product names of the Licensor,
+>       except as required for reasonable and customary use in describing the
+>       origin of the Work and reproducing the content of the NOTICE file.
+> 
+>    7. Disclaimer of Warranty. Unless required by applicable law or
+>       agreed to in writing, Licensor provides the Work (and each
+>       Contributor provides its Contributions) on an "AS IS" BASIS,
+>       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+>       implied, including, without limitation, any warranties or conditions
+>       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+>       PARTICULAR PURPOSE. You are solely responsible for determining the
+>       appropriateness of using or redistributing the Work and assume any
+>       risks associated with Your exercise of permissions under this License.
+> 
+>    8. Limitation of Liability. In no event and under no legal theory,
+>       whether in tort (including negligence), contract, or otherwise,
+>       unless required by applicable law (such as deliberate and grossly
+>       negligent acts) or agreed to in writing, shall any Contributor be
+>       liable to You for damages, including any direct, indirect, special,
+>       incidental, or consequential damages of any character arising as a
+>       result of this License or out of the use or inability to use the
+>       Work (including but not limited to damages for loss of goodwill,
+>       work stoppage, computer failure or malfunction, or any and all
+>       other commercial damages or losses), even if such Contributor
+>       has been advised of the possibility of such damages.
+> 
+>    9. Accepting Warranty or Additional Liability. While redistributing
+>       the Work or Derivative Works thereof, You may choose to offer,
+>       and charge a fee for, acceptance of support, warranty, indemnity,
+>       or other liability obligations and/or rights consistent with this
+>       License. However, in accepting such obligations, You may act only
+>       on Your own behalf and on Your sole responsibility, not on behalf
+>       of any other Contributor, and only if You agree to indemnify,
+>       defend, and hold each Contributor harmless for any liability
+>       incurred by, or claims asserted against, such Contributor by reason
+>       of your accepting any such warranty or additional liability.
+> 
+>    END OF TERMS AND CONDITIONS
+> 
+>    APPENDIX: How to apply the Apache License to your work.
+> 
+>       To apply the Apache License to your work, attach the following
+>       boilerplate notice, with the fields enclosed by brackets "[]"
+>       replaced with your own identifying information. (Don't include
+>       the brackets!)  The text should be enclosed in the appropriate
+>       comment syntax for the file format. We also recommend that a
+>       file or class name and description of purpose be included on the
+>       same "printed page" as the copyright notice for easier
+>       identification within third-party archives.
+> 
+>    Copyright 2017 Vercel, Inc.
+> 
+>    Licensed under the Apache License, Version 2.0 (the "License");
+>    you may not use this file except in compliance with the License.
+>    You may obtain a copy of the License at
+> 
+>        http://www.apache.org/licenses/LICENSE-2.0
+> 
+>    Unless required by applicable law or agreed to in writing, software
+>    distributed under the License is distributed on an "AS IS" BASIS,
+>    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+>    See the License for the specific language governing permissions and
+>    limitations under the License.
+
+---------------------------------------
+
+## cross-spawn
+License: MIT
+By: André Cruz
+Repository: https://github.com/moxystudio/node-cross-spawn
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2018 Made With MOXY Lda <hello@moxy.studio>
+> 
+> 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.
+
+---------------------------------------
+
+## fast-string-truncated-width, fast-string-width
+License: MIT
+Repositories: https://github.com/fabiospampinato/fast-string-truncated-width, https://github.com/fabiospampinato/fast-string-width
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2024-present Fabio Spampinato
+> 
+> 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.
+
+---------------------------------------
+
+## fast-wrap-ansi
+License: MIT
+By: James Garbutt
+Repository: https://github.com/43081j/fast-wrap-ansi
+
+> MIT License
+> 
+> Copyright (c) 2025 James Garbutt
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://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.
+
+---------------------------------------
+
+## isexe, which
+License: ISC
+By: Isaac Z. Schlueter
+Repositories: https://github.com/isaacs/isexe, https://github.com/isaacs/node-which
+
+> The ISC License
+> 
+> Copyright (c) Isaac Z. Schlueter and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## mri
+License: MIT
+By: Luke Edwards
+Repository: https://github.com/lukeed/mri
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.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.
+
+---------------------------------------
+
+## path-key, shebang-regex
+License: MIT
+By: Sindre Sorhus
+Repositories: https://github.com/sindresorhus/path-key, https://github.com/sindresorhus/shebang-regex
+
+> 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.
+
+---------------------------------------
+
+## shebang-command
+License: MIT
+By: Kevin Mårtensson
+Repository: https://github.com/kevva/shebang-command
+
+> MIT License
+> 
+> Copyright (c) Kevin Mårtensson <kevinmartensson@gmail.com> (github.com/kevva)
+> 
+> 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.
+
+---------------------------------------
+
+## sisteransi
+License: MIT
+By: Terkel Gjervig
+Repository: https://github.com/terkelg/sisteransi
+
+> MIT License
+> 
+> Copyright (c) 2018 Terkel Gjervig Nielsen
+> 
+> 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.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/README.md
new file mode 100644
index 0000000..2efc921
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/README.md
@@ -0,0 +1,92 @@
+# create-vite <a href="https://npmjs.com/package/create-vite"><img src="https://img.shields.io/npm/v/create-vite" alt="npm package"></a>
+
+## Scaffolding Your First Vite Project
+
+> **Compatibility Note:**
+> Vite requires [Node.js](https://nodejs.org/en/) version 20.19+, 22.12+. However, some templates require a higher Node.js version to work, please upgrade if your package manager warns about it.
+
+With NPM:
+
+```bash
+npm create vite@latest
+```
+
+With Yarn:
+
+```bash
+yarn create vite
+```
+
+With PNPM:
+
+```bash
+pnpm create vite
+```
+
+With Bun:
+
+```bash
+bun create vite
+```
+
+With Deno:
+
+```bash
+deno init --npm vite
+```
+
+Then follow the prompts!
+
+You can also directly specify the project name and the template you want to use via additional command line options. For example, to scaffold a Vite + Vue project, run:
+
+```bash
+# npm 7+, extra double-dash is needed:
+npm create vite@latest my-vue-app -- --template vue
+
+# yarn
+yarn create vite my-vue-app --template vue
+
+# pnpm
+pnpm create vite my-vue-app --template vue
+
+# Bun
+bun create vite my-vue-app --template vue
+
+# Deno
+deno init --npm vite my-vue-app --template vue
+```
+
+Currently supported template presets include:
+
+- `vanilla`
+- `vanilla-ts`
+- `vue`
+- `vue-ts`
+- `react`
+- `react-compiler`
+- `react-ts`
+- `react-compiler-ts`
+- `preact`
+- `preact-ts`
+- `lit`
+- `lit-ts`
+- `svelte`
+- `svelte-ts`
+- `solid`
+- `solid-ts`
+- `qwik`
+- `qwik-ts`
+
+You can use `.` for the project name to scaffold in the current directory.
+
+## Community Templates
+
+create-vite is a tool to quickly start a project from a basic template for popular frameworks. Check out Awesome Vite for [community maintained templates](https://github.com/vitejs/awesome-vite#templates) that include other tools or target different frameworks. You can use a tool like [tiged](https://github.com/tiged/tiged) to scaffold your project with one of the templates.
+
+```bash
+npx tiged user/project my-project
+cd my-project
+
+npm install
+npm run dev
+```
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/dist/index.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/dist/index.js
new file mode 100644
index 0000000..3d1c05e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/dist/index.js
@@ -0,0 +1,89 @@
+import{createRequire as e}from"node:module";import t from"node:fs";import n from"node:path";import{fileURLToPath as r}from"node:url";import i,{stripVTControlCharacters as a,styleText as o}from"node:util";import s,{stdin as c,stdout as l}from"node:process";import"node:readline";import u from"node:readline";import"node:tty";var d=Object.create,f=Object.defineProperty,p=Object.getOwnPropertyDescriptor,m=Object.getOwnPropertyNames,h=Object.getPrototypeOf,g=Object.prototype.hasOwnProperty,_=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),v=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=m(t),a=0,o=i.length,s;a<o;a++)s=i[a],!g.call(e,s)&&s!==n&&f(e,s,{get:(e=>t[e]).bind(null,s),enumerable:!(r=p(t,s))||r.enumerable});return e},y=(e,t,n)=>(n=e==null?{}:d(h(e)),v(t||!e||!e.__esModule?f(n,`default`,{value:e,enumerable:!0}):n,e)),b=e(import.meta.url),x=_(((e,t)=>{t.exports=a,a.sync=o;var n=b(`fs`);function r(e,t){var n=t.pathExt===void 0?process.env.PATHEXT:t.pathExt;if(!n||(n=n.split(`;`),n.indexOf(``)!==-1))return!0;for(var r=0;r<n.length;r++){var i=n[r].toLowerCase();if(i&&e.substr(-i.length).toLowerCase()===i)return!0}return!1}function i(e,t,n){return!e.isSymbolicLink()&&!e.isFile()?!1:r(t,n)}function a(e,t,r){n.stat(e,function(n,a){r(n,n?!1:i(a,e,t))})}function o(e,t){return i(n.statSync(e),e,t)}})),S=_(((e,t)=>{t.exports=r,r.sync=i;var n=b(`fs`);function r(e,t,r){n.stat(e,function(e,n){r(e,e?!1:a(n,t))})}function i(e,t){return a(n.statSync(e),t)}function a(e,t){return e.isFile()&&o(e,t)}function o(e,t){var n=e.mode,r=e.uid,i=e.gid,a=t.uid===void 0?process.getuid&&process.getuid():t.uid,o=t.gid===void 0?process.getgid&&process.getgid():t.gid,s=64,c=8,l=1,u=s|c;return n&l||n&c&&i===o||n&s&&r===a||n&u&&a===0}})),C=_(((e,t)=>{b(`fs`);var n=process.platform===`win32`||global.TESTING_WINDOWS?x():S();t.exports=r,r.sync=i;function r(e,t,i){if(typeof t==`function`&&(i=t,t={}),!i){if(typeof Promise!=`function`)throw TypeError(`callback not provided`);return new Promise(function(n,i){r(e,t||{},function(e,t){e?i(e):n(t)})})}n(e,t||{},function(e,n){e&&(e.code===`EACCES`||t&&t.ignoreErrors)&&(e=null,n=!1),i(e,n)})}function i(e,t){try{return n.sync(e,t||{})}catch(e){if(t&&t.ignoreErrors||e.code===`EACCES`)return!1;throw e}}})),w=_(((e,t)=>{let n=process.platform===`win32`||process.env.OSTYPE===`cygwin`||process.env.OSTYPE===`msys`,r=b(`path`),i=n?`;`:`:`,a=C(),o=e=>Object.assign(Error(`not found: ${e}`),{code:`ENOENT`}),s=(e,t)=>{let r=t.colon||i,a=e.match(/\//)||n&&e.match(/\\/)?[``]:[...n?[process.cwd()]:[],...(t.path||process.env.PATH||``).split(r)],o=n?t.pathExt||process.env.PATHEXT||`.EXE;.CMD;.BAT;.COM`:``,s=n?o.split(r):[``];return n&&e.indexOf(`.`)!==-1&&s[0]!==``&&s.unshift(``),{pathEnv:a,pathExt:s,pathExtExe:o}},c=(e,t,n)=>{typeof t==`function`&&(n=t,t={}),t||={};let{pathEnv:i,pathExt:c,pathExtExe:l}=s(e,t),u=[],d=n=>new Promise((a,s)=>{if(n===i.length)return t.all&&u.length?a(u):s(o(e));let c=i[n],l=/^".*"$/.test(c)?c.slice(1,-1):c,d=r.join(l,e);a(f(!l&&/^\.[\\\/]/.test(e)?e.slice(0,2)+d:d,n,0))}),f=(e,n,r)=>new Promise((i,o)=>{if(r===c.length)return i(d(n+1));let s=c[r];a(e+s,{pathExt:l},(a,o)=>{if(!a&&o)if(t.all)u.push(e+s);else return i(e+s);return i(f(e,n,r+1))})});return n?d(0).then(e=>n(null,e),n):d(0)};t.exports=c,c.sync=(e,t)=>{t||={};let{pathEnv:n,pathExt:i,pathExtExe:c}=s(e,t),l=[];for(let o=0;o<n.length;o++){let s=n[o],u=/^".*"$/.test(s)?s.slice(1,-1):s,d=r.join(u,e),f=!u&&/^\.[\\\/]/.test(e)?e.slice(0,2)+d:d;for(let e=0;e<i.length;e++){let n=f+i[e];try{if(a.sync(n,{pathExt:c}))if(t.all)l.push(n);else return n}catch{}}}if(t.all&&l.length)return l;if(t.nothrow)return null;throw o(e)}})),ee=_(((e,t)=>{let n=(e={})=>{let t=e.env||process.env;return(e.platform||process.platform)===`win32`?Object.keys(t).reverse().find(e=>e.toUpperCase()===`PATH`)||`Path`:`PATH`};t.exports=n,t.exports.default=n})),te=_(((e,t)=>{let n=b(`path`),r=w(),i=ee();function a(e,t){let a=e.options.env||process.env,o=process.cwd(),s=e.options.cwd!=null,c=s&&process.chdir!==void 0&&!process.chdir.disabled;if(c)try{process.chdir(e.options.cwd)}catch{}let l;try{l=r.sync(e.command,{path:a[i({env:a})],pathExt:t?n.delimiter:void 0})}catch{}finally{c&&process.chdir(o)}return l&&=n.resolve(s?e.options.cwd:``,l),l}function o(e){return a(e)||a(e,!0)}t.exports=o})),ne=_(((e,t)=>{let n=/([()\][%!^"`<>&|;, *?])/g;function r(e){return e=e.replace(n,`^$1`),e}function i(e,t){return e=`${e}`,e=e.replace(/(?=(\\+?)?)\1"/g,`$1$1\\"`),e=e.replace(/(?=(\\+?)?)\1$/,`$1$1`),e=`"${e}"`,e=e.replace(n,`^$1`),t&&(e=e.replace(n,`^$1`)),e}t.exports.command=r,t.exports.argument=i})),re=_(((e,t)=>{t.exports=/^#!(.*)/})),ie=_(((e,t)=>{let n=re();t.exports=(e=``)=>{let t=e.match(n);if(!t)return null;let[r,i]=t[0].replace(/#! ?/,``).split(` `),a=r.split(`/`).pop();return a===`env`?i:i?`${a} ${i}`:a}})),ae=_(((e,t)=>{let n=b(`fs`),r=ie();function i(e){let t=Buffer.alloc(150),i;try{i=n.openSync(e,`r`),n.readSync(i,t,0,150,0),n.closeSync(i)}catch{}return r(t.toString())}t.exports=i})),oe=_(((e,t)=>{let n=b(`path`),r=te(),i=ne(),a=ae(),o=process.platform===`win32`,s=/\.(?:com|exe)$/i,c=/node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;function l(e){e.file=r(e);let t=e.file&&a(e.file);return t?(e.args.unshift(e.file),e.command=t,r(e)):e.file}function u(e){if(!o)return e;let t=l(e),r=!s.test(t);if(e.options.forceShell||r){let r=c.test(t);e.command=n.normalize(e.command),e.command=i.command(e.command),e.args=e.args.map(e=>i.argument(e,r)),e.args=[`/d`,`/s`,`/c`,`"${[e.command].concat(e.args).join(` `)}"`],e.command=process.env.comspec||`cmd.exe`,e.options.windowsVerbatimArguments=!0}return e}function d(e,t,n){t&&!Array.isArray(t)&&(n=t,t=null),t=t?t.slice(0):[],n=Object.assign({},n);let r={command:e,args:t,options:n,file:void 0,original:{command:e,args:t}};return n.shell?r:u(r)}t.exports=d})),se=_(((e,t)=>{let n=process.platform===`win32`;function r(e,t){return Object.assign(Error(`${t} ${e.command} ENOENT`),{code:`ENOENT`,errno:`ENOENT`,syscall:`${t} ${e.command}`,path:e.command,spawnargs:e.args})}function i(e,t){if(!n)return;let r=e.emit;e.emit=function(n,i){if(n===`exit`){let n=a(i,t);if(n)return r.call(e,`error`,n)}return r.apply(e,arguments)}}function a(e,t){return n&&e===1&&!t.file?r(t.original,`spawn`):null}function o(e,t){return n&&e===1&&!t.file?r(t.original,`spawnSync`):null}t.exports={hookChildProcess:i,verifyENOENT:a,verifyENOENTSync:o,notFoundError:r}})),ce=_(((e,t)=>{let n=b(`child_process`),r=oe(),i=se();function a(e,t,a){let o=r(e,t,a),s=n.spawn(o.command,o.args,o.options);return i.hookChildProcess(s,o),s}function o(e,t,a){let o=r(e,t,a),s=n.spawnSync(o.command,o.args,o.options);return s.error=s.error||i.verifyENOENTSync(s.status,o),s}t.exports=a,t.exports.spawn=a,t.exports.sync=o,t.exports._parse=r,t.exports._enoent=i})),le=_(((e,t)=>{function n(e){return e==null?[]:Array.isArray(e)?e:[e]}function r(e,t,n,r){var i,a=e[t],o=~r.string.indexOf(t)?n==null||n===!0?``:String(n):typeof n==`boolean`?n:~r.boolean.indexOf(t)?n===`false`?!1:n===`true`||(e._.push((i=+n,i*0==0?i:n)),!!n):(i=+n,i*0==0?i:n);e[t]=a==null?o:Array.isArray(a)?a.concat(o):[a,o]}t.exports=function(e,t){e||=[],t||={};var i,a,o,s,c,l={_:[]},u=0,d=0,f=0,p=e.length;let m=t.alias!==void 0,h=t.unknown!==void 0,g=t.default!==void 0;if(t.alias=t.alias||{},t.string=n(t.string),t.boolean=n(t.boolean),m)for(i in t.alias)for(a=t.alias[i]=n(t.alias[i]),u=0;u<a.length;u++)(t.alias[a[u]]=a.concat(i)).splice(u,1);for(u=t.boolean.length;u-- >0;)for(a=t.alias[t.boolean[u]]||[],d=a.length;d-- >0;)t.boolean.push(a[d]);for(u=t.string.length;u-- >0;)for(a=t.alias[t.string[u]]||[],d=a.length;d-- >0;)t.string.push(a[d]);if(g){for(i in t.default)if(s=typeof t.default[i],a=t.alias[i]=t.alias[i]||[],t[s]!==void 0)for(t[s].push(i),u=0;u<a.length;u++)t[s].push(a[u])}let _=h?Object.keys(t.alias):[];for(u=0;u<p;u++){if(o=e[u],o===`--`){l._=l._.concat(e.slice(++u));break}for(d=0;d<o.length&&o.charCodeAt(d)===45;d++);if(d===0)l._.push(o);else if(o.substring(d,d+3)===`no-`){if(s=o.substring(d+3),h&&!~_.indexOf(s))return t.unknown(o);l[s]=!1}else{for(f=d+1;f<o.length&&o.charCodeAt(f)!==61;f++);for(s=o.substring(d,f),c=o.substring(++f)||u+1===p||(``+e[u+1]).charCodeAt(0)===45||e[++u],a=d===2?[s]:s,f=0;f<a.length;f++){if(s=a[f],h&&!~_.indexOf(s))return t.unknown(`-`.repeat(d)+s);r(l,s,f+1<a.length||c,t)}}}if(g)for(i in t.default)l[i]===void 0&&(l[i]=t.default[i]);if(m)for(i in l)for(a=t.alias[i]||[];a.length>0;)l[a.shift()]=l[i];return l}})),ue=y(ce(),1),de=y(le(),1);const fe=(()=>{let e=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g;return t=>{let n=0;for(e.lastIndex=0;e.test(t);)n+=1;return t.length-n}})(),pe=e=>e===12288||e>=65281&&e<=65376||e>=65504&&e<=65510,me=e=>e===8987||e===9001||e>=12272&&e<=12287||e>=12289&&e<=12350||e>=12441&&e<=12543||e>=12549&&e<=12591||e>=12593&&e<=12686||e>=12688&&e<=12771||e>=12783&&e<=12830||e>=12832&&e<=12871||e>=12880&&e<=19903||e>=65040&&e<=65049||e>=65072&&e<=65106||e>=65108&&e<=65126||e>=65128&&e<=65131||e>=127488&&e<=127490||e>=127504&&e<=127547||e>=127552&&e<=127560||e>=131072&&e<=196605||e>=196608&&e<=262141,he=/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y,ge=/[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y,_e=/(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/uy,ve=/\t{1,1000}/y,ye=/[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/uy,be=/(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y,xe=/\p{M}+/gu,Se={limit:1/0,ellipsis:``},Ce=(e,t={},n={})=>{let r=t.limit??1/0,i=t.ellipsis??``,a=t?.ellipsisWidth??(i?Ce(i,Se,n).width:0),o=n.controlWidth??0,s=n.tabWidth??8,c=n.emojiWidth??2,l=n.regularWidth??1,u=n.wideWidth??2,d=[[be,l],[he,0],[ge,o],[ve,s],[ye,c],[_e,u]],f=0,p=0,m=e.length,h=0,g=!1,_=m,v=Math.max(0,r-a),y=0,b=0,x=0,S=0;outer:for(;;){if(b>y||p>=m&&p>f){let t=e.slice(y,b)||e.slice(f,p);h=0;for(let e of t.replaceAll(xe,``)){let t=e.codePointAt(0)||0;if(S=pe(t)?2:me(t)?u:l,x+S>v&&(_=Math.min(_,Math.max(y,f)+h)),x+S>r){g=!0;break outer}h+=e.length,x+=S}y=b=0}if(p>=m)break outer;for(let t=0,n=d.length;t<n;t++){let[n,i]=d[t];if(n.lastIndex=p,n.test(e)){if(h=n===_e?fe(e.slice(p,n.lastIndex)):n===ye?1:n.lastIndex-p,S=h*i,x+S>v&&(_=Math.min(_,p+Math.floor((v-x)/i))),x+S>r){g=!0;break outer}x+=S,y=f,b=p,p=f=n.lastIndex;continue outer}}p+=1}return{width:g?v:x,index:g?_:m,truncated:g,ellipsed:g&&r>=a}},we={limit:1/0,ellipsis:``,ellipsisWidth:0},T=(e,t={})=>Ce(e,we,t).width,E=`]8;;`,Te=RegExp(`(?:\\[(?<code>\\d+)m|\\${E}(?<uri>.*))`,`y`),Ee=e=>{if(e>=30&&e<=37||e>=90&&e<=97)return 39;if(e>=40&&e<=47||e>=100&&e<=107)return 49;if(e===1||e===2)return 22;if(e===3)return 23;if(e===4)return 24;if(e===7)return 27;if(e===8)return 28;if(e===9)return 29;if(e===0)return 0},De=e=>`[${e}m`,Oe=e=>`${E}${e}`,D=(e,t,n)=>{let r=t[Symbol.iterator](),i=!1,a=!1,o=e.at(-1),s=o===void 0?0:T(o),c=r.next(),l=r.next(),u=0;for(;!c.done;){let o=c.value,d=T(o);s+d<=n?e[e.length-1]+=o:(e.push(o),s=0),(o===`\x1B`||o===`›`)&&(i=!0,a=t.startsWith(E,u+1)),i?a?o===`\x07`&&(i=!1,a=!1):o===`m`&&(i=!1):(s+=d,s===n&&!l.done&&(e.push(``),s=0)),c=l,l=r.next(),u+=o.length}o=e.at(-1),!s&&o!==void 0&&o.length&&e.length>1&&(e[e.length-2]+=e.pop())},ke=e=>{let t=e.split(` `),n=t.length;for(;n&&!T(t[n-1]);)n--;return n===t.length?e:t.slice(0,n).join(` `)+t.slice(n).join(``)},Ae=(e,t,n={})=>{if(n.trim!==!1&&e.trim()===``)return``;let r=``,i,a,o=e.split(` `),s=[``],c=0;for(let e=0;e<o.length;e++){let r=o[e];if(n.trim!==!1){let e=s.at(-1)??``,t=e.trimStart();e.length!==t.length&&(s[s.length-1]=t,c=T(t))}e!==0&&(c>=t&&(n.wordWrap===!1||n.trim===!1)&&(s.push(``),c=0),(c||n.trim===!1)&&(s[s.length-1]+=` `,c++));let i=T(r);if(n.hard&&i>t){let e=t-c,n=1+Math.floor((i-e-1)/t);Math.floor((i-1)/t)<n&&s.push(``),D(s,r,t),c=T(s.at(-1)??``);continue}if(c+i>t&&c&&i){if(n.wordWrap===!1&&c<t){D(s,r,t),c=T(s.at(-1)??``);continue}s.push(``),c=0}if(c+i>t&&n.wordWrap===!1){D(s,r,t),c=T(s.at(-1)??``);continue}s[s.length-1]+=r,c+=i}n.trim!==!1&&(s=s.map(e=>ke(e)));let l=s.join(`
+`),u=!1;for(let e=0;e<l.length;e++){let t=l[e];if(r+=t,u)u=!1;else if(u=t>=`\ud800`&&t<=`\udbff`,u)continue;if(t===`\x1B`||t===`›`){Te.lastIndex=e+1;let t=Te.exec(l)?.groups;if(t?.code!==void 0){let e=Number.parseFloat(t.code);i=e===39?void 0:e}else t?.uri!==void 0&&(a=t.uri.length===0?void 0:t.uri)}if(l[e+1]===`
+`){a&&(r+=Oe(``));let e=i?Ee(i):void 0;i&&e&&(r+=De(e))}else t===`
+`&&(i&&Ee(i)&&(r+=De(i)),a&&(r+=Oe(a)))}return r},je=/\r?\n/;function O(e,t,n){return String(e).normalize().split(je).map(e=>Ae(e,t,n)).join(`
+`)}var k=_(((e,t)=>{let n={to(e,t){return t?`[${t+1};${e+1}H`:`[${e+1}G`},move(e,t){let n=``;return e<0?n+=`[${-e}D`:e>0&&(n+=`[${e}C`),t<0?n+=`[${-t}A`:t>0&&(n+=`[${t}B`),n},up:(e=1)=>`[${e}A`,down:(e=1)=>`[${e}B`,forward:(e=1)=>`[${e}C`,backward:(e=1)=>`[${e}D`,nextLine:(e=1)=>`\x1B[E`.repeat(e),prevLine:(e=1)=>`\x1B[F`.repeat(e),left:`\x1B[G`,hide:`\x1B[?25l`,show:`\x1B[?25h`,save:`\x1B7`,restore:`\x1B8`};t.exports={cursor:n,scroll:{up:(e=1)=>`\x1B[S`.repeat(e),down:(e=1)=>`\x1B[T`.repeat(e)},erase:{screen:`\x1B[2J`,up:(e=1)=>`\x1B[1J`.repeat(e),down:(e=1)=>`\x1B[J`.repeat(e),line:`\x1B[2K`,lineEnd:`\x1B[K`,lineStart:`\x1B[1K`,lines(e){let t=``;for(let r=0;r<e;r++)t+=this.line+(r<e-1?n.up():``);return e&&(t+=n.left),t}},beep:`\x07`}}))();function A(e,t,n){if(!n.some(e=>!e.disabled))return e;let r=e+t,i=Math.max(n.length-1,0),a=r<0?i:r>i?0:r;return n[a].disabled?A(a,t<0?-1:1,n):a}const j={actions:new Set([`up`,`down`,`left`,`right`,`space`,`enter`,`cancel`]),aliases:new Map([[`k`,`up`],[`j`,`down`],[`h`,`left`],[`l`,`right`],[``,`cancel`],[`escape`,`cancel`]]),messages:{cancel:`Canceled`,error:`Something went wrong`},withGuide:!0,date:{monthNames:[`January`,`February`,`March`,`April`,`May`,`June`,`July`,`August`,`September`,`October`,`November`,`December`],messages:{required:`Please enter a valid date`,invalidMonth:`There are only 12 months in a year`,invalidDay:(e,t)=>`There are only ${e} days in ${t}`,afterMin:e=>`Date must be on or after ${e.toISOString().slice(0,10)}`,beforeMax:e=>`Date must be on or before ${e.toISOString().slice(0,10)}`}}};function Me(e,t){if(typeof e==`string`)return j.aliases.get(e)===t;for(let n of e)if(n!==void 0&&Me(n,t))return!0;return!1}function Ne(e,t){if(e===t)return;let n=e.split(`
+`),r=t.split(`
+`),i=Math.max(n.length,r.length),a=[];for(let e=0;e<i;e++)n[e]!==r[e]&&a.push(e);return{lines:a,numLinesBefore:n.length,numLinesAfter:r.length,numLines:i}}globalThis.process.platform.startsWith(`win`);const M=Symbol(`clack:cancel`);function N(e){return e===M}function P(e,t){let n=e;n.isTTY&&n.setRawMode(t)}const Pe=e=>`columns`in e&&typeof e.columns==`number`?e.columns:80,Fe=e=>`rows`in e&&typeof e.rows==`number`?e.rows:20;function F(e,t,n,r=n,i){return O(t,Pe(e??l)-n.length,{hard:!0,trim:!1}).split(`
+`).map((e,t)=>{let a=i?i(e,t):e;return`${t===0?r:n}${a}`}).join(`
+`)}let I=class{input;output;_abortSignal;rl;opts;_render;_track=!1;_prevFrame=``;_subscribers=new Map;_cursor=0;state=`initial`;error=``;value;userInput=``;constructor(e,t=!0){let{input:n=c,output:r=l,render:i,signal:a,...o}=e;this.opts=o,this.onKeypress=this.onKeypress.bind(this),this.close=this.close.bind(this),this.render=this.render.bind(this),this._render=i.bind(this),this._track=t,this._abortSignal=a,this.input=n,this.output=r}unsubscribe(){this._subscribers.clear()}setSubscriber(e,t){let n=this._subscribers.get(e)??[];n.push(t),this._subscribers.set(e,n)}on(e,t){this.setSubscriber(e,{cb:t})}once(e,t){this.setSubscriber(e,{cb:t,once:!0})}emit(e,...t){let n=this._subscribers.get(e)??[],r=[];for(let e of n)e.cb(...t),e.once&&r.push(()=>n.splice(n.indexOf(e),1));for(let e of r)e()}prompt(){return new Promise(e=>{if(this._abortSignal){if(this._abortSignal.aborted)return this.state=`cancel`,this.close(),e(M);this._abortSignal.addEventListener(`abort`,()=>{this.state=`cancel`,this.close()},{once:!0})}this.rl=u.createInterface({input:this.input,tabSize:2,prompt:``,escapeCodeTimeout:50,terminal:!0}),this.rl.prompt(),this.opts.initialUserInput!==void 0&&this._setUserInput(this.opts.initialUserInput,!0),this.input.on(`keypress`,this.onKeypress),P(this.input,!0),this.output.on(`resize`,this.render),this.render(),this.once(`submit`,()=>{this.output.write(k.cursor.show),this.output.off(`resize`,this.render),P(this.input,!1),e(this.value)}),this.once(`cancel`,()=>{this.output.write(k.cursor.show),this.output.off(`resize`,this.render),P(this.input,!1),e(M)})})}_isActionKey(e,t){return e===`	`}_shouldSubmit(e,t){return!0}_setValue(e){this.value=e,this.emit(`value`,this.value)}_setUserInput(e,t){this.userInput=e??``,this.emit(`userInput`,this.userInput),t&&this._track&&this.rl&&(this.rl.write(this.userInput),this._cursor=this.rl.cursor)}_clearUserInput(){this.rl?.write(null,{ctrl:!0,name:`u`}),this._setUserInput(``)}onKeypress(e,t){if(this._track&&t.name!==`return`&&(t.name&&this._isActionKey(e,t)&&this.rl?.write(null,{ctrl:!0,name:`h`}),this._cursor=this.rl?.cursor??0,this._setUserInput(this.rl?.line)),this.state===`error`&&(this.state=`active`),t?.name&&(!this._track&&j.aliases.has(t.name)&&this.emit(`cursor`,j.aliases.get(t.name)),j.actions.has(t.name)&&this.emit(`cursor`,t.name)),e&&(e.toLowerCase()===`y`||e.toLowerCase()===`n`)&&this.emit(`confirm`,e.toLowerCase()===`y`),this.emit(`key`,e?.toLowerCase(),t),t?.name===`return`&&this._shouldSubmit(e,t)){if(this.opts.validate){let e=this.opts.validate(this.value);e&&(this.error=e instanceof Error?e.message:e,this.state=`error`,this.rl?.write(this.userInput))}this.state!==`error`&&(this.state=`submit`)}Me([e,t?.name,t?.sequence],`cancel`)&&(this.state=`cancel`),(this.state===`submit`||this.state===`cancel`)&&this.emit(`finalize`),this.render(),(this.state===`submit`||this.state===`cancel`)&&this.close()}close(){this.input.unpipe(),this.input.removeListener(`keypress`,this.onKeypress),this.output.write(`
+`),P(this.input,!1),this.rl?.close(),this.rl=void 0,this.emit(`${this.state}`,this.value),this.unsubscribe()}restoreCursor(){let e=O(this._prevFrame,process.stdout.columns,{hard:!0,trim:!1}).split(`
+`).length-1;this.output.write(k.cursor.move(-999,e*-1))}render(){let e=O(this._render(this)??``,process.stdout.columns,{hard:!0,trim:!1});if(e!==this._prevFrame){if(this.state===`initial`)this.output.write(k.cursor.hide);else{let t=Ne(this._prevFrame,e),n=Fe(this.output);if(this.restoreCursor(),t){let r=Math.max(0,t.numLinesAfter-n),i=Math.max(0,t.numLinesBefore-n),a=t.lines.find(e=>e>=r);if(a===void 0){this._prevFrame=e;return}if(t.lines.length===1){this.output.write(k.cursor.move(0,a-i)),this.output.write(k.erase.lines(1));let t=e.split(`
+`);this.output.write(t[a]),this._prevFrame=e,this.output.write(k.cursor.move(0,t.length-a-1));return}else if(t.lines.length>1){if(r<i)a=r;else{let e=a-i;e>0&&this.output.write(k.cursor.move(0,e))}this.output.write(k.erase.down());let t=e.split(`
+`).slice(a);this.output.write(t.join(`
+`)),this._prevFrame=e;return}}this.output.write(k.erase.down())}this.output.write(e),this.state===`initial`&&(this.state=`active`),this._prevFrame=e}}};var Ie=class extends I{get cursor(){return+!this.value}get _value(){return this.cursor===0}constructor(e){super(e,!1),this.value=!!e.initialValue,this.on(`userInput`,()=>{this.value=this._value}),this.on(`confirm`,e=>{this.output.write(k.cursor.move(0,-1)),this.value=e,this.state=`submit`,this.close()}),this.on(`cursor`,()=>{this.value=!this.value})}},Le=class extends I{options;cursor=0;get _selectedValue(){return this.options[this.cursor]}changeValue(){this.value=this._selectedValue.value}constructor(e){super(e,!1),this.options=e.options;let t=this.options.findIndex(({value:t})=>t===e.initialValue),n=t===-1?0:t;this.cursor=this.options[n].disabled?A(n,1,this.options):n,this.changeValue(),this.on(`cursor`,e=>{switch(e){case`left`:case`up`:this.cursor=A(this.cursor,-1,this.options);break;case`down`:case`right`:this.cursor=A(this.cursor,1,this.options);break}this.changeValue()})}},Re=class extends I{get userInputWithCursor(){if(this.state===`submit`)return this.userInput;let e=this.userInput;if(this.cursor>=e.length)return`${this.userInput}\u2588`;let t=e.slice(0,this.cursor),[n,...r]=e.slice(this.cursor);return`${t}${o(`inverse`,n)}${r.join(``)}`}get cursor(){return this._cursor}constructor(e){super({...e,initialUserInput:e.initialUserInput??e.initialValue}),this.on(`userInput`,e=>{this._setValue(e)}),this.on(`finalize`,()=>{this.value||=e.defaultValue,this.value===void 0&&(this.value=``)})}};function ze(){return s.platform===`win32`?!!s.env.CI||!!s.env.WT_SESSION||!!s.env.TERMINUS_SUBLIME||s.env.ConEmuTask===`{cmd::Cmder}`||s.env.TERM_PROGRAM===`Terminus-Sublime`||s.env.TERM_PROGRAM===`vscode`||s.env.TERM===`xterm-256color`||s.env.TERM===`alacritty`||s.env.TERMINAL_EMULATOR===`JetBrains-JediTerm`:s.env.TERM!==`linux`}const Be=ze(),L=(e,t)=>Be?e:t,Ve=L(`◆`,`*`),He=L(`■`,`x`),Ue=L(`▲`,`x`),R=L(`◇`,`o`),z=L(`│`,`|`),B=L(`└`,`—`),We=L(`●`,`>`),V=L(`○`,` `),Ge=L(`●`,`•`),Ke=L(`◆`,`*`),qe=L(`▲`,`!`),Je=L(`■`,`x`),Ye=e=>{switch(e){case`initial`:case`active`:return o(`cyan`,Ve);case`cancel`:return o(`red`,He);case`error`:return o(`yellow`,Ue);case`submit`:return o(`green`,R)}},Xe=e=>{switch(e){case`initial`:case`active`:return o(`cyan`,z);case`cancel`:return o(`red`,z);case`error`:return o(`yellow`,z);case`submit`:return o(`green`,z)}},Ze=(e,t,n,r,i)=>{let a=t,o=0;for(let t=n;t<r;t++){let n=e[t];if(a-=n.length,o++,a<=i)break}return{lineCount:a,removals:o}},Qe=({cursor:e,options:t,style:n,output:r=process.stdout,maxItems:i=1/0,columnPadding:a=0,rowPadding:s=4})=>{let c=Pe(r)-a,l=Fe(r),u=o(`dim`,`...`),d=Math.max(l-s,0),f=Math.max(Math.min(i,d),5),p=0;e>=f-3&&(p=Math.max(Math.min(e-f+3,t.length-f),0));let m=f<t.length&&p>0,h=f<t.length&&p+f<t.length,g=Math.min(p+f,t.length),_=[],v=0;m&&v++,h&&v++;let y=p+ +!!m,b=g-+!!h;for(let r=y;r<b;r++){let i=O(n(t[r],r===e),c,{hard:!0,trim:!1}).split(`
+`);_.push(i),v+=i.length}if(v>d){let t=0,n=0,r=v,i=e-y,a=(e,t)=>Ze(_,r,e,t,d);m?({lineCount:r,removals:t}=a(0,i),r>d&&({lineCount:r,removals:n}=a(i+1,_.length))):({lineCount:r,removals:n}=a(i+1,_.length),r>d&&({lineCount:r,removals:t}=a(0,i))),t>0&&(m=!0,_.splice(0,t)),n>0&&(h=!0,_.splice(_.length-n,n))}let x=[];m&&x.push(u);for(let e of _)for(let t of e)x.push(t);return h&&x.push(u),x},$e=e=>{let t=e.active??`Yes`,n=e.inactive??`No`;return new Ie({active:t,inactive:n,signal:e.signal,input:e.input,output:e.output,initialValue:e.initialValue??!0,render(){let r=e.withGuide??j.withGuide,i=`${Ye(this.state)}  `,a=r?`${o(`gray`,z)}  `:``,s=F(e.output,e.message,a,i),c=`${r?`${o(`gray`,z)}
+`:``}${s}
+`,l=this.value?t:n;switch(this.state){case`submit`:return`${c}${r?`${o(`gray`,z)}  `:``}${o(`dim`,l)}`;case`cancel`:return`${c}${r?`${o(`gray`,z)}  `:``}${o([`strikethrough`,`dim`],l)}${r?`
+${o(`gray`,z)}`:``}`;default:{let i=r?`${o(`cyan`,z)}  `:``,a=r?o(`cyan`,B):``;return`${c}${i}${this.value?`${o(`green`,We)} ${t}`:`${o(`dim`,V)} ${o(`dim`,t)}`}${e.vertical?r?`
+${o(`cyan`,z)}  `:`
+`:` ${o(`dim`,`/`)} `}${this.value?`${o(`dim`,V)} ${o(`dim`,n)}`:`${o(`green`,We)} ${n}`}
+${a}
+`}}}}).prompt()},H={message:(e=[],{symbol:t=o(`gray`,z),secondarySymbol:n=o(`gray`,z),output:r=process.stdout,spacing:i=1,withGuide:a}={})=>{let s=[],c=a??j.withGuide,l=c?n:``,u=c?`${t}  `:``,d=c?`${n}  `:``;for(let e=0;e<i;e++)s.push(l);let f=Array.isArray(e)?e:e.split(`
+`);if(f.length>0){let[e,...r]=f;e.length>0?s.push(`${u}${e}`):s.push(c?t:``);for(let e of r)e.length>0?s.push(`${d}${e}`):s.push(c?n:``)}r.write(`${s.join(`
+`)}
+`)},info:(e,t)=>{H.message(e,{...t,symbol:o(`blue`,Ge)})},success:(e,t)=>{H.message(e,{...t,symbol:o(`green`,Ke)})},step:(e,t)=>{H.message(e,{...t,symbol:o(`green`,R)})},warn:(e,t)=>{H.message(e,{...t,symbol:o(`yellow`,qe)})},warning:(e,t)=>{H.warn(e,t)},error:(e,t)=>{H.message(e,{...t,symbol:o(`red`,Je)})}},et=(e=``,t)=>{let n=t?.output??process.stdout,r=t?.withGuide??j.withGuide?`${o(`gray`,B)}  `:``;n.write(`${r}${o(`red`,e)}
+
+`)},tt=(e=``,t)=>{let n=t?.output??process.stdout,r=t?.withGuide??j.withGuide?`${o(`gray`,z)}
+${o(`gray`,B)}  `:``;n.write(`${r}${e}
+
+`)},U=(e,t)=>e.includes(`
+`)?e.split(`
+`).map(e=>t(e)).join(`
+`):t(e),nt=e=>{let t=(e,t)=>{let n=e.label??String(e.value);switch(t){case`disabled`:return`${o(`gray`,V)} ${U(n,e=>o(`gray`,e))}${e.hint?` ${o(`dim`,`(${e.hint??`disabled`})`)}`:``}`;case`selected`:return`${U(n,e=>o(`dim`,e))}`;case`active`:return`${o(`green`,We)} ${n}${e.hint?` ${o(`dim`,`(${e.hint})`)}`:``}`;case`cancelled`:return`${U(n,e=>o([`strikethrough`,`dim`],e))}`;default:return`${o(`dim`,V)} ${U(n,e=>o(`dim`,e))}`}};return new Le({options:e.options,signal:e.signal,input:e.input,output:e.output,initialValue:e.initialValue,render(){let n=e.withGuide??j.withGuide,r=`${Ye(this.state)}  `,i=`${Xe(this.state)}  `,a=F(e.output,e.message,i,r),s=`${n?`${o(`gray`,z)}
+`:``}${a}
+`;switch(this.state){case`submit`:{let r=n?`${o(`gray`,z)}  `:``;return`${s}${F(e.output,t(this.options[this.cursor],`selected`),r)}`}case`cancel`:{let r=n?`${o(`gray`,z)}  `:``;return`${s}${F(e.output,t(this.options[this.cursor],`cancelled`),r)}${n?`
+${o(`gray`,z)}`:``}`}default:{let r=n?`${o(`cyan`,z)}  `:``,i=n?o(`cyan`,B):``,a=s.split(`
+`).length,c=n?2:1;return`${s}${r}${Qe({output:e.output,cursor:this.cursor,options:this.options,maxItems:e.maxItems,columnPadding:r.length,rowPadding:a+c,style:(e,n)=>t(e,e.disabled?`disabled`:n?`active`:`inactive`)}).join(`
+${r}`)}
+${i}
+`}}}}).prompt()},rt=`${o(`gray`,z)}  `,W={message:async(e,{symbol:t=o(`gray`,z)}={})=>{process.stdout.write(`${o(`gray`,z)}
+${t}  `);let n=3;for await(let t of e){t=t.replace(/\n/g,`
+${rt}`),t.includes(`
+`)&&(n=3+a(t.slice(t.lastIndexOf(`
+`))).length);let e=a(t).length;n+e<process.stdout.columns?(n+=e,process.stdout.write(t)):(process.stdout.write(`
+${rt}${t.trimStart()}`),n=3+a(t.trimStart()).length)}process.stdout.write(`
+`)},info:e=>W.message(e,{symbol:o(`blue`,Ge)}),success:e=>W.message(e,{symbol:o(`green`,Ke)}),step:e=>W.message(e,{symbol:o(`green`,R)}),warn:e=>W.message(e,{symbol:o(`yellow`,qe)}),warning:e=>W.warn(e),error:e=>W.message(e,{symbol:o(`red`,Je)})},it=e=>new Re({validate:e.validate,placeholder:e.placeholder,defaultValue:e.defaultValue,initialValue:e.initialValue,output:e.output,signal:e.signal,input:e.input,render(){let t=e?.withGuide??j.withGuide,n=`${`${t?`${o(`gray`,z)}
+`:``}${Ye(this.state)}  `}${e.message}
+`,r=e.placeholder?o(`inverse`,e.placeholder[0])+o(`dim`,e.placeholder.slice(1)):o([`inverse`,`hidden`],`_`),i=this.userInput?this.userInputWithCursor:r,a=this.value??``;switch(this.state){case`error`:{let e=this.error?`  ${o(`yellow`,this.error)}`:``,r=t?`${o(`yellow`,z)}  `:``,a=t?o(`yellow`,B):``;return`${n.trim()}
+${r}${i}
+${a}${e}
+`}case`submit`:{let e=a?`  ${o(`dim`,a)}`:``;return`${n}${t?o(`gray`,z):``}${e}`}case`cancel`:{let e=a?`  ${o([`strikethrough`,`dim`],a)}`:``,r=t?o(`gray`,z):``;return`${n}${r}${e}${a.trim()?`
+${r}`:``}`}default:return`${n}${t?`${o(`cyan`,z)}  `:``}${i}
+${t?o(`cyan`,B):``}
+`}}}).prompt();var at=_(((e,t)=>{var n=Object.defineProperty,r=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.prototype.hasOwnProperty,o=(e,t)=>{for(var r in t)n(e,r,{get:t[r],enumerable:!0})},s=(e,t,o,s)=>{if(t&&typeof t==`object`||typeof t==`function`)for(let c of i(t))!a.call(e,c)&&c!==o&&n(e,c,{get:()=>t[c],enumerable:!(s=r(t,c))||s.enumerable});return e},c=e=>s(n({},`__esModule`,{value:!0}),e),l={};o(l,{KNOWN_AGENTS:()=>ee,determineAgent:()=>te}),t.exports=c(l);var u=b(`node:fs/promises`),d=b(`node:fs`);let f=`cursor`,p=`cursor-cli`,m=`claude`,h=`cowork`,g=`devin`,_=`replit`,v=`gemini`,y=`codex`,x=`antigravity`,S=`augment-cli`,C=`opencode`,w=`github-copilot`,ee={CURSOR:f,CURSOR_CLI:p,CLAUDE:m,COWORK:h,DEVIN:g,REPLIT:_,GEMINI:v,CODEX:y,ANTIGRAVITY:x,AUGMENT_CLI:S,OPENCODE:C,GITHUB_COPILOT:w,V0:`v0`};async function te(){if(process.env.AI_AGENT){let e=process.env.AI_AGENT.trim();if(e)return e===w||e===`github-copilot-cli`?{isAgent:!0,agent:{name:w}}:e===`v0`?{isAgent:!0,agent:{name:`v0`}}:{isAgent:!0,agent:{name:e}}}if(process.env.CURSOR_TRACE_ID)return{isAgent:!0,agent:{name:f}};if(process.env.CURSOR_AGENT||process.env.CURSOR_EXTENSION_HOST_ROLE===`agent-exec`)return{isAgent:!0,agent:{name:p}};if(process.env.GEMINI_CLI)return{isAgent:!0,agent:{name:v}};if(process.env.CODEX_SANDBOX||process.env.CODEX_CI||process.env.CODEX_THREAD_ID)return{isAgent:!0,agent:{name:y}};if(process.env.ANTIGRAVITY_AGENT)return{isAgent:!0,agent:{name:x}};if(process.env.AUGMENT_AGENT)return{isAgent:!0,agent:{name:S}};if(process.env.OPENCODE_CLIENT)return{isAgent:!0,agent:{name:C}};if(process.env.CLAUDECODE||process.env.CLAUDE_CODE)return process.env.CLAUDE_CODE_IS_COWORK?{isAgent:!0,agent:{name:h}}:{isAgent:!0,agent:{name:m}};if(process.env.REPL_ID)return{isAgent:!0,agent:{name:_}};if(process.env.COPILOT_MODEL||process.env.COPILOT_ALLOW_ALL||process.env.COPILOT_GITHUB_TOKEN)return{isAgent:!0,agent:{name:w}};try{return await(0,u.access)(`/opt/.devin`,d.constants.F_OK),{isAgent:!0,agent:{name:g}}}catch{}return{isAgent:!1,agent:void 0}}}))();const{blue:G,blueBright:K,cyan:q,green:ot,greenBright:st,magenta:J,red:Y,redBright:X,reset:ct,underline:lt,yellow:Z}=Pt(),Q=(0,de.default)(process.argv.slice(2),{boolean:[`help`,`overwrite`,`immediate`,`interactive`],alias:{h:`help`,t:`template`,i:`immediate`},string:[`template`]}),ut=process.cwd(),dt=`\
+Usage: create-vite [OPTION]... [DIRECTORY]
+
+Create a new Vite project in JavaScript or TypeScript.
+When running in TTY, the CLI will start in interactive mode.
+
+Options:
+  -t, --template NAME                   use a specific template
+  -i, --immediate                       install dependencies and start dev
+  --overwrite                           remove existing files if target directory is not empty
+  --interactive / --no-interactive      force interactive / non-interactive mode
+
+Available templates:
+${Z(`vanilla-ts          vanilla`)}
+${ot(`vue-ts              vue`)}
+${q(`react-ts            react`)}
+${q(`react-compiler-ts   react-compiler`)}
+${J(`preact-ts           preact`)}
+${X(`lit-ts              lit`)}
+${Y(`svelte-ts           svelte`)}
+${G(`solid-ts            solid`)}
+${K(`qwik-ts             qwik`)}`,$=[{name:`vanilla`,display:`Vanilla`,color:Z,variants:[{name:`vanilla-ts`,display:`TypeScript`,color:G},{name:`vanilla`,display:`JavaScript`,color:Z}]},{name:`vue`,display:`Vue`,color:ot,variants:[{name:`vue-ts`,display:`TypeScript`,color:G},{name:`vue`,display:`JavaScript`,color:Z},{name:`custom-create-vue`,display:`Official Vue Starter ↗`,color:ot,customCommand:`npm create vue@latest TARGET_DIR`},{name:`custom-nuxt`,display:`Nuxt ↗`,link:`https://nuxt.com`,color:st,customCommand:`npm exec nuxi init TARGET_DIR`},{name:`custom-vike-vue`,display:`Vike ↗`,link:`https://vike.dev`,color:st,customCommand:`npm create -- vike@latest --vue TARGET_DIR`}]},{name:`react`,display:`React`,color:q,variants:[{name:`react-ts`,display:`TypeScript`,color:G},{name:`react-compiler-ts`,display:`TypeScript + React Compiler`,color:G},{name:`react`,display:`JavaScript`,color:Z},{name:`react-compiler`,display:`JavaScript + React Compiler`,color:Z},{name:`rsc`,display:`RSC`,color:J,customCommand:`npm exec tiged vitejs/vite-plugin-react/packages/plugin-rsc/examples/starter TARGET_DIR`},{name:`custom-react-router`,display:`React Router v7 ↗`,link:`https://reactrouter.com`,color:q,customCommand:`npm create react-router@latest TARGET_DIR`},{name:`custom-tanstack-router-react`,display:`TanStack Router ↗`,link:`https://tanstack.com/router`,color:q,customCommand:`npm exec -- @tanstack/cli@latest create TARGET_DIR --framework react --interactive`},{name:`redwoodsdk-standard`,display:`RedwoodSDK ↗`,link:`https://rwsdk.com`,color:q,customCommand:`npm create rwsdk@latest TARGET_DIR`},{name:`custom-vike-react`,display:`Vike ↗`,link:`https://vike.dev`,color:q,customCommand:`npm create -- vike@latest --react TARGET_DIR`}]},{name:`preact`,display:`Preact`,color:J,variants:[{name:`preact-ts`,display:`TypeScript`,color:G},{name:`preact`,display:`JavaScript`,color:Z},{name:`custom-create-preact`,display:`Official Preact Starter ↗`,color:J,customCommand:`npm create preact@latest TARGET_DIR`}]},{name:`lit`,display:`Lit`,color:X,variants:[{name:`lit-ts`,display:`TypeScript`,color:G},{name:`lit`,display:`JavaScript`,color:Z}]},{name:`svelte`,display:`Svelte`,color:Y,variants:[{name:`svelte-ts`,display:`TypeScript`,color:G},{name:`svelte`,display:`JavaScript`,color:Z},{name:`custom-svelte-kit`,display:`SvelteKit ↗`,color:Y,customCommand:`npm exec sv create TARGET_DIR`}]},{name:`solid`,display:`Solid`,color:G,variants:[{name:`solid-ts`,display:`TypeScript`,color:G},{name:`solid`,display:`JavaScript`,color:Z},{name:`custom-tanstack-router-solid`,display:`TanStack Router ↗`,link:`https://tanstack.com/router`,color:q,customCommand:`npm exec -- @tanstack/cli@latest create TARGET_DIR --framework solid --interactive`},{name:`custom-vike-solid`,display:`Vike ↗`,link:`https://vike.dev`,color:q,customCommand:`npm create -- vike@latest --solid TARGET_DIR`}]},{name:`ember`,display:`Ember`,color:X,variants:[{name:`ember-app-ts`,display:`TypeScript ↗`,color:K,customCommand:`npm exec -- ember-cli@latest new TARGET_DIR --typescript`},{name:`ember-app`,display:`JavaScript ↗`,color:X,customCommand:`npm exec -- ember-cli@latest new TARGET_DIR`}]},{name:`qwik`,display:`Qwik`,color:K,variants:[{name:`qwik-ts`,display:`TypeScript`,color:K},{name:`qwik`,display:`JavaScript`,color:Z},{name:`custom-qwik-city`,display:`QwikCity ↗`,color:K,customCommand:`npm create qwik@latest empty TARGET_DIR`}]},{name:`angular`,display:`Angular`,color:Y,variants:[{name:`custom-angular`,display:`Angular ↗`,color:Y,customCommand:`npm exec @angular/cli@latest new TARGET_DIR`},{name:`custom-analog`,display:`Analog ↗`,color:Z,customCommand:`npm create analog@latest TARGET_DIR`}]},{name:`marko`,display:`Marko`,color:J,variants:[{name:`marko-run`,display:`Marko Run ↗`,color:J,customCommand:`npm create -- marko@latest --name TARGET_DIR`}]},{name:`others`,display:`Others`,color:ct,variants:[{name:`create-vite-extra`,display:`Extra Vite Starters ↗`,color:ct,customCommand:`npm create vite-extra@latest TARGET_DIR`},{name:`create-electron-vite`,display:`Electron ↗`,color:ct,customCommand:`npm create electron-vite@latest TARGET_DIR`}]}],ft=$.map(e=>e.variants.map(e=>e.name)).reduce((e,t)=>e.concat(t),[]),pt={_gitignore:`.gitignore`},mt=`vite-project`;function ht([e,...t],n){let{status:r,error:i}=ue.default.sync(e,t,n);r!=null&&r>0&&process.exit(r),i&&(console.error(`\n${e} ${t.join(` `)} error!`),console.error(i),process.exit(1))}function gt(e,t){if(process.env._VITE_TEST_CLI){H.step(`Installing dependencies with ${t}... (skipped in test)`);return}H.step(`Installing dependencies with ${t}...`),ht(Mt(t),{stdio:`inherit`,cwd:e})}function _t(e,t){if(process.env._VITE_TEST_CLI){H.step(`Starting dev server... (skipped in test)`);return}H.step(`Starting dev server...`),ht(Nt(t,`dev`),{stdio:`inherit`,cwd:e})}async function vt(){let e=Q._[0]?yt(String(Q._[0])):void 0,i=Q.template,a=Q.overwrite,o=Q.immediate,s=Q.interactive;if(Q.help){console.log(dt);return}let c=s??process.stdin.isTTY,{isAgent:l}=await(0,at.determineAgent)();l&&c&&console.log(`
+To create in one go, run: create-vite <DIRECTORY> --no-interactive --template <TEMPLATE>
+`);let u=Et(process.env.npm_config_user_agent),d=()=>et(`Operation cancelled`),f=e;if(!f)if(c){let e=await it({message:`Project name:`,defaultValue:mt,placeholder:mt,validate:e=>!e||yt(e).length>0?void 0:`Invalid project name`});if(N(e))return d();f=yt(e)}else f=mt;if(t.existsSync(f)&&!wt(f)){let e=a?`yes`:void 0;if(!e)if(c){let t=await nt({message:(f===`.`?`Current directory`:`Target directory "${f}"`)+` is not empty. Please choose how to proceed:`,options:[{label:`Cancel operation`,value:`no`},{label:`Remove existing files and continue`,value:`yes`},{label:`Ignore files and continue`,value:`ignore`}]});if(N(t))return d();e=t}else e=`no`;switch(e){case`yes`:Tt(f);break;case`no`:d();return}}let p=n.basename(n.resolve(f));if(!xt(p))if(c){let e=await it({message:`Package name:`,defaultValue:St(p),placeholder:St(p),validate(e){if(e&&!xt(e))return`Invalid package.json name`}});if(N(e))return d();p=e}else p=St(p);let m=i,h=!1;if(i&&!ft.includes(i)&&(m=void 0,h=!0),!m)if(c){let e=await nt({message:h?`"${i}" isn't a valid template. Please choose from below: `:`Select a framework:`,options:$.map(e=>{let t=e.color;return{label:t(e.display||e.name),value:e}})});if(N(e))return d();let t=await nt({message:`Select a variant:`,options:e.variants.map(e=>{let t=e.customCommand?At(e.customCommand,u).replace(/ TARGET_DIR$/,``):void 0;return{label:jt(e),value:e.name,hint:t}})});if(N(t))return d();m=t}else m=`vanilla-ts`;let g=u?u.name:`npm`,_=n.join(ut,f),v=!1;m.includes(`react-compiler`)&&(v=!0,m=m.replace(`-compiler`,``));let{customCommand:y}=$.flatMap(e=>e.variants).find(e=>e.name===m)??{};if(y){let[e,...t]=At(y,u).split(` `),n=t.map(e=>e.replace(`TARGET_DIR`,()=>f)),{status:r}=ue.default.sync(e,n,{stdio:`inherit`});process.exit(r??0)}let b=o;if(b===void 0)if(c){let e=await $e({message:`Install with ${g} and start now?`});if(N(e))return d();b=e}else b=!1;t.mkdirSync(_,{recursive:!0}),H.step(`Scaffolding project in ${_}...`);let x=n.resolve(r(import.meta.url),`../..`,`template-${m}`),S=(e,r)=>{let i=n.join(_,pt[e]??e);if(r)t.writeFileSync(i,r);else if(e===`index.html`){let r=n.join(x,e),a=t.readFileSync(r,`utf-8`).replace(/<title>.*?<\/title>/,`<title>${p}</title>`);t.writeFileSync(i,a)}else bt(n.join(x,e),i)},C=t.readdirSync(x);for(let e of C.filter(e=>e!==`package.json`))S(e);let w=JSON.parse(t.readFileSync(n.join(x,`package.json`),`utf-8`));if(w.name=p,S(`package.json`,JSON.stringify(w,null,2)+`
+`),v&&Dt(_,m.endsWith(`-ts`)),b)gt(_,g),_t(_,g);else{let e=``,t=n.relative(ut,_);e+=`Done. Now run:
+`,_!==ut&&(e+=`\n  cd ${t.includes(` `)?`"${t}"`:t}`),e+=`\n  ${Mt(g).join(` `)}`,e+=`\n  ${Nt(g,`dev`).join(` `)}`,tt(e)}}function yt(e){return e.trim().replace(/[<>:"\\|?*]/g,``).replace(/\/+$/g,``)}function bt(e,n){t.statSync(e).isDirectory()?Ct(e,n):t.copyFileSync(e,n)}function xt(e){return/^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(e)}function St(e){return e.trim().toLowerCase().replace(/\s+/g,`-`).replace(/^[._]/,``).replace(/[^a-z\d\-~]+/g,`-`)}function Ct(e,r){t.mkdirSync(r,{recursive:!0});for(let i of t.readdirSync(e))bt(n.resolve(e,i),n.resolve(r,i))}function wt(e){let n=t.readdirSync(e);return n.length===0||n.length===1&&n[0]===`.git`}function Tt(e){if(t.existsSync(e))for(let r of t.readdirSync(e))r!==`.git`&&t.rmSync(n.resolve(e,r),{recursive:!0,force:!0})}function Et(e){if(!e)return;let t=e.split(` `)[0].split(`/`);return{name:t[0],version:t[1]}}function Dt(e,t){kt(n.resolve(e,`package.json`),e=>{let n=JSON.parse(e),r=Object.entries(n.devDependencies);return r.push([`@rolldown/plugin-babel`,`^0.2.3`]),r.push([`babel-plugin-react-compiler`,`^1.0.0`]),r.push([`@babel/core`,`^7.29.0`]),t&&r.push([`@types/babel__core`,`^7.20.5`]),r.sort(),n.devDependencies=Object.fromEntries(r),JSON.stringify(n,null,2)+`
+`}),kt(n.resolve(e,`vite.config.${t?`ts`:`js`}`),e=>e.replace(`import react from '@vitejs/plugin-react'`,`import react, { reactCompilerPreset } from '@vitejs/plugin-react'
+import babel from '@rolldown/plugin-babel'`).replace(`  plugins: [react()],`,`  plugins: [
+    react(),
+    babel({ presets: [reactCompilerPreset()] })
+  ],`)),Ot(e,`The React Compiler is enabled on this template. See [this documentation](https://react.dev/learn/react-compiler) for more information.
+
+Note: This will impact Vite dev & build performances.`)}function Ot(e,t){kt(n.resolve(e,`README.md`),e=>{let n=e.indexOf(`## React Compiler`),r=e.indexOf(`
+
+`,n),i=e.indexOf(`
+## `,r);return n===-1||r===-1||i===-1?(console.warn(`Could not update compiler section in README.md`),e):e.replace(e.slice(r+2,i-1),t)})}function kt(e,n){let r=t.readFileSync(e,`utf-8`);t.writeFileSync(e,n(r),`utf-8`)}function At(e,t){let n=t?t.name:`npm`,r=n===`yarn`&&t?.version.startsWith(`1.`);return e.replace(/^npm create (?:-- )?/,()=>n===`bun`?`bun x create-`:n===`deno`?`deno run -A npm:create-`:n===`pnpm`?`pnpm create `:e.startsWith(`npm create -- `)?`${n} create -- `:`${n} create `).replace(`@latest`,()=>r?``:`@latest`).replace(/^npm exec (?:-- )?/,()=>n===`pnpm`?`pnpm dlx `:n===`yarn`&&!r?`yarn dlx `:n===`bun`?`bun x `:n===`deno`?`deno run -A npm:`:e.startsWith(`npm exec -- `)?`npm exec -- `:`npm exec `)}function jt(e){let t=e.display||e.name,n=e.color(t),{link:r}=e;return r&&(n+=` ${lt(r)}`),n}function Mt(e){return e===`yarn`?[e]:[e,`install`]}function Nt(e,t){switch(e){case`yarn`:case`pnpm`:case`bun`:return[e,t];case`deno`:return[e,`task`,t];default:return[e,`run`,t]}}function Pt(){return new Proxy({},{get(e,t){return e=>i.styleText(t,e)}})}vt().catch(e=>{console.error(e)});export{};
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/index.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/index.js
new file mode 100644
index 0000000..a771b98
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/index.js
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import './dist/index.js'
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/package.json
new file mode 100644
index 0000000..3c2339a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/package.json
@@ -0,0 +1,43 @@
+{
+  "name": "create-vite",
+  "version": "9.0.7",
+  "type": "module",
+  "license": "MIT",
+  "author": "Evan You",
+  "bin": {
+    "create-vite": "index.js",
+    "cva": "index.js"
+  },
+  "files": [
+    "index.js",
+    "template-*",
+    "dist"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitejs/vite.git",
+    "directory": "packages/create-vite"
+  },
+  "bugs": {
+    "url": "https://github.com/vitejs/vite/issues"
+  },
+  "homepage": "https://github.com/vitejs/vite/tree/main/packages/create-vite#readme",
+  "funding": "https://github.com/vitejs/vite?sponsor=1",
+  "devDependencies": {
+    "@clack/prompts": "^1.3.0",
+    "@vercel/detect-agent": "^1.2.3",
+    "cross-spawn": "^7.0.6",
+    "mri": "^1.2.0",
+    "tsdown": "^0.22.0",
+    "unrun": "^0.3.0"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "typecheck": "tsc",
+    "execute": "node index.js"
+  }
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/index.html
new file mode 100644
index 0000000..b74823e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/index.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Lit + TS</title>
+    <link rel="stylesheet" href="./src/index.css" />
+    <script type="module" src="/src/my-element.ts"></script>
+  </head>
+  <body>
+    <my-element>
+      <h1>Get started</h1>
+    </my-element>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/package.json
new file mode 100644
index 0000000..f5e6c97
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "vite-lit-ts-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "lit": "^3.3.2"
+  },
+  "devDependencies": {
+    "typescript": "~6.0.2",
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/assets/lit.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/assets/lit.svg
new file mode 100644
index 0000000..4a9c1fe
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/assets/lit.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="25.6" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 320"><path fill="#00E8FF" d="m64 192l25.926-44.727l38.233-19.114l63.974 63.974l10.833 61.754L192 320l-64-64l-38.074-25.615z"></path><path fill="#283198" d="M128 256V128l64-64v128l-64 64ZM0 256l64 64l9.202-60.602L64 192l-37.542 23.71L0 256Z"></path><path fill="#324FFF" d="M64 192V64l64-64v128l-64 64Zm128 128V192l64-64v128l-64 64ZM0 256V128l64 64l-64 64Z"></path><path fill="#0FF" d="M64 320V192l64 64z"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/index.css
new file mode 100644
index 0000000..4ffca5c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/index.css
@@ -0,0 +1,24 @@
+:root {
+  color-scheme: light dark;
+  background-color: #ffffff;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    background-color: #16171d;
+  }
+}
+
+body {
+  margin: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  min-width: 320px;
+  min-height: 100svh;
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  overflow-x: hidden;
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/my-element.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/my-element.ts
new file mode 100644
index 0000000..d02bc8d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/src/my-element.ts
@@ -0,0 +1,438 @@
+import { LitElement, css, html } from 'lit'
+import { customElement, property } from 'lit/decorators.js'
+import litLogo from './assets/lit.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+
+/**
+ * An example element.
+ *
+ * @slot - This element has a slot
+ * @csspart button - The button
+ */
+@customElement('my-element')
+export class MyElement extends LitElement {
+  /**
+   * The number of times the button has been clicked.
+   */
+  @property({ type: Number })
+  count = 0
+
+  render() {
+    return html`
+      <section id="center">
+        <div class="hero">
+          <img src=${heroImg} class="base" width="170" height="179" alt="" />
+          <img src=${litLogo} class="framework" alt="Lit logo" />
+          <img src=${viteLogo} class="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <slot></slot>
+          <p>
+            Edit <code>src/my-element.ts</code> and save to test
+            <code>HMR</code>
+          </p>
+        </div>
+        <button
+          type="button"
+          class="counter"
+          @click=${this._onClick}
+          part="button"
+        >
+          Count is ${this.count}
+        </button>
+      </section>
+
+      <div class="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img class="logo" src=${viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://lit.dev/" target="_blank">
+                <img class="button-icon" src=${litLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div class="ticks"></div>
+      <section id="spacer"></section>
+    `
+  }
+
+  private _onClick() {
+    this.count++
+  }
+
+  static styles = css`
+    :host {
+      --text: #6b6375;
+      --text-h: #08060d;
+      --bg: #fff;
+      --border: #e5e4e7;
+      --code-bg: #f4f3ec;
+      --accent: #aa3bff;
+      --accent-bg: rgba(170, 59, 255, 0.1);
+      --accent-border: rgba(170, 59, 255, 0.5);
+      --social-bg: rgba(244, 243, 236, 0.5);
+      --shadow:
+        rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+      --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+      --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+      --mono: ui-monospace, Consolas, monospace;
+
+      font: 18px/145% var(--sans);
+      letter-spacing: 0.18px;
+
+      width: 1126px;
+      max-width: 100%;
+      margin: 0 auto;
+      text-align: center;
+      border-inline: 1px solid var(--border);
+      min-height: 100svh;
+      display: flex;
+      flex-direction: column;
+      box-sizing: border-box;
+      color: var(--text);
+    }
+
+    @media (prefers-color-scheme: dark) {
+      :host {
+        --text: #9ca3af;
+        --text-h: #f3f4f6;
+        --bg: #16171d;
+        --border: #2e303a;
+        --code-bg: #1f2028;
+        --accent: #c084fc;
+        --accent-bg: rgba(192, 132, 252, 0.15);
+        --accent-border: rgba(192, 132, 252, 0.5);
+        --social-bg: rgba(47, 48, 58, 0.5);
+        --shadow:
+          rgba(0, 0, 0, 0.4) 0 10px 15px -3px,
+          rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+      }
+
+      #social .button-icon {
+        filter: invert(1) brightness(2);
+      }
+    }
+
+    h1,
+    h2,
+    ::slotted(h1),
+    ::slotted(h2) {
+      font-family: var(--heading);
+      font-weight: 500;
+      color: var(--text-h);
+    }
+
+    h1,
+    ::slotted(h1) {
+      font-size: 56px;
+      letter-spacing: -1.68px;
+      margin: 32px 0;
+    }
+
+    h2 {
+      font-size: 24px;
+      line-height: 118%;
+      letter-spacing: -0.24px;
+      margin: 0 0 8px;
+    }
+
+    p {
+      margin: 0;
+    }
+
+    code {
+      font-family: var(--mono);
+      font-size: 15px;
+      line-height: 135%;
+      display: inline-flex;
+      padding: 4px 8px;
+      border-radius: 4px;
+      color: var(--text-h);
+      background: var(--code-bg);
+    }
+
+    .counter {
+      font-family: var(--mono);
+      font-size: 16px;
+      display: inline-flex;
+      padding: 5px 10px;
+      border-radius: 5px;
+      color: var(--accent);
+      background: var(--accent-bg);
+      border: 2px solid transparent;
+      transition: border-color 0.3s;
+      margin-bottom: 24px;
+      cursor: pointer;
+    }
+
+    .counter:hover {
+      border-color: var(--accent-border);
+    }
+
+    .counter:focus-visible {
+      outline: 2px solid var(--accent);
+      outline-offset: 2px;
+    }
+
+    .hero {
+      position: relative;
+    }
+
+    .hero .base,
+    .hero .framework,
+    .hero .vite {
+      inset-inline: 0;
+      margin: 0 auto;
+    }
+
+    .hero .base {
+      width: 170px;
+      position: relative;
+      z-index: 0;
+    }
+
+    .hero .framework,
+    .hero .vite {
+      position: absolute;
+    }
+
+    .hero .framework {
+      z-index: 1;
+      top: 34px;
+      height: 28px;
+      transform: perspective(2000px) rotateZ(300deg) rotateX(44deg)
+        rotateY(39deg) scale(1.4);
+    }
+
+    .hero .vite {
+      z-index: 0;
+      top: 107px;
+      height: 26px;
+      width: auto;
+      color: var(--vite-logo);
+      transform: perspective(2000px) rotateZ(300deg) rotateX(40deg)
+        rotateY(39deg) scale(0.8);
+    }
+
+    #center {
+      display: flex;
+      flex-direction: column;
+      gap: 25px;
+      place-content: center;
+      place-items: center;
+      flex-grow: 1;
+    }
+
+    #next-steps {
+      display: flex;
+      border-top: 1px solid var(--border);
+      text-align: left;
+    }
+
+    #next-steps > div {
+      flex: 1 1 0;
+      padding: 32px;
+    }
+
+    #next-steps .icon {
+      margin-bottom: 16px;
+      width: 22px;
+      height: 22px;
+    }
+
+    #docs {
+      border-right: 1px solid var(--border);
+    }
+
+    #next-steps ul {
+      list-style: none;
+      padding: 0;
+      display: flex;
+      gap: 8px;
+      margin: 32px 0 0;
+    }
+
+    #next-steps ul .logo {
+      height: 18px;
+    }
+
+    #next-steps ul .logo svg {
+      height: 100%;
+      width: auto;
+    }
+
+    #next-steps ul a {
+      color: var(--text-h);
+      font-size: 16px;
+      border-radius: 6px;
+      background: var(--social-bg);
+      display: flex;
+      padding: 6px 12px;
+      align-items: center;
+      gap: 8px;
+      text-decoration: none;
+      transition: box-shadow 0.3s;
+    }
+
+    #next-steps ul a:hover {
+      box-shadow: var(--shadow);
+    }
+
+    #next-steps ul .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+
+    #spacer {
+      height: 88px;
+      border-top: 1px solid var(--border);
+    }
+
+    .ticks {
+      position: relative;
+      width: 100%;
+    }
+
+    .ticks::before,
+    .ticks::after {
+      content: '';
+      position: absolute;
+      top: -4.5px;
+      border: 5px solid transparent;
+    }
+
+    .ticks::before {
+      left: 0;
+      border-left-color: var(--border);
+    }
+
+    .ticks::after {
+      right: 0;
+      border-right-color: var(--border);
+    }
+
+    @media (max-width: 1024px) {
+      :host {
+        font-size: 16px;
+        width: 100%;
+        max-width: 100%;
+      }
+
+      h1,
+      ::slotted(h1) {
+        font-size: 36px;
+        margin: 20px 0;
+      }
+
+      h2,
+      ::slotted(h2) {
+        font-size: 20px;
+      }
+
+      #center {
+        padding: 32px 20px 24px;
+        gap: 18px;
+      }
+
+      #next-steps {
+        flex-direction: column;
+        text-align: center;
+      }
+
+      #next-steps > div {
+        padding: 24px 20px;
+      }
+
+      #docs {
+        border-right: none;
+        border-bottom: 1px solid var(--border);
+      }
+
+      #next-steps ul {
+        margin-top: 20px;
+        flex-wrap: wrap;
+        justify-content: center;
+      }
+
+      #next-steps ul li {
+        flex: 1 1 calc(50% - 8px);
+      }
+
+      #next-steps ul a {
+        width: 100%;
+        justify-content: center;
+        box-sizing: border-box;
+      }
+
+      #spacer {
+        height: 48px;
+      }
+    }
+  `
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'my-element': MyElement
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/tsconfig.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/tsconfig.json
new file mode 100644
index 0000000..ec4849a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit-ts/tsconfig.json
@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "es2023",
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "module": "esnext",
+    "lib": ["ES2023", "DOM"],
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/index.html
new file mode 100644
index 0000000..c7b06cf
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/index.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Lit</title>
+    <link rel="stylesheet" href="./src/index.css" />
+    <script type="module" src="/src/my-element.js"></script>
+  </head>
+  <body>
+    <my-element>
+      <h1>Get started</h1>
+    </my-element>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/package.json
new file mode 100644
index 0000000..afa3722
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/package.json
@@ -0,0 +1,17 @@
+{
+  "name": "vite-lit-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "lit": "^3.3.2"
+  },
+  "devDependencies": {
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/assets/lit.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/assets/lit.svg
new file mode 100644
index 0000000..4a9c1fe
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/assets/lit.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="25.6" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 320"><path fill="#00E8FF" d="m64 192l25.926-44.727l38.233-19.114l63.974 63.974l10.833 61.754L192 320l-64-64l-38.074-25.615z"></path><path fill="#283198" d="M128 256V128l64-64v128l-64 64ZM0 256l64 64l9.202-60.602L64 192l-37.542 23.71L0 256Z"></path><path fill="#324FFF" d="M64 192V64l64-64v128l-64 64Zm128 128V192l64-64v128l-64 64ZM0 256V128l64 64l-64 64Z"></path><path fill="#0FF" d="M64 320V192l64 64z"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/index.css
new file mode 100644
index 0000000..4ffca5c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/index.css
@@ -0,0 +1,24 @@
+:root {
+  color-scheme: light dark;
+  background-color: #ffffff;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    background-color: #16171d;
+  }
+}
+
+body {
+  margin: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  min-width: 320px;
+  min-height: 100svh;
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  overflow-x: hidden;
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/my-element.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/my-element.js
new file mode 100644
index 0000000..3f63508
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-lit/src/my-element.js
@@ -0,0 +1,442 @@
+import { LitElement, css, html } from 'lit'
+import litLogo from './assets/lit.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+
+/**
+ * An example element.
+ *
+ * @slot - This element has a slot
+ * @csspart button - The button
+ */
+export class MyElement extends LitElement {
+  static get properties() {
+    return {
+      /**
+       * The number of times the button has been clicked.
+       */
+      count: { type: Number },
+    }
+  }
+
+  constructor() {
+    super()
+    this.count = 0
+  }
+
+  render() {
+    return html`
+      <section id="center">
+        <div class="hero">
+          <img src=${heroImg} class="base" width="170" height="179" alt="" />
+          <img src=${litLogo} class="framework" alt="Lit logo" />
+          <img src=${viteLogo} class="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <slot></slot>
+          <p>
+            Edit <code>src/my-element.js</code> and save to test
+            <code>HMR</code>
+          </p>
+        </div>
+        <button
+          type="button"
+          class="counter"
+          @click=${this._onClick}
+          part="button"
+        >
+          Count is ${this.count}
+        </button>
+      </section>
+
+      <div class="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img class="logo" src=${viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://lit.dev/" target="_blank">
+                <img class="button-icon" src=${litLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div class="ticks"></div>
+      <section id="spacer"></section>
+    `
+  }
+
+  _onClick() {
+    this.count++
+  }
+
+  static get styles() {
+    return css`
+      :host {
+        --text: #6b6375;
+        --text-h: #08060d;
+        --bg: #fff;
+        --border: #e5e4e7;
+        --code-bg: #f4f3ec;
+        --accent: #aa3bff;
+        --accent-bg: rgba(170, 59, 255, 0.1);
+        --accent-border: rgba(170, 59, 255, 0.5);
+        --social-bg: rgba(244, 243, 236, 0.5);
+        --shadow:
+          rgba(0, 0, 0, 0.1) 0 10px 15px -3px,
+          rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+        --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+        --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+        --mono: ui-monospace, Consolas, monospace;
+
+        font: 18px/145% var(--sans);
+        letter-spacing: 0.18px;
+
+        width: 1126px;
+        max-width: 100%;
+        margin: 0 auto;
+        text-align: center;
+        border-inline: 1px solid var(--border);
+        min-height: 100svh;
+        display: flex;
+        flex-direction: column;
+        box-sizing: border-box;
+        color: var(--text);
+      }
+
+      @media (prefers-color-scheme: dark) {
+        :host {
+          --text: #9ca3af;
+          --text-h: #f3f4f6;
+          --bg: #16171d;
+          --border: #2e303a;
+          --code-bg: #1f2028;
+          --accent: #c084fc;
+          --accent-bg: rgba(192, 132, 252, 0.15);
+          --accent-border: rgba(192, 132, 252, 0.5);
+          --social-bg: rgba(47, 48, 58, 0.5);
+          --shadow:
+            rgba(0, 0, 0, 0.4) 0 10px 15px -3px,
+            rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+        }
+
+        #social .button-icon {
+          filter: invert(1) brightness(2);
+        }
+      }
+
+      h1,
+      h2,
+      ::slotted(h1),
+      ::slotted(h2) {
+        font-family: var(--heading);
+        font-weight: 500;
+        color: var(--text-h);
+      }
+
+      h1,
+      ::slotted(h1) {
+        font-size: 56px;
+        letter-spacing: -1.68px;
+        margin: 32px 0;
+      }
+
+      h2 {
+        font-size: 24px;
+        line-height: 118%;
+        letter-spacing: -0.24px;
+        margin: 0 0 8px;
+      }
+
+      p {
+        margin: 0;
+      }
+
+      code {
+        font-family: var(--mono);
+        font-size: 15px;
+        line-height: 135%;
+        display: inline-flex;
+        padding: 4px 8px;
+        border-radius: 4px;
+        color: var(--text-h);
+        background: var(--code-bg);
+      }
+
+      .counter {
+        font-family: var(--mono);
+        font-size: 16px;
+        display: inline-flex;
+        padding: 5px 10px;
+        border-radius: 5px;
+        color: var(--accent);
+        background: var(--accent-bg);
+        border: 2px solid transparent;
+        transition: border-color 0.3s;
+        margin-bottom: 24px;
+        cursor: pointer;
+      }
+
+      .counter:hover {
+        border-color: var(--accent-border);
+      }
+
+      .counter:focus-visible {
+        outline: 2px solid var(--accent);
+        outline-offset: 2px;
+      }
+
+      .hero {
+        position: relative;
+      }
+
+      .hero .base,
+      .hero .framework,
+      .hero .vite {
+        inset-inline: 0;
+        margin: 0 auto;
+      }
+
+      .hero .base {
+        width: 170px;
+        position: relative;
+        z-index: 0;
+      }
+
+      .hero .framework,
+      .hero .vite {
+        position: absolute;
+      }
+
+      .hero .framework {
+        z-index: 1;
+        top: 34px;
+        height: 28px;
+        transform: perspective(2000px) rotateZ(300deg) rotateX(44deg)
+          rotateY(39deg) scale(1.4);
+      }
+
+      .hero .vite {
+        z-index: 0;
+        top: 107px;
+        height: 26px;
+        width: auto;
+        transform: perspective(2000px) rotateZ(300deg) rotateX(40deg)
+          rotateY(39deg) scale(0.8);
+      }
+
+      #center {
+        display: flex;
+        flex-direction: column;
+        gap: 25px;
+        place-content: center;
+        place-items: center;
+        flex-grow: 1;
+      }
+
+      #next-steps {
+        display: flex;
+        border-top: 1px solid var(--border);
+        text-align: left;
+      }
+
+      #next-steps > div {
+        flex: 1 1 0;
+        padding: 32px;
+      }
+
+      #next-steps .icon {
+        margin-bottom: 16px;
+        width: 22px;
+        height: 22px;
+      }
+
+      #docs {
+        border-right: 1px solid var(--border);
+      }
+
+      #next-steps ul {
+        list-style: none;
+        padding: 0;
+        display: flex;
+        gap: 8px;
+        margin: 32px 0 0;
+      }
+
+      #next-steps ul .logo {
+        height: 18px;
+      }
+
+      #next-steps ul .logo svg {
+        height: 100%;
+        width: auto;
+      }
+
+      #next-steps ul a {
+        color: var(--text-h);
+        font-size: 16px;
+        border-radius: 6px;
+        background: var(--social-bg);
+        display: flex;
+        padding: 6px 12px;
+        align-items: center;
+        gap: 8px;
+        text-decoration: none;
+        transition: box-shadow 0.3s;
+      }
+
+      #next-steps ul a:hover {
+        box-shadow: var(--shadow);
+      }
+
+      #next-steps ul .button-icon {
+        height: 18px;
+        width: 18px;
+      }
+
+      #spacer {
+        height: 88px;
+        border-top: 1px solid var(--border);
+      }
+
+      .ticks {
+        position: relative;
+        width: 100%;
+      }
+
+      .ticks::before,
+      .ticks::after {
+        content: '';
+        position: absolute;
+        top: -4.5px;
+        border: 5px solid transparent;
+      }
+
+      .ticks::before {
+        left: 0;
+        border-left-color: var(--border);
+      }
+
+      .ticks::after {
+        right: 0;
+        border-right-color: var(--border);
+      }
+
+      @media (max-width: 1024px) {
+        :host {
+          font-size: 16px;
+          width: 100%;
+          max-width: 100%;
+        }
+
+        h1,
+        ::slotted(h1) {
+          font-size: 36px;
+          margin: 20px 0;
+        }
+
+        h2,
+        ::slotted(h2) {
+          font-size: 20px;
+        }
+
+        #center {
+          padding: 32px 20px 24px;
+          gap: 18px;
+        }
+
+        #next-steps {
+          flex-direction: column;
+          text-align: center;
+        }
+
+        #next-steps > div {
+          padding: 24px 20px;
+        }
+
+        #docs {
+          border-right: none;
+          border-bottom: 1px solid var(--border);
+        }
+
+        #next-steps ul {
+          margin-top: 20px;
+          flex-wrap: wrap;
+          justify-content: center;
+        }
+
+        #next-steps ul li {
+          flex: 1 1 calc(50% - 8px);
+        }
+
+        #next-steps ul a {
+          width: 100%;
+          justify-content: center;
+          box-sizing: border-box;
+        }
+
+        #spacer {
+          height: 48px;
+        }
+      }
+    `
+  }
+}
+
+window.customElements.define('my-element', MyElement)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/index.html
new file mode 100644
index 0000000..dd25d63
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Preact + TS</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/package.json
new file mode 100644
index 0000000..905229e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "vite-preact-ts-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "preact": "^10.29.1"
+  },
+  "devDependencies": {
+    "@preact/preset-vite": "^2.10.5",
+    "@types/node": "^24.12.3",
+    "typescript": "~6.0.2",
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/app.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/app.css
new file mode 100644
index 0000000..3e2ec78
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/app.css
@@ -0,0 +1,196 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/app.tsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/app.tsx
new file mode 100644
index 0000000..ea79489
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/app.tsx
@@ -0,0 +1,104 @@
+import { useState } from 'preact/hooks'
+import preactLogo from './assets/preact.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import './app.css'
+
+export function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <>
+      <section id="center">
+        <div class="hero">
+          <img src={heroImg} class="base" width="170" height="179" alt="" />
+          <img src={preactLogo} class="framework" alt="Preact logo" />
+          <img src={viteLogo} class="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <h1>Get started</h1>
+          <p>
+            Edit <code>src/app.tsx</code> and save to test <code>HMR</code>
+          </p>
+        </div>
+        <button
+          type="button"
+          class="counter"
+          onClick={() => setCount((count) => count + 1)}
+        >
+          Count is {count}
+        </button>
+      </section>
+
+      <div class="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img class="logo" src={viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://preactjs.com/" target="_blank">
+                <img class="button-icon" src={preactLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div class="ticks"></div>
+      <section id="spacer"></section>
+    </>
+  )
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/assets/preact.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/assets/preact.svg
new file mode 100644
index 0000000..908f17d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/assets/preact.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="27.68" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 296"><path fill="#673AB8" d="m128 0l128 73.9v147.8l-128 73.9L0 221.7V73.9z"></path><path fill="#FFF" d="M34.865 220.478c17.016 21.78 71.095 5.185 122.15-34.704c51.055-39.888 80.24-88.345 63.224-110.126c-17.017-21.78-71.095-5.184-122.15 34.704c-51.055 39.89-80.24 88.346-63.224 110.126Zm7.27-5.68c-5.644-7.222-3.178-21.402 7.573-39.253c11.322-18.797 30.541-39.548 54.06-57.923c23.52-18.375 48.303-32.004 69.281-38.442c19.922-6.113 34.277-5.075 39.92 2.148c5.644 7.223 3.178 21.403-7.573 39.254c-11.322 18.797-30.541 39.547-54.06 57.923c-23.52 18.375-48.304 32.004-69.281 38.441c-19.922 6.114-34.277 5.076-39.92-2.147Z"></path><path fill="#FFF" d="M220.239 220.478c17.017-21.78-12.169-70.237-63.224-110.126C105.96 70.464 51.88 53.868 34.865 75.648c-17.017 21.78 12.169 70.238 63.224 110.126c51.055 39.889 105.133 56.485 122.15 34.704Zm-7.27-5.68c-5.643 7.224-19.998 8.262-39.92 2.148c-20.978-6.437-45.761-20.066-69.28-38.441c-23.52-18.376-42.74-39.126-54.06-57.923c-10.752-17.851-13.218-32.03-7.575-39.254c5.644-7.223 19.999-8.261 39.92-2.148c20.978 6.438 45.762 20.067 69.281 38.442c23.52 18.375 42.739 39.126 54.06 57.923c10.752 17.85 13.218 32.03 7.574 39.254Z"></path><path fill="#FFF" d="M127.552 167.667c10.827 0 19.603-8.777 19.603-19.604c0-10.826-8.776-19.603-19.603-19.603c-10.827 0-19.604 8.777-19.604 19.603c0 10.827 8.777 19.604 19.604 19.604Z"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/index.css
new file mode 100644
index 0000000..2bdd44f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/index.css
@@ -0,0 +1,111 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/main.tsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/main.tsx
new file mode 100644
index 0000000..bfb172e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/src/main.tsx
@@ -0,0 +1,5 @@
+import { render } from 'preact'
+import './index.css'
+import { App } from './app.tsx'
+
+render(<App />, document.getElementById('app')!)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/tsconfig.app.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/tsconfig.app.json
new file mode 100644
index 0000000..3b144be
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/tsconfig.app.json
@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "es2023",
+    "module": "esnext",
+    "lib": ["ES2023", "DOM"],
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+    "paths": {
+      "react": ["./node_modules/preact/compat/"],
+      "react-dom": ["./node_modules/preact/compat/"]
+    },
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact",
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/tsconfig.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/tsconfig.json
new file mode 100644
index 0000000..1ffef60
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/tsconfig.node.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/tsconfig.node.json
new file mode 100644
index 0000000..d3c52ea
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/tsconfig.node.json
@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "es2023",
+    "lib": ["ES2023"],
+    "module": "esnext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/vite.config.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/vite.config.ts
new file mode 100644
index 0000000..b995c32
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact-ts/vite.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import preact from '@preact/preset-vite'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [preact()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/index.html
new file mode 100644
index 0000000..d06ca44
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Preact</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/package.json
new file mode 100644
index 0000000..e53cea8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "vite-preact-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "preact": "^10.29.1"
+  },
+  "devDependencies": {
+    "@preact/preset-vite": "^2.10.5",
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/app.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/app.css
new file mode 100644
index 0000000..3e2ec78
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/app.css
@@ -0,0 +1,196 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/app.jsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/app.jsx
new file mode 100644
index 0000000..9088c55
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/app.jsx
@@ -0,0 +1,104 @@
+import { useState } from 'preact/hooks'
+import preactLogo from './assets/preact.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import './app.css'
+
+export function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <>
+      <section id="center">
+        <div class="hero">
+          <img src={heroImg} class="base" width="170" height="179" alt="" />
+          <img src={preactLogo} class="framework" alt="Preact logo" />
+          <img src={viteLogo} class="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <h1>Get started</h1>
+          <p>
+            Edit <code>src/app.jsx</code> and save to test <code>HMR</code>
+          </p>
+        </div>
+        <button
+          type="button"
+          class="counter"
+          onClick={() => setCount((count) => count + 1)}
+        >
+          Count is {count}
+        </button>
+      </section>
+
+      <div class="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img class="logo" src={viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://preactjs.com/" target="_blank">
+                <img class="button-icon" src={preactLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div class="ticks"></div>
+      <section id="spacer"></section>
+    </>
+  )
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/assets/preact.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/assets/preact.svg
new file mode 100644
index 0000000..908f17d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/assets/preact.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="27.68" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 296"><path fill="#673AB8" d="m128 0l128 73.9v147.8l-128 73.9L0 221.7V73.9z"></path><path fill="#FFF" d="M34.865 220.478c17.016 21.78 71.095 5.185 122.15-34.704c51.055-39.888 80.24-88.345 63.224-110.126c-17.017-21.78-71.095-5.184-122.15 34.704c-51.055 39.89-80.24 88.346-63.224 110.126Zm7.27-5.68c-5.644-7.222-3.178-21.402 7.573-39.253c11.322-18.797 30.541-39.548 54.06-57.923c23.52-18.375 48.303-32.004 69.281-38.442c19.922-6.113 34.277-5.075 39.92 2.148c5.644 7.223 3.178 21.403-7.573 39.254c-11.322 18.797-30.541 39.547-54.06 57.923c-23.52 18.375-48.304 32.004-69.281 38.441c-19.922 6.114-34.277 5.076-39.92-2.147Z"></path><path fill="#FFF" d="M220.239 220.478c17.017-21.78-12.169-70.237-63.224-110.126C105.96 70.464 51.88 53.868 34.865 75.648c-17.017 21.78 12.169 70.238 63.224 110.126c51.055 39.889 105.133 56.485 122.15 34.704Zm-7.27-5.68c-5.643 7.224-19.998 8.262-39.92 2.148c-20.978-6.437-45.761-20.066-69.28-38.441c-23.52-18.376-42.74-39.126-54.06-57.923c-10.752-17.851-13.218-32.03-7.575-39.254c5.644-7.223 19.999-8.261 39.92-2.148c20.978 6.438 45.762 20.067 69.281 38.442c23.52 18.375 42.739 39.126 54.06 57.923c10.752 17.85 13.218 32.03 7.574 39.254Z"></path><path fill="#FFF" d="M127.552 167.667c10.827 0 19.603-8.777 19.603-19.604c0-10.826-8.776-19.603-19.603-19.603c-10.827 0-19.604 8.777-19.604 19.603c0 10.827 8.777 19.604 19.604 19.604Z"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/index.css
new file mode 100644
index 0000000..2bdd44f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/index.css
@@ -0,0 +1,111 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/main.jsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/main.jsx
new file mode 100644
index 0000000..26b0467
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/src/main.jsx
@@ -0,0 +1,5 @@
+import { render } from 'preact'
+import './index.css'
+import { App } from './app.jsx'
+
+render(<App />, document.getElementById('app'))
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/vite.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/vite.config.js
new file mode 100644
index 0000000..b995c32
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-preact/vite.config.js
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import preact from '@preact/preset-vite'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [preact()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/README.md
new file mode 100644
index 0000000..c1aaa6b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/README.md
@@ -0,0 +1,38 @@
+# Qwik + Vite
+
+## Qwik in CSR mode
+
+This starter is using a pure CSR (Client-Side Rendering) mode. This means, that the application is fully bootstrapped in the browser. Most of Qwik innovations however take advantage of SSR (Server-Side Rendering) mode.
+
+```ts
+export default defineConfig({
+  plugins: [
+    qwikVite({
+      csr: true,
+    }),
+  ],
+})
+```
+
+Use `npm create qwik@latest` to create a full production ready Qwik application, using SSR and [QwikCity](https://qwik.dev/docs/qwikcity/), our server-side meta-framework.
+
+## Usage
+
+```bash
+$ npm install # or pnpm install or yarn install
+```
+
+Learn more on the [Qwik Website](https://qwik.dev) and join our community on our [Discord](https://qwik.dev/chat)
+
+## Available Scripts
+
+In the project directory, you can run:
+
+### `npm run dev`
+
+Runs the app in the development mode.<br>
+Open [http://localhost:5173](http://localhost:5173) to view it in the browser.
+
+### `npm run build`
+
+Builds the app for production to the `dist` folder.<br>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/index.html
new file mode 100644
index 0000000..78dd6f4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Qwik + TS</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/package.json
new file mode 100644
index 0000000..4f65e7d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "vite-qwik",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "serve dist"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.3",
+    "serve": "^14.2.6",
+    "typescript": "~6.0.2",
+    "vite": "^8.0.12"
+  },
+  "dependencies": {
+    "@builder.io/qwik": "^1.19.2"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/app.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/app.css
new file mode 100644
index 0000000..3e2ec78
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/app.css
@@ -0,0 +1,196 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/app.tsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/app.tsx
new file mode 100644
index 0000000..350813e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/app.tsx
@@ -0,0 +1,101 @@
+import { component$, useSignal } from '@builder.io/qwik'
+
+import qwikLogo from './assets/qwik.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import './app.css'
+
+export const App = component$(() => {
+  const count = useSignal(0)
+
+  return (
+    <>
+      <section id="center">
+        <div class="hero">
+          <img src={heroImg} class="base" width="170" height="179" alt="" />
+          <img src={qwikLogo} class="framework" alt="Qwik logo" />
+          <img src={viteLogo} class="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <h1>Get started</h1>
+          <p>
+            Edit <code>src/app.tsx</code> and save to test <code>HMR</code>
+          </p>
+        </div>
+        <button type="button" class="counter" onClick$={() => count.value++}>
+          Count is {count.value}
+        </button>
+      </section>
+
+      <div class="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img class="logo" src={viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://qwik.dev/" target="_blank">
+                <img class="button-icon" src={qwikLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div class="ticks"></div>
+      <section id="spacer"></section>
+    </>
+  )
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/assets/qwik.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/assets/qwik.svg
new file mode 100644
index 0000000..08a46e2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/assets/qwik.svg
@@ -0,0 +1,5 @@
+<svg width="110" height="118" viewBox="0 0 110 118" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M96.8285 117.176L75.9674 96.4188L75.67 96.4705V96.2507L31.3094 52.3816L42.2638 41.8282L35.8231 4.91711L5.33977 42.7335C0.166531 47.9585 -0.829317 56.5072 2.92128 62.7798L21.9717 94.4012C24.8817 99.2511 29.46 102.368 35.849 102.135C49.377 101.657 55.3262 101.657 55.3262 101.657L96.8156 117.163L96.8285 117.176Z" fill="#18B6F6"/>
+<path d="M107.134 59.0164C110.134 52.8214 111.208 47.4024 108.246 41.9576L104.03 34.1977L101.844 30.2143L100.991 28.6624L100.913 28.7529L89.4413 8.84886C86.5443 3.81789 81.19 0.752745 75.3571 0.804478L65.2952 1.08901L35.2645 1.1666C29.5869 1.21834 24.3749 4.20588 21.4908 9.10753L3.24219 45.3461L35.8983 4.72321L78.7327 51.8256L71.0634 59.5983L75.6417 96.4447L75.7063 96.3671V96.4706H75.6417L75.7322 96.5611L79.3017 100.04L96.5804 116.918C97.3046 117.616 98.4815 116.776 98.003 115.909L87.3203 94.8928" fill="#AC7EF4"/>
+<path d="M78.8354 51.7092L35.8846 4.8396L41.989 41.5437L31.0605 52.1489L75.5633 96.3801L71.5541 59.663L78.8354 51.7221V51.7092Z" fill="white"/>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/index.css
new file mode 100644
index 0000000..2bdd44f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/index.css
@@ -0,0 +1,111 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/main.tsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/main.tsx
new file mode 100644
index 0000000..3ab6fcc
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/src/main.tsx
@@ -0,0 +1,7 @@
+import '@builder.io/qwik/qwikloader.js'
+
+import { render } from '@builder.io/qwik'
+import './index.css'
+import { App } from './app.tsx'
+
+render(document.getElementById('app') as HTMLElement, <App />)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/tsconfig.app.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/tsconfig.app.json
new file mode 100644
index 0000000..8e60c4d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/tsconfig.app.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "es2023",
+    "module": "esnext",
+    "lib": ["ES2023", "DOM"],
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "@builder.io/qwik",
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/tsconfig.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/tsconfig.json
new file mode 100644
index 0000000..1ffef60
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/tsconfig.node.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/tsconfig.node.json
new file mode 100644
index 0000000..d3c52ea
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/tsconfig.node.json
@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "es2023",
+    "lib": ["ES2023"],
+    "module": "esnext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/vite.config.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/vite.config.ts
new file mode 100644
index 0000000..8c07d8f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik-ts/vite.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite'
+import { qwikVite } from '@builder.io/qwik/optimizer'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [
+    qwikVite({
+      csr: true,
+    }),
+  ],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/README.md
new file mode 100644
index 0000000..c1aaa6b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/README.md
@@ -0,0 +1,38 @@
+# Qwik + Vite
+
+## Qwik in CSR mode
+
+This starter is using a pure CSR (Client-Side Rendering) mode. This means, that the application is fully bootstrapped in the browser. Most of Qwik innovations however take advantage of SSR (Server-Side Rendering) mode.
+
+```ts
+export default defineConfig({
+  plugins: [
+    qwikVite({
+      csr: true,
+    }),
+  ],
+})
+```
+
+Use `npm create qwik@latest` to create a full production ready Qwik application, using SSR and [QwikCity](https://qwik.dev/docs/qwikcity/), our server-side meta-framework.
+
+## Usage
+
+```bash
+$ npm install # or pnpm install or yarn install
+```
+
+Learn more on the [Qwik Website](https://qwik.dev) and join our community on our [Discord](https://qwik.dev/chat)
+
+## Available Scripts
+
+In the project directory, you can run:
+
+### `npm run dev`
+
+Runs the app in the development mode.<br>
+Open [http://localhost:5173](http://localhost:5173) to view it in the browser.
+
+### `npm run build`
+
+Builds the app for production to the `dist` folder.<br>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/index.html
new file mode 100644
index 0000000..764c7c8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Qwik</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/package.json
new file mode 100644
index 0000000..739ccfd
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "vite-qwik",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "serve dist"
+  },
+  "devDependencies": {
+    "serve": "^14.2.6",
+    "vite": "^8.0.12"
+  },
+  "dependencies": {
+    "@builder.io/qwik": "^1.19.2"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/app.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/app.css
new file mode 100644
index 0000000..3e2ec78
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/app.css
@@ -0,0 +1,196 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/app.jsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/app.jsx
new file mode 100644
index 0000000..d6b8a64
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/app.jsx
@@ -0,0 +1,101 @@
+import { component$, useSignal } from '@builder.io/qwik'
+
+import qwikLogo from './assets/qwik.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import './app.css'
+
+export const App = component$(() => {
+  const count = useSignal(0)
+
+  return (
+    <>
+      <section id="center">
+        <div class="hero">
+          <img src={heroImg} class="base" width="170" height="179" alt="" />
+          <img src={qwikLogo} class="framework" alt="Qwik logo" />
+          <img src={viteLogo} class="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <h1>Get started</h1>
+          <p>
+            Edit <code>src/app.jsx</code> and save to test <code>HMR</code>
+          </p>
+        </div>
+        <button type="button" class="counter" onClick$={() => count.value++}>
+          Count is {count.value}
+        </button>
+      </section>
+
+      <div class="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img class="logo" src={viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://qwik.dev/" target="_blank">
+                <img class="button-icon" src={qwikLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div class="ticks"></div>
+      <section id="spacer"></section>
+    </>
+  )
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/assets/qwik.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/assets/qwik.svg
new file mode 100644
index 0000000..08a46e2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/assets/qwik.svg
@@ -0,0 +1,5 @@
+<svg width="110" height="118" viewBox="0 0 110 118" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M96.8285 117.176L75.9674 96.4188L75.67 96.4705V96.2507L31.3094 52.3816L42.2638 41.8282L35.8231 4.91711L5.33977 42.7335C0.166531 47.9585 -0.829317 56.5072 2.92128 62.7798L21.9717 94.4012C24.8817 99.2511 29.46 102.368 35.849 102.135C49.377 101.657 55.3262 101.657 55.3262 101.657L96.8156 117.163L96.8285 117.176Z" fill="#18B6F6"/>
+<path d="M107.134 59.0164C110.134 52.8214 111.208 47.4024 108.246 41.9576L104.03 34.1977L101.844 30.2143L100.991 28.6624L100.913 28.7529L89.4413 8.84886C86.5443 3.81789 81.19 0.752745 75.3571 0.804478L65.2952 1.08901L35.2645 1.1666C29.5869 1.21834 24.3749 4.20588 21.4908 9.10753L3.24219 45.3461L35.8983 4.72321L78.7327 51.8256L71.0634 59.5983L75.6417 96.4447L75.7063 96.3671V96.4706H75.6417L75.7322 96.5611L79.3017 100.04L96.5804 116.918C97.3046 117.616 98.4815 116.776 98.003 115.909L87.3203 94.8928" fill="#AC7EF4"/>
+<path d="M78.8354 51.7092L35.8846 4.8396L41.989 41.5437L31.0605 52.1489L75.5633 96.3801L71.5541 59.663L78.8354 51.7221V51.7092Z" fill="white"/>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/index.css
new file mode 100644
index 0000000..2bdd44f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/index.css
@@ -0,0 +1,111 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/main.jsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/main.jsx
new file mode 100644
index 0000000..d2dcca9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/src/main.jsx
@@ -0,0 +1,7 @@
+import '@builder.io/qwik/qwikloader.js'
+
+import { render } from '@builder.io/qwik'
+import './index.css'
+import { App } from './app.jsx'
+
+render(document.getElementById('app'), <App />)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/vite.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/vite.config.js
new file mode 100644
index 0000000..8c07d8f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-qwik/vite.config.js
@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite'
+import { qwikVite } from '@builder.io/qwik/optimizer'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [
+    qwikVite({
+      csr: true,
+    }),
+  ],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/README.md
new file mode 100644
index 0000000..7dbf7eb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/README.md
@@ -0,0 +1,73 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/eslint.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/eslint.config.js
new file mode 100644
index 0000000..ef614d2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/eslint.config.js
@@ -0,0 +1,22 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      globals: globals.browser,
+    },
+  },
+])
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/index.html
new file mode 100644
index 0000000..3d38e14
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React + TS</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/package.json
new file mode 100644
index 0000000..c64e820
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/package.json
@@ -0,0 +1,30 @@
+{
+  "name": "vite-react-typescript-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^24.12.3",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "eslint": "^10.3.0",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.6.0",
+    "typescript": "~6.0.2",
+    "typescript-eslint": "^8.59.2",
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/App.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/App.css
new file mode 100644
index 0000000..f90339d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/App.css
@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/App.tsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/App.tsx
new file mode 100644
index 0000000..a66b5ef
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/App.tsx
@@ -0,0 +1,122 @@
+import { useState } from 'react'
+import reactLogo from './assets/react.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import './App.css'
+
+function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <>
+      <section id="center">
+        <div className="hero">
+          <img src={heroImg} className="base" width="170" height="179" alt="" />
+          <img src={reactLogo} className="framework" alt="React logo" />
+          <img src={viteLogo} className="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <h1>Get started</h1>
+          <p>
+            Edit <code>src/App.tsx</code> and save to test <code>HMR</code>
+          </p>
+        </div>
+        <button
+          type="button"
+          className="counter"
+          onClick={() => setCount((count) => count + 1)}
+        >
+          Count is {count}
+        </button>
+      </section>
+
+      <div className="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg className="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img className="logo" src={viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://react.dev/" target="_blank">
+                <img className="button-icon" src={reactLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg className="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg
+                  className="button-icon"
+                  role="presentation"
+                  aria-hidden="true"
+                >
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg
+                  className="button-icon"
+                  role="presentation"
+                  aria-hidden="true"
+                >
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg
+                  className="button-icon"
+                  role="presentation"
+                  aria-hidden="true"
+                >
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg
+                  className="button-icon"
+                  role="presentation"
+                  aria-hidden="true"
+                >
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div className="ticks"></div>
+      <section id="spacer"></section>
+    </>
+  )
+}
+
+export default App
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/assets/react.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/assets/react.svg
new file mode 100644
index 0000000..6c87de9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/assets/react.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/index.css
new file mode 100644
index 0000000..5fb3313
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/index.css
@@ -0,0 +1,111 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/main.tsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/main.tsx
new file mode 100644
index 0000000..bef5202
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/src/main.tsx
@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/tsconfig.app.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/tsconfig.app.json
new file mode 100644
index 0000000..7f42e5f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/tsconfig.app.json
@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "es2023",
+    "lib": ["ES2023", "DOM"],
+    "module": "esnext",
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/tsconfig.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/tsconfig.json
new file mode 100644
index 0000000..1ffef60
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/tsconfig.node.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/tsconfig.node.json
new file mode 100644
index 0000000..d3c52ea
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/tsconfig.node.json
@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "es2023",
+    "lib": ["ES2023"],
+    "module": "esnext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/vite.config.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/vite.config.ts
new file mode 100644
index 0000000..8b0f57b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react-ts/vite.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/README.md
new file mode 100644
index 0000000..a36934d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/README.md
@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/eslint.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/eslint.config.js
new file mode 100644
index 0000000..ea36dd3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/eslint.config.js
@@ -0,0 +1,21 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      globals: globals.browser,
+      parserOptions: { ecmaFeatures: { jsx: true } },
+    },
+  },
+])
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/index.html
new file mode 100644
index 0000000..594488a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/package.json
new file mode 100644
index 0000000..073e0d8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "vite-react-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "eslint": "^10.3.0",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.6.0",
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/App.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/App.css
new file mode 100644
index 0000000..f90339d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/App.css
@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/App.jsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/App.jsx
new file mode 100644
index 0000000..4f03aa1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/App.jsx
@@ -0,0 +1,122 @@
+import { useState } from 'react'
+import reactLogo from './assets/react.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import './App.css'
+
+function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <>
+      <section id="center">
+        <div className="hero">
+          <img src={heroImg} className="base" width="170" height="179" alt="" />
+          <img src={reactLogo} className="framework" alt="React logo" />
+          <img src={viteLogo} className="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <h1>Get started</h1>
+          <p>
+            Edit <code>src/App.jsx</code> and save to test <code>HMR</code>
+          </p>
+        </div>
+        <button
+          type="button"
+          className="counter"
+          onClick={() => setCount((count) => count + 1)}
+        >
+          Count is {count}
+        </button>
+      </section>
+
+      <div className="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg className="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img className="logo" src={viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://react.dev/" target="_blank">
+                <img className="button-icon" src={reactLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg className="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg
+                  className="button-icon"
+                  role="presentation"
+                  aria-hidden="true"
+                >
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg
+                  className="button-icon"
+                  role="presentation"
+                  aria-hidden="true"
+                >
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg
+                  className="button-icon"
+                  role="presentation"
+                  aria-hidden="true"
+                >
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg
+                  className="button-icon"
+                  role="presentation"
+                  aria-hidden="true"
+                >
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div className="ticks"></div>
+      <section id="spacer"></section>
+    </>
+  )
+}
+
+export default App
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/assets/react.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/assets/react.svg
new file mode 100644
index 0000000..6c87de9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/assets/react.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/index.css
new file mode 100644
index 0000000..2c84af0
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/index.css
@@ -0,0 +1,111 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/main.jsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/main.jsx
new file mode 100644
index 0000000..b9a1a6d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/src/main.jsx
@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/vite.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/vite.config.js
new file mode 100644
index 0000000..8b0f57b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-react/vite.config.js
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/README.md
new file mode 100644
index 0000000..167c567
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/README.md
@@ -0,0 +1,28 @@
+## Usage
+
+```bash
+$ npm install # or pnpm install or yarn install
+```
+
+### Learn more on the [Solid Website](https://solidjs.com) and come chat with us on our [Discord](https://discord.com/invite/solidjs)
+
+## Available Scripts
+
+In the project directory, you can run:
+
+### `npm run dev`
+
+Runs the app in the development mode.<br>
+Open [http://localhost:5173](http://localhost:5173) to view it in the browser.
+
+### `npm run build`
+
+Builds the app for production to the `dist` folder.<br>
+It correctly bundles Solid in production mode and optimizes the build for the best performance.
+
+The build is minified and the filenames include the hashes.<br>
+Your app is ready to be deployed!
+
+## Deployment
+
+Learn more about deploying your application with the [documentations](https://vite.dev/guide/static-deploy.html)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/index.html
new file mode 100644
index 0000000..51addad
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Solid + TS</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/index.tsx"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/package.json
new file mode 100644
index 0000000..cbeb5d6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "vite-solid-typescript-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "solid-js": "^1.9.12"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.3",
+    "typescript": "~6.0.2",
+    "vite": "^8.0.12",
+    "vite-plugin-solid": "^2.11.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/App.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/App.css
new file mode 100644
index 0000000..f90339d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/App.css
@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/App.tsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/App.tsx
new file mode 100644
index 0000000..d9148cf
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/App.tsx
@@ -0,0 +1,106 @@
+import { createSignal } from 'solid-js'
+import solidLogo from './assets/solid.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import './App.css'
+
+function App() {
+  const [count, setCount] = createSignal(0)
+
+  return (
+    <>
+      <section id="center">
+        <div class="hero">
+          <img src={heroImg} class="base" width="170" height="179" alt="" />
+          <img src={solidLogo} class="framework" alt="Solid logo" />
+          <img src={viteLogo} class="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <h1>Get started</h1>
+          <p>
+            Edit <code>src/App.tsx</code> and save to test <code>HMR</code>
+          </p>
+        </div>
+        <button
+          type="button"
+          class="counter"
+          onClick={() => setCount((count) => count + 1)}
+        >
+          Count is {count()}
+        </button>
+      </section>
+
+      <div class="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img class="logo" src={viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://solidjs.com/" target="_blank">
+                <img class="button-icon" src={solidLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div class="ticks"></div>
+      <section id="spacer"></section>
+    </>
+  )
+}
+
+export default App
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/assets/solid.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/assets/solid.svg
new file mode 100644
index 0000000..025aa30
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/assets/solid.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 166 155.3"><path d="M163 35S110-4 69 5l-3 1c-6 2-11 5-14 9l-2 3-15 26 26 5c11 7 25 10 38 7l46 9 18-30z" fill="#76b3e1"/><linearGradient id="a" gradientUnits="userSpaceOnUse" x1="27.5" y1="3" x2="152" y2="63.5"><stop offset=".1" stop-color="#76b3e1"/><stop offset=".3" stop-color="#dcf2fd"/><stop offset="1" stop-color="#76b3e1"/></linearGradient><path d="M163 35S110-4 69 5l-3 1c-6 2-11 5-14 9l-2 3-15 26 26 5c11 7 25 10 38 7l46 9 18-30z" opacity=".3" fill="url(#a)"/><path d="M52 35l-4 1c-17 5-22 21-13 35 10 13 31 20 48 15l62-21S92 26 52 35z" fill="#518ac8"/><linearGradient id="b" gradientUnits="userSpaceOnUse" x1="95.8" y1="32.6" x2="74" y2="105.2"><stop offset="0" stop-color="#76b3e1"/><stop offset=".5" stop-color="#4377bb"/><stop offset="1" stop-color="#1f3b77"/></linearGradient><path d="M52 35l-4 1c-17 5-22 21-13 35 10 13 31 20 48 15l62-21S92 26 52 35z" opacity=".3" fill="url(#b)"/><linearGradient id="c" gradientUnits="userSpaceOnUse" x1="18.4" y1="64.2" x2="144.3" y2="149.8"><stop offset="0" stop-color="#315aa9"/><stop offset=".5" stop-color="#518ac8"/><stop offset="1" stop-color="#315aa9"/></linearGradient><path d="M134 80a45 45 0 00-48-15L24 85 4 120l112 19 20-36c4-7 3-15-2-23z" fill="url(#c)"/><linearGradient id="d" gradientUnits="userSpaceOnUse" x1="75.2" y1="74.5" x2="24.4" y2="260.8"><stop offset="0" stop-color="#4377bb"/><stop offset=".5" stop-color="#1a336b"/><stop offset="1" stop-color="#1a336b"/></linearGradient><path d="M114 115a45 45 0 00-48-15L4 120s53 40 94 30l3-1c17-5 23-21 13-34z" fill="url(#d)"/></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/index.css
new file mode 100644
index 0000000..2c84af0
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/index.css
@@ -0,0 +1,111 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/index.tsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/index.tsx
new file mode 100644
index 0000000..f67cd20
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/src/index.tsx
@@ -0,0 +1,8 @@
+/* @refresh reload */
+import { render } from 'solid-js/web'
+import './index.css'
+import App from './App.tsx'
+
+const root = document.getElementById('root')
+
+render(() => <App />, root!)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/tsconfig.app.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/tsconfig.app.json
new file mode 100644
index 0000000..e8a00e4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/tsconfig.app.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "es2023",
+    "module": "esnext",
+    "lib": ["ES2023", "DOM"],
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "preserve",
+    "jsxImportSource": "solid-js",
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/tsconfig.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/tsconfig.json
new file mode 100644
index 0000000..1ffef60
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/tsconfig.node.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/tsconfig.node.json
new file mode 100644
index 0000000..d3c52ea
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/tsconfig.node.json
@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "es2023",
+    "lib": ["ES2023"],
+    "module": "esnext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/vite.config.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/vite.config.ts
new file mode 100644
index 0000000..4095d9b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid-ts/vite.config.ts
@@ -0,0 +1,6 @@
+import { defineConfig } from 'vite'
+import solid from 'vite-plugin-solid'
+
+export default defineConfig({
+  plugins: [solid()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/README.md
new file mode 100644
index 0000000..167c567
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/README.md
@@ -0,0 +1,28 @@
+## Usage
+
+```bash
+$ npm install # or pnpm install or yarn install
+```
+
+### Learn more on the [Solid Website](https://solidjs.com) and come chat with us on our [Discord](https://discord.com/invite/solidjs)
+
+## Available Scripts
+
+In the project directory, you can run:
+
+### `npm run dev`
+
+Runs the app in the development mode.<br>
+Open [http://localhost:5173](http://localhost:5173) to view it in the browser.
+
+### `npm run build`
+
+Builds the app for production to the `dist` folder.<br>
+It correctly bundles Solid in production mode and optimizes the build for the best performance.
+
+The build is minified and the filenames include the hashes.<br>
+Your app is ready to be deployed!
+
+## Deployment
+
+Learn more about deploying your application with the [documentations](https://vite.dev/guide/static-deploy.html)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/index.html
new file mode 100644
index 0000000..2ce5efa
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Solid</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/index.jsx"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/package.json
new file mode 100644
index 0000000..efbd526
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "vite-solid-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "solid-js": "^1.9.12"
+  },
+  "devDependencies": {
+    "vite": "^8.0.12",
+    "vite-plugin-solid": "^2.11.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/App.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/App.css
new file mode 100644
index 0000000..f90339d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/App.css
@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/App.jsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/App.jsx
new file mode 100644
index 0000000..c0f673b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/App.jsx
@@ -0,0 +1,106 @@
+import { createSignal } from 'solid-js'
+import solidLogo from './assets/solid.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import './App.css'
+
+function App() {
+  const [count, setCount] = createSignal(0)
+
+  return (
+    <>
+      <section id="center">
+        <div class="hero">
+          <img src={heroImg} class="base" width="170" height="179" alt="" />
+          <img src={solidLogo} class="framework" alt="Solid logo" />
+          <img src={viteLogo} class="vite" alt="Vite logo" />
+        </div>
+        <div>
+          <h1>Get started</h1>
+          <p>
+            Edit <code>src/App.jsx</code> and save to test <code>HMR</code>
+          </p>
+        </div>
+        <button
+          type="button"
+          class="counter"
+          onClick={() => setCount((count) => count + 1)}
+        >
+          Count is {count()}
+        </button>
+      </section>
+
+      <div class="ticks"></div>
+
+      <section id="next-steps">
+        <div id="docs">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#documentation-icon"></use>
+          </svg>
+          <h2>Documentation</h2>
+          <p>Your questions, answered</p>
+          <ul>
+            <li>
+              <a href="https://vite.dev/" target="_blank">
+                <img class="logo" src={viteLogo} alt="" />
+                Explore Vite
+              </a>
+            </li>
+            <li>
+              <a href="https://solidjs.com/" target="_blank">
+                <img class="button-icon" src={solidLogo} alt="" />
+                Learn more
+              </a>
+            </li>
+          </ul>
+        </div>
+        <div id="social">
+          <svg class="icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#social-icon"></use>
+          </svg>
+          <h2>Connect with us</h2>
+          <p>Join the Vite community</p>
+          <ul>
+            <li>
+              <a href="https://github.com/vitejs/vite" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#github-icon"></use>
+                </svg>
+                GitHub
+              </a>
+            </li>
+            <li>
+              <a href="https://chat.vite.dev/" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#discord-icon"></use>
+                </svg>
+                Discord
+              </a>
+            </li>
+            <li>
+              <a href="https://x.com/vite_js" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#x-icon"></use>
+                </svg>
+                X.com
+              </a>
+            </li>
+            <li>
+              <a href="https://bsky.app/profile/vite.dev" target="_blank">
+                <svg class="button-icon" role="presentation" aria-hidden="true">
+                  <use href="/icons.svg#bluesky-icon"></use>
+                </svg>
+                Bluesky
+              </a>
+            </li>
+          </ul>
+        </div>
+      </section>
+
+      <div class="ticks"></div>
+      <section id="spacer"></section>
+    </>
+  )
+}
+
+export default App
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/assets/solid.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/assets/solid.svg
new file mode 100644
index 0000000..025aa30
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/assets/solid.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 166 155.3"><path d="M163 35S110-4 69 5l-3 1c-6 2-11 5-14 9l-2 3-15 26 26 5c11 7 25 10 38 7l46 9 18-30z" fill="#76b3e1"/><linearGradient id="a" gradientUnits="userSpaceOnUse" x1="27.5" y1="3" x2="152" y2="63.5"><stop offset=".1" stop-color="#76b3e1"/><stop offset=".3" stop-color="#dcf2fd"/><stop offset="1" stop-color="#76b3e1"/></linearGradient><path d="M163 35S110-4 69 5l-3 1c-6 2-11 5-14 9l-2 3-15 26 26 5c11 7 25 10 38 7l46 9 18-30z" opacity=".3" fill="url(#a)"/><path d="M52 35l-4 1c-17 5-22 21-13 35 10 13 31 20 48 15l62-21S92 26 52 35z" fill="#518ac8"/><linearGradient id="b" gradientUnits="userSpaceOnUse" x1="95.8" y1="32.6" x2="74" y2="105.2"><stop offset="0" stop-color="#76b3e1"/><stop offset=".5" stop-color="#4377bb"/><stop offset="1" stop-color="#1f3b77"/></linearGradient><path d="M52 35l-4 1c-17 5-22 21-13 35 10 13 31 20 48 15l62-21S92 26 52 35z" opacity=".3" fill="url(#b)"/><linearGradient id="c" gradientUnits="userSpaceOnUse" x1="18.4" y1="64.2" x2="144.3" y2="149.8"><stop offset="0" stop-color="#315aa9"/><stop offset=".5" stop-color="#518ac8"/><stop offset="1" stop-color="#315aa9"/></linearGradient><path d="M134 80a45 45 0 00-48-15L24 85 4 120l112 19 20-36c4-7 3-15-2-23z" fill="url(#c)"/><linearGradient id="d" gradientUnits="userSpaceOnUse" x1="75.2" y1="74.5" x2="24.4" y2="260.8"><stop offset="0" stop-color="#4377bb"/><stop offset=".5" stop-color="#1a336b"/><stop offset="1" stop-color="#1a336b"/></linearGradient><path d="M114 115a45 45 0 00-48-15L4 120s53 40 94 30l3-1c17-5 23-21 13-34z" fill="url(#d)"/></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/index.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/index.css
new file mode 100644
index 0000000..2c84af0
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/index.css
@@ -0,0 +1,111 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/index.jsx b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/index.jsx
new file mode 100644
index 0000000..a80d6d7
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/src/index.jsx
@@ -0,0 +1,8 @@
+/* @refresh reload */
+import { render } from 'solid-js/web'
+import './index.css'
+import App from './App.jsx'
+
+const root = document.getElementById('root')
+
+render(() => <App />, root)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/vite.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/vite.config.js
new file mode 100644
index 0000000..4095d9b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-solid/vite.config.js
@@ -0,0 +1,6 @@
+import { defineConfig } from 'vite'
+import solid from 'vite-plugin-solid'
+
+export default defineConfig({
+  plugins: [solid()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/.vscode/extensions.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/.vscode/extensions.json
new file mode 100644
index 0000000..bdef820
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/.vscode/extensions.json
@@ -0,0 +1,3 @@
+{
+  "recommendations": ["svelte.svelte-vscode"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/README.md
new file mode 100644
index 0000000..e6cd94f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/README.md
@@ -0,0 +1,47 @@
+# Svelte + TS + Vite
+
+This template should help get you started developing with Svelte and TypeScript in Vite.
+
+## Recommended IDE Setup
+
+[VS Code](https://code.visualstudio.com/) + [Svelte](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode).
+
+## Need an official Svelte framework?
+
+Check out [SvelteKit](https://github.com/sveltejs/kit#readme), which is also powered by Vite. Deploy anywhere with its serverless-first approach and adapt to various platforms, with out of the box support for TypeScript, SCSS, and Less, and easily-added support for mdsvex, GraphQL, PostCSS, Tailwind CSS, and more.
+
+## Technical considerations
+
+**Why use this over SvelteKit?**
+
+- It brings its own routing solution which might not be preferable for some users.
+- It is first and foremost a framework that just happens to use Vite under the hood, not a Vite app.
+
+This template contains as little as possible to get started with Vite + TypeScript + Svelte, while taking into account the developer experience with regards to HMR and intellisense. It demonstrates capabilities on par with the other `create-vite` templates and is a good starting point for beginners dipping their toes into a Vite + Svelte project.
+
+Should you later need the extended capabilities and extensibility provided by SvelteKit, the template has been structured similarly to SvelteKit so that it is easy to migrate.
+
+**Why `global.d.ts` instead of `compilerOptions.types` inside `jsconfig.json` or `tsconfig.json`?**
+
+Setting `compilerOptions.types` shuts out all other types not explicitly listed in the configuration. Using triple-slash references keeps the default TypeScript setting of accepting type information from the entire workspace, while also adding `svelte` and `vite/client` type information.
+
+**Why include `.vscode/extensions.json`?**
+
+Other templates indirectly recommend extensions via the README, but this file allows VS Code to prompt the user to install the recommended extension upon opening the project.
+
+**Why enable `allowJs` in the TS template?**
+
+While `allowJs: false` would indeed prevent the use of `.js` files in the project, it does not prevent the use of JavaScript syntax in `.svelte` files. In addition, it would force `checkJs: false`, bringing the worst of both worlds: not being able to guarantee the entire codebase is TypeScript, and also having worse typechecking for the existing JavaScript. In addition, there are valid use cases in which a mixed codebase may be relevant.
+
+**Why is HMR not preserving my local component state?**
+
+HMR state preservation comes with a number of gotchas! It has been disabled by default in both `svelte-hmr` and `@sveltejs/vite-plugin-svelte` due to its often surprising behavior. You can read the details [here](https://github.com/rixo/svelte-hmr#svelte-hmr).
+
+If you have state that's important to retain within a component, consider creating an external store which would not be replaced by HMR.
+
+```ts
+// store.ts
+// An extremely simple external store
+import { writable } from 'svelte/store'
+export default writable(0)
+```
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/index.html
new file mode 100644
index 0000000..bbb64ff
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Svelte + TS</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/package.json
new file mode 100644
index 0000000..38a3d9e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "vite-svelte-ts-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "check": "svelte-check --tsconfig ./tsconfig.app.json && tsc -p tsconfig.node.json"
+  },
+  "devDependencies": {
+    "@sveltejs/vite-plugin-svelte": "^7.1.2",
+    "@tsconfig/svelte": "^5.0.8",
+    "@types/node": "^24.12.3",
+    "svelte": "^5.55.5",
+    "svelte-check": "^4.4.8",
+    "typescript": "~6.0.2",
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/App.svelte b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/App.svelte
new file mode 100644
index 0000000..dafc575
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/App.svelte
@@ -0,0 +1,89 @@
+<script>
+  import svelteLogo from './assets/svelte.svg'
+  import viteLogo from './assets/vite.svg'
+  import heroImg from './assets/hero.png'
+  import Counter from './lib/Counter.svelte'
+</script>
+
+<section id="center">
+  <div class="hero">
+    <img src={heroImg} class="base" width="170" height="179" alt="" />
+    <img src={svelteLogo} class="framework" alt="Svelte logo" />
+    <img src={viteLogo} class="vite" alt="Vite logo" />
+  </div>
+  <div>
+    <h1>Get started</h1>
+    <p>Edit <code>src/App.svelte</code> and save to test <code>HMR</code></p>
+  </div>
+  <Counter />
+</section>
+
+<div class="ticks"></div>
+
+<section id="next-steps">
+  <div id="docs">
+    <svg class="icon" role="presentation" aria-hidden="true">
+      <use href="/icons.svg#documentation-icon"></use>
+    </svg>
+    <h2>Documentation</h2>
+    <p>Your questions, answered</p>
+    <ul>
+      <li>
+        <a href="https://vite.dev/" target="_blank" rel="noreferrer">
+          <img class="logo" src={viteLogo} alt="" />
+          Explore Vite
+        </a>
+      </li>
+      <li>
+        <a href="https://svelte.dev/" target="_blank" rel="noreferrer">
+          <img class="button-icon" src={svelteLogo} alt="" />
+          Learn more
+        </a>
+      </li>
+    </ul>
+  </div>
+  <div id="social">
+    <svg class="icon" role="presentation" aria-hidden="true">
+      <use href="/icons.svg#social-icon"></use>
+    </svg>
+    <h2>Connect with us</h2>
+    <p>Join the Vite community</p>
+    <ul>
+      <li>
+        <a href="https://github.com/vitejs/vite" target="_blank" rel="noreferrer">
+          <svg class="button-icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#github-icon"></use>
+          </svg>
+          GitHub
+        </a>
+      </li>
+      <li>
+        <a href="https://chat.vite.dev/" target="_blank" rel="noreferrer">
+          <svg class="button-icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#discord-icon"></use>
+          </svg>
+          Discord
+        </a>
+      </li>
+      <li>
+        <a href="https://x.com/vite_js" target="_blank" rel="noreferrer">
+          <svg class="button-icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#x-icon"></use>
+          </svg>
+          X.com
+        </a>
+      </li>
+      <li>
+        <a href="https://bsky.app/profile/vite.dev" target="_blank" rel="noreferrer">
+          <svg class="button-icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#bluesky-icon"></use>
+          </svg>
+          Bluesky
+        </a>
+      </li>
+    </ul>
+  </div>
+</section>
+
+<div class="ticks"></div>
+<section id="spacer"></section>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/app.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/app.css
new file mode 100644
index 0000000..527d4fb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/app.css
@@ -0,0 +1,296 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
+
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/assets/svelte.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/assets/svelte.svg
new file mode 100644
index 0000000..c5e0848
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/assets/svelte.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="26.6" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 308"><path fill="#FF3E00" d="M239.682 40.707C211.113-.182 154.69-12.301 113.895 13.69L42.247 59.356a82.198 82.198 0 0 0-37.135 55.056a86.566 86.566 0 0 0 8.536 55.576a82.425 82.425 0 0 0-12.296 30.719a87.596 87.596 0 0 0 14.964 66.244c28.574 40.893 84.997 53.007 125.787 27.016l71.648-45.664a82.182 82.182 0 0 0 37.135-55.057a86.601 86.601 0 0 0-8.53-55.577a82.409 82.409 0 0 0 12.29-30.718a87.573 87.573 0 0 0-14.963-66.244"></path><path fill="#FFF" d="M106.889 270.841c-23.102 6.007-47.497-3.036-61.103-22.648a52.685 52.685 0 0 1-9.003-39.85a49.978 49.978 0 0 1 1.713-6.693l1.35-4.115l3.671 2.697a92.447 92.447 0 0 0 28.036 14.007l2.663.808l-.245 2.659a16.067 16.067 0 0 0 2.89 10.656a17.143 17.143 0 0 0 18.397 6.828a15.786 15.786 0 0 0 4.403-1.935l71.67-45.672a14.922 14.922 0 0 0 6.734-9.977a15.923 15.923 0 0 0-2.713-12.011a17.156 17.156 0 0 0-18.404-6.832a15.78 15.78 0 0 0-4.396 1.933l-27.35 17.434a52.298 52.298 0 0 1-14.553 6.391c-23.101 6.007-47.497-3.036-61.101-22.649a52.681 52.681 0 0 1-9.004-39.849a49.428 49.428 0 0 1 22.34-33.114l71.664-45.677a52.218 52.218 0 0 1 14.563-6.398c23.101-6.007 47.497 3.036 61.101 22.648a52.685 52.685 0 0 1 9.004 39.85a50.559 50.559 0 0 1-1.713 6.692l-1.35 4.116l-3.67-2.693a92.373 92.373 0 0 0-28.037-14.013l-2.664-.809l.246-2.658a16.099 16.099 0 0 0-2.89-10.656a17.143 17.143 0 0 0-18.398-6.828a15.786 15.786 0 0 0-4.402 1.935l-71.67 45.674a14.898 14.898 0 0 0-6.73 9.975a15.9 15.9 0 0 0 2.709 12.012a17.156 17.156 0 0 0 18.404 6.832a15.841 15.841 0 0 0 4.402-1.935l27.345-17.427a52.147 52.147 0 0 1 14.552-6.397c23.101-6.006 47.497 3.037 61.102 22.65a52.681 52.681 0 0 1 9.003 39.848a49.453 49.453 0 0 1-22.34 33.12l-71.664 45.673a52.218 52.218 0 0 1-14.563 6.398"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/lib/Counter.svelte b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/lib/Counter.svelte
new file mode 100644
index 0000000..5f046bd
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/lib/Counter.svelte
@@ -0,0 +1,10 @@
+<script lang="ts">
+  let count: number = $state(0)
+  const increment = () => {
+    count += 1
+  }
+</script>
+
+<button type="button" class="counter" onclick={increment}>
+  Count is {count}
+</button>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/main.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/main.ts
new file mode 100644
index 0000000..664a057
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/src/main.ts
@@ -0,0 +1,9 @@
+import { mount } from 'svelte'
+import './app.css'
+import App from './App.svelte'
+
+const app = mount(App, {
+  target: document.getElementById('app')!,
+})
+
+export default app
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/svelte.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/svelte.config.js
new file mode 100644
index 0000000..0cf7db3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/svelte.config.js
@@ -0,0 +1,2 @@
+/** @type {import("@sveltejs/vite-plugin-svelte").SvelteConfig} */
+export default {}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/tsconfig.app.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/tsconfig.app.json
new file mode 100644
index 0000000..d774b20
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/tsconfig.app.json
@@ -0,0 +1,20 @@
+{
+  "extends": "@tsconfig/svelte/tsconfig.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "es2023",
+    "module": "esnext",
+    "types": ["svelte", "vite/client"],
+    "noEmit": true,
+    /**
+     * Typecheck JS in `.svelte` and `.js` files by default.
+     * Disable checkJs if you'd like to use dynamic types in JS.
+     * Note that setting allowJs false does not prevent the use
+     * of JS in `.svelte` files.
+     */
+    "allowJs": true,
+    "checkJs": true,
+    "moduleDetection": "force"
+  },
+  "include": ["src/**/*.ts", "src/**/*.js", "src/**/*.svelte"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/tsconfig.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/tsconfig.json
new file mode 100644
index 0000000..1ffef60
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/tsconfig.node.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/tsconfig.node.json
new file mode 100644
index 0000000..d3c52ea
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/tsconfig.node.json
@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "es2023",
+    "lib": ["ES2023"],
+    "module": "esnext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/vite.config.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/vite.config.ts
new file mode 100644
index 0000000..d32eba1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte-ts/vite.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import { svelte } from '@sveltejs/vite-plugin-svelte'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [svelte()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/.vscode/extensions.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/.vscode/extensions.json
new file mode 100644
index 0000000..bdef820
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/.vscode/extensions.json
@@ -0,0 +1,3 @@
+{
+  "recommendations": ["svelte.svelte-vscode"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/README.md
new file mode 100644
index 0000000..54a2631
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/README.md
@@ -0,0 +1,43 @@
+# Svelte + Vite
+
+This template should help get you started developing with Svelte in Vite.
+
+## Recommended IDE Setup
+
+[VS Code](https://code.visualstudio.com/) + [Svelte](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode).
+
+## Need an official Svelte framework?
+
+Check out [SvelteKit](https://github.com/sveltejs/kit#readme), which is also powered by Vite. Deploy anywhere with its serverless-first approach and adapt to various platforms, with out of the box support for TypeScript, SCSS, and Less, and easily-added support for mdsvex, GraphQL, PostCSS, Tailwind CSS, and more.
+
+## Technical considerations
+
+**Why use this over SvelteKit?**
+
+- It brings its own routing solution which might not be preferable for some users.
+- It is first and foremost a framework that just happens to use Vite under the hood, not a Vite app.
+
+This template contains as little as possible to get started with Vite + Svelte, while taking into account the developer experience with regards to HMR and intellisense. It demonstrates capabilities on par with the other `create-vite` templates and is a good starting point for beginners dipping their toes into a Vite + Svelte project.
+
+Should you later need the extended capabilities and extensibility provided by SvelteKit, the template has been structured similarly to SvelteKit so that it is easy to migrate.
+
+**Why include `.vscode/extensions.json`?**
+
+Other templates indirectly recommend extensions via the README, but this file allows VS Code to prompt the user to install the recommended extension upon opening the project.
+
+**Why enable `checkJs` in the JS template?**
+
+It is likely that most cases of changing variable types in runtime are likely to be accidental, rather than deliberate. This provides advanced typechecking out of the box. Should you like to take advantage of the dynamically-typed nature of JavaScript, it is trivial to change the configuration.
+
+**Why is HMR not preserving my local component state?**
+
+HMR state preservation comes with a number of gotchas! It has been disabled by default in both `svelte-hmr` and `@sveltejs/vite-plugin-svelte` due to its often surprising behavior. You can read the details [here](https://github.com/sveltejs/svelte-hmr/tree/master/packages/svelte-hmr#preservation-of-local-state).
+
+If you have state that's important to retain within a component, consider creating an external store which would not be replaced by HMR.
+
+```js
+// store.js
+// An extremely simple external store
+import { writable } from 'svelte/store'
+export default writable(0)
+```
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/index.html
new file mode 100644
index 0000000..d6eb7c8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Svelte</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/jsconfig.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/jsconfig.json
new file mode 100644
index 0000000..c7a0b10
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/jsconfig.json
@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "moduleResolution": "bundler",
+    "target": "ESNext",
+    "module": "ESNext",
+    /**
+     * svelte-preprocess cannot figure out whether you have
+     * a value or a type, so tell TypeScript to enforce using
+     * `import type` instead of `import` for Types.
+     */
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    /**
+     * To have warnings / errors of the Svelte compiler at the
+     * correct position, enable source maps by default.
+     */
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+    /**
+     * Typecheck JS in `.svelte` and `.js` files by default.
+     * Disable this if you'd like to use dynamic types.
+     */
+    "checkJs": true
+  },
+  /**
+   * Use global.d.ts instead of compilerOptions.types
+   * to avoid limiting type declarations.
+   */
+  "include": ["src/**/*.d.ts", "src/**/*.js", "src/**/*.svelte"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/package.json
new file mode 100644
index 0000000..6804657
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/package.json
@@ -0,0 +1,16 @@
+{
+  "name": "vite-svelte-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "@sveltejs/vite-plugin-svelte": "^7.1.2",
+    "svelte": "^5.55.5",
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/App.svelte b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/App.svelte
new file mode 100644
index 0000000..dafc575
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/App.svelte
@@ -0,0 +1,89 @@
+<script>
+  import svelteLogo from './assets/svelte.svg'
+  import viteLogo from './assets/vite.svg'
+  import heroImg from './assets/hero.png'
+  import Counter from './lib/Counter.svelte'
+</script>
+
+<section id="center">
+  <div class="hero">
+    <img src={heroImg} class="base" width="170" height="179" alt="" />
+    <img src={svelteLogo} class="framework" alt="Svelte logo" />
+    <img src={viteLogo} class="vite" alt="Vite logo" />
+  </div>
+  <div>
+    <h1>Get started</h1>
+    <p>Edit <code>src/App.svelte</code> and save to test <code>HMR</code></p>
+  </div>
+  <Counter />
+</section>
+
+<div class="ticks"></div>
+
+<section id="next-steps">
+  <div id="docs">
+    <svg class="icon" role="presentation" aria-hidden="true">
+      <use href="/icons.svg#documentation-icon"></use>
+    </svg>
+    <h2>Documentation</h2>
+    <p>Your questions, answered</p>
+    <ul>
+      <li>
+        <a href="https://vite.dev/" target="_blank" rel="noreferrer">
+          <img class="logo" src={viteLogo} alt="" />
+          Explore Vite
+        </a>
+      </li>
+      <li>
+        <a href="https://svelte.dev/" target="_blank" rel="noreferrer">
+          <img class="button-icon" src={svelteLogo} alt="" />
+          Learn more
+        </a>
+      </li>
+    </ul>
+  </div>
+  <div id="social">
+    <svg class="icon" role="presentation" aria-hidden="true">
+      <use href="/icons.svg#social-icon"></use>
+    </svg>
+    <h2>Connect with us</h2>
+    <p>Join the Vite community</p>
+    <ul>
+      <li>
+        <a href="https://github.com/vitejs/vite" target="_blank" rel="noreferrer">
+          <svg class="button-icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#github-icon"></use>
+          </svg>
+          GitHub
+        </a>
+      </li>
+      <li>
+        <a href="https://chat.vite.dev/" target="_blank" rel="noreferrer">
+          <svg class="button-icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#discord-icon"></use>
+          </svg>
+          Discord
+        </a>
+      </li>
+      <li>
+        <a href="https://x.com/vite_js" target="_blank" rel="noreferrer">
+          <svg class="button-icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#x-icon"></use>
+          </svg>
+          X.com
+        </a>
+      </li>
+      <li>
+        <a href="https://bsky.app/profile/vite.dev" target="_blank" rel="noreferrer">
+          <svg class="button-icon" role="presentation" aria-hidden="true">
+            <use href="/icons.svg#bluesky-icon"></use>
+          </svg>
+          Bluesky
+        </a>
+      </li>
+    </ul>
+  </div>
+</section>
+
+<div class="ticks"></div>
+<section id="spacer"></section>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/app.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/app.css
new file mode 100644
index 0000000..527d4fb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/app.css
@@ -0,0 +1,296 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
+
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/assets/svelte.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/assets/svelte.svg
new file mode 100644
index 0000000..c5e0848
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/assets/svelte.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="26.6" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 308"><path fill="#FF3E00" d="M239.682 40.707C211.113-.182 154.69-12.301 113.895 13.69L42.247 59.356a82.198 82.198 0 0 0-37.135 55.056a86.566 86.566 0 0 0 8.536 55.576a82.425 82.425 0 0 0-12.296 30.719a87.596 87.596 0 0 0 14.964 66.244c28.574 40.893 84.997 53.007 125.787 27.016l71.648-45.664a82.182 82.182 0 0 0 37.135-55.057a86.601 86.601 0 0 0-8.53-55.577a82.409 82.409 0 0 0 12.29-30.718a87.573 87.573 0 0 0-14.963-66.244"></path><path fill="#FFF" d="M106.889 270.841c-23.102 6.007-47.497-3.036-61.103-22.648a52.685 52.685 0 0 1-9.003-39.85a49.978 49.978 0 0 1 1.713-6.693l1.35-4.115l3.671 2.697a92.447 92.447 0 0 0 28.036 14.007l2.663.808l-.245 2.659a16.067 16.067 0 0 0 2.89 10.656a17.143 17.143 0 0 0 18.397 6.828a15.786 15.786 0 0 0 4.403-1.935l71.67-45.672a14.922 14.922 0 0 0 6.734-9.977a15.923 15.923 0 0 0-2.713-12.011a17.156 17.156 0 0 0-18.404-6.832a15.78 15.78 0 0 0-4.396 1.933l-27.35 17.434a52.298 52.298 0 0 1-14.553 6.391c-23.101 6.007-47.497-3.036-61.101-22.649a52.681 52.681 0 0 1-9.004-39.849a49.428 49.428 0 0 1 22.34-33.114l71.664-45.677a52.218 52.218 0 0 1 14.563-6.398c23.101-6.007 47.497 3.036 61.101 22.648a52.685 52.685 0 0 1 9.004 39.85a50.559 50.559 0 0 1-1.713 6.692l-1.35 4.116l-3.67-2.693a92.373 92.373 0 0 0-28.037-14.013l-2.664-.809l.246-2.658a16.099 16.099 0 0 0-2.89-10.656a17.143 17.143 0 0 0-18.398-6.828a15.786 15.786 0 0 0-4.402 1.935l-71.67 45.674a14.898 14.898 0 0 0-6.73 9.975a15.9 15.9 0 0 0 2.709 12.012a17.156 17.156 0 0 0 18.404 6.832a15.841 15.841 0 0 0 4.402-1.935l27.345-17.427a52.147 52.147 0 0 1 14.552-6.397c23.101-6.006 47.497 3.037 61.102 22.65a52.681 52.681 0 0 1 9.003 39.848a49.453 49.453 0 0 1-22.34 33.12l-71.664 45.673a52.218 52.218 0 0 1-14.563 6.398"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/lib/Counter.svelte b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/lib/Counter.svelte
new file mode 100644
index 0000000..20bf4c9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/lib/Counter.svelte
@@ -0,0 +1,5 @@
+<script>
+  let count = $state(0)
+</script>
+
+<button type="button" class="counter" onclick={() => count++}>Count is {count}</button>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/main.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/main.js
new file mode 100644
index 0000000..458c7a8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/src/main.js
@@ -0,0 +1,9 @@
+import { mount } from 'svelte'
+import './app.css'
+import App from './App.svelte'
+
+const app = mount(App, {
+  target: document.getElementById('app'),
+})
+
+export default app
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/svelte.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/svelte.config.js
new file mode 100644
index 0000000..0cf7db3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/svelte.config.js
@@ -0,0 +1,2 @@
+/** @type {import("@sveltejs/vite-plugin-svelte").SvelteConfig} */
+export default {}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/vite.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/vite.config.js
new file mode 100644
index 0000000..d32eba1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-svelte/vite.config.js
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import { svelte } from '@sveltejs/vite-plugin-svelte'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [svelte()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/index.html
new file mode 100644
index 0000000..727cca2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + TS</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/package.json
new file mode 100644
index 0000000..ef5d889
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "vite-typescript-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "typescript": "~6.0.2",
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/assets/typescript.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/assets/typescript.svg
new file mode 100644
index 0000000..6c9d69c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/assets/typescript.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" width="32" height="32" viewBox="0 0 256 256"><path fill="#007ACC" d="M0 128v128h256V0H0z"/><path fill="#FFF" d="m56.612 128.85l-.081 10.483h33.32v94.68h23.568v-94.68h33.321v-10.28c0-5.69-.122-10.444-.284-10.566c-.122-.162-20.4-.244-44.983-.203l-44.74.122l-.121 10.443Zm149.955-10.742c6.501 1.625 11.459 4.51 16.01 9.224c2.357 2.52 5.851 7.111 6.136 8.208c.08.325-11.053 7.802-17.798 11.988c-.244.162-1.22-.894-2.317-2.52c-3.291-4.795-6.745-6.867-12.028-7.233c-7.76-.528-12.759 3.535-12.718 10.321c0 1.992.284 3.17 1.097 4.795c1.707 3.536 4.876 5.649 14.832 9.956c18.326 7.883 26.168 13.084 31.045 20.48c5.445 8.249 6.664 21.415 2.966 31.208c-4.063 10.646-14.14 17.879-28.323 20.276c-4.388.772-14.79.65-19.504-.203c-10.28-1.828-20.033-6.908-26.047-13.572c-2.357-2.6-6.949-9.387-6.664-9.874c.122-.163 1.178-.813 2.356-1.504c1.138-.65 5.446-3.129 9.509-5.485l7.355-4.267l1.544 2.276c2.154 3.29 6.867 7.801 9.712 9.305c8.167 4.307 19.383 3.698 24.909-1.26c2.357-2.153 3.332-4.388 3.332-7.68c0-2.966-.366-4.266-1.91-6.501c-1.99-2.845-6.054-5.242-17.595-10.24c-13.206-5.69-18.895-9.224-24.096-14.832c-3.007-3.25-5.852-8.452-7.03-12.8c-.975-3.617-1.22-12.678-.447-16.335c2.723-12.76 12.353-21.659 26.25-24.3c4.51-.853 14.994-.528 19.424.569Z"/></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/counter.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/counter.ts
new file mode 100644
index 0000000..9f629e8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/counter.ts
@@ -0,0 +1,9 @@
+export function setupCounter(element: HTMLButtonElement) {
+  let counter = 0
+  const setCounter = (count: number) => {
+    counter = count
+    element.innerHTML = `Count is ${counter}`
+  }
+  element.addEventListener('click', () => setCounter(counter + 1))
+  setCounter(0)
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/main.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/main.ts
new file mode 100644
index 0000000..d72bbca
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/main.ts
@@ -0,0 +1,60 @@
+import './style.css'
+import typescriptLogo from './assets/typescript.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import { setupCounter } from './counter.ts'
+
+document.querySelector<HTMLDivElement>('#app')!.innerHTML = `
+<section id="center">
+  <div class="hero">
+    <img src="${heroImg}" class="base" width="170" height="179">
+    <img src="${typescriptLogo}" class="framework" alt="TypeScript logo"/>
+    <img src="${viteLogo}" class="vite" alt="Vite logo" />
+  </div>
+  <div>
+    <h1>Get started</h1>
+    <p>Edit <code>src/main.ts</code> and save to test <code>HMR</code></p>
+  </div>
+  <button id="counter" type="button" class="counter"></button>
+</section>
+
+<div class="ticks"></div>
+
+<section id="next-steps">
+  <div id="docs">
+    <svg class="icon" role="presentation" aria-hidden="true"><use href="/icons.svg#documentation-icon"></use></svg>
+    <h2>Documentation</h2>
+    <p>Your questions, answered</p>
+    <ul>
+      <li>
+        <a href="https://vite.dev/" target="_blank">
+          <img class="logo" src="${viteLogo}" alt="" />
+          Explore Vite
+        </a>
+      </li>
+      <li>
+        <a href="https://www.typescriptlang.org" target="_blank">
+          <img class="button-icon" src="${typescriptLogo}" alt="">
+          Learn more
+        </a>
+      </li>
+    </ul>
+  </div>
+  <div id="social">
+    <svg class="icon" role="presentation" aria-hidden="true"><use href="/icons.svg#social-icon"></use></svg>
+    <h2>Connect with us</h2>
+    <p>Join the Vite community</p>
+    <ul>
+      <li><a href="https://github.com/vitejs/vite" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#github-icon"></use></svg>GitHub</a></li>
+      <li><a href="https://chat.vite.dev/" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#discord-icon"></use></svg>Discord</a></li>
+      <li><a href="https://x.com/vite_js" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#x-icon"></use></svg>X.com</a></li>
+      <li><a href="https://bsky.app/profile/vite.dev" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#bluesky-icon"></use></svg>Bluesky</a></li>
+    </ul>
+  </div>
+</section>
+
+<div class="ticks"></div>
+<section id="spacer"></section>
+`
+
+setupCounter(document.querySelector<HTMLButtonElement>('#counter')!)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/style.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/style.css
new file mode 100644
index 0000000..527d4fb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/src/style.css
@@ -0,0 +1,296 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
+
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/tsconfig.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/tsconfig.json
new file mode 100644
index 0000000..1ab38c8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla-ts/tsconfig.json
@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "es2023",
+    "module": "esnext",
+    "lib": ["ES2023", "DOM"],
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/index.html
new file mode 100644
index 0000000..265516b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + JS</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/package.json
new file mode 100644
index 0000000..97130a6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "vite-starter",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/public/favicon.svg
new file mode 100644
index 0000000..0906f9c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/assets/javascript.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/assets/javascript.svg
new file mode 100644
index 0000000..bebbfc1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/assets/javascript.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" width="32" height="32" viewBox="0 0 256 256"><path fill="#F7DF1E" d="M0 0h256v256H0V0Z"/><path d="m67.312 213.932l19.59-11.856c3.78 6.701 7.218 12.371 15.465 12.371c7.905 0 12.89-3.092 12.89-15.12v-81.798h24.057v82.138c0 24.917-14.606 36.259-35.916 36.259c-19.245 0-30.416-9.967-36.087-21.996m85.07-2.576l19.588-11.341c5.157 8.421 11.859 14.607 23.715 14.607c9.969 0 16.325-4.984 16.325-11.858c0-8.248-6.53-11.17-17.528-15.98l-6.013-2.58c-17.357-7.387-28.87-16.667-28.87-36.257c0-18.044 13.747-31.792 35.228-31.792c15.294 0 26.292 5.328 34.196 19.247l-18.732 12.03c-4.125-7.389-8.591-10.31-15.465-10.31c-7.046 0-11.514 4.468-11.514 10.31c0 7.217 4.468 10.14 14.778 14.608l6.014 2.577c20.45 8.765 31.963 17.7 31.963 37.804c0 21.654-17.012 33.51-39.867 33.51c-22.339 0-36.774-10.654-43.819-24.574"/></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/counter.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/counter.js
new file mode 100644
index 0000000..12bf115
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/counter.js
@@ -0,0 +1,9 @@
+export function setupCounter(element) {
+  let counter = 0
+  const setCounter = (count) => {
+    counter = count
+    element.innerHTML = `Count is ${counter}`
+  }
+  element.addEventListener('click', () => setCounter(counter + 1))
+  setCounter(0)
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/main.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/main.js
new file mode 100644
index 0000000..a6ace3e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/main.js
@@ -0,0 +1,60 @@
+import './style.css'
+import javascriptLogo from './assets/javascript.svg'
+import viteLogo from './assets/vite.svg'
+import heroImg from './assets/hero.png'
+import { setupCounter } from './counter.js'
+
+document.querySelector('#app').innerHTML = `
+<section id="center">
+  <div class="hero">
+    <img src="${heroImg}" class="base" width="170" height="179">
+    <img src="${javascriptLogo}" class="framework" alt="JavaScript logo"/>
+    <img src="${viteLogo}" class="vite" alt="Vite logo" />
+  </div>
+  <div>
+    <h1>Get started</h1>
+    <p>Edit <code>src/main.js</code> and save to test <code>HMR</code></p>
+  </div>
+  <button id="counter" type="button" class="counter"></button>
+</section>
+
+<div class="ticks"></div>
+
+<section id="next-steps">
+  <div id="docs">
+    <svg class="icon" role="presentation" aria-hidden="true"><use href="/icons.svg#documentation-icon"></use></svg>
+    <h2>Documentation</h2>
+    <p>Your questions, answered</p>
+    <ul>
+      <li>
+        <a href="https://vite.dev/" target="_blank">
+          <img class="logo" src="${viteLogo}" alt="" />
+          Explore Vite
+        </a>
+      </li>
+      <li>
+        <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript" target="_blank">
+          <img class="button-icon" src="${javascriptLogo}" alt="">
+          Learn more
+        </a>
+      </li>
+    </ul>
+  </div>
+  <div id="social">
+    <svg class="icon" role="presentation" aria-hidden="true"><use href="/icons.svg#social-icon"></use></svg>
+    <h2>Connect with us</h2>
+    <p>Join the Vite community</p>
+    <ul>
+      <li><a href="https://github.com/vitejs/vite" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#github-icon"></use></svg>GitHub</a></li>
+      <li><a href="https://chat.vite.dev/" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#discord-icon"></use></svg>Discord</a></li>
+      <li><a href="https://x.com/vite_js" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#x-icon"></use></svg>X.com</a></li>
+      <li><a href="https://bsky.app/profile/vite.dev" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#bluesky-icon"></use></svg>Bluesky</a></li>
+    </ul>
+  </div>
+</section>
+
+<div class="ticks"></div>
+<section id="spacer"></section>
+`
+
+setupCounter(document.querySelector('#counter'))
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/style.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/style.css
new file mode 100644
index 0000000..527d4fb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vanilla/src/style.css
@@ -0,0 +1,296 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
+
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/.vscode/extensions.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/.vscode/extensions.json
new file mode 100644
index 0000000..a7cea0b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/.vscode/extensions.json
@@ -0,0 +1,3 @@
+{
+  "recommendations": ["Vue.volar"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/README.md
new file mode 100644
index 0000000..33895ab
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/README.md
@@ -0,0 +1,5 @@
+# Vue 3 + TypeScript + Vite
+
+This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
+
+Learn more about the recommended Project Setup and IDE Support in the [Vue Docs TypeScript Guide](https://vuejs.org/guide/typescript/overview.html#project-setup).
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/index.html
new file mode 100644
index 0000000..cfa0c98
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Vue + TS</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/package.json
new file mode 100644
index 0000000..55c5ea4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "vite-vue-typescript-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vue-tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "vue": "^3.5.34"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.3",
+    "@vitejs/plugin-vue": "^6.0.6",
+    "@vue/tsconfig": "^0.9.1",
+    "typescript": "~6.0.2",
+    "vite": "^8.0.12",
+    "vue-tsc": "^3.2.8"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/App.vue b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/App.vue
new file mode 100644
index 0000000..388b05e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/App.vue
@@ -0,0 +1,7 @@
+<script setup lang="ts">
+import HelloWorld from './components/HelloWorld.vue'
+</script>
+
+<template>
+  <HelloWorld />
+</template>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/assets/vue.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/assets/vue.svg
new file mode 100644
index 0000000..770e9d3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/assets/vue.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="37.07" height="36" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 198"><path fill="#41B883" d="M204.8 0H256L128 220.8L0 0h97.92L128 51.2L157.44 0h47.36Z"></path><path fill="#41B883" d="m0 0l128 220.8L256 0h-51.2L128 132.48L50.56 0H0Z"></path><path fill="#35495E" d="M50.56 0L128 133.12L204.8 0h-47.36L128 51.2L97.92 0H50.56Z"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/components/HelloWorld.vue b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/components/HelloWorld.vue
new file mode 100644
index 0000000..c232865
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/components/HelloWorld.vue
@@ -0,0 +1,95 @@
+<script setup lang="ts">
+import { ref } from 'vue'
+import viteLogo from '../assets/vite.svg'
+import heroImg from '../assets/hero.png'
+import vueLogo from '../assets/vue.svg'
+
+const count = ref(0)
+</script>
+
+<template>
+  <section id="center">
+    <div class="hero">
+      <img :src="heroImg" class="base" width="170" height="179" alt="" />
+      <img :src="vueLogo" class="framework" alt="Vue logo" />
+      <img :src="viteLogo" class="vite" alt="Vite logo" />
+    </div>
+    <div>
+      <h1>Get started</h1>
+      <p>Edit <code>src/App.vue</code> and save to test <code>HMR</code></p>
+    </div>
+    <button type="button" class="counter" @click="count++">
+      Count is {{ count }}
+    </button>
+  </section>
+
+  <div class="ticks"></div>
+
+  <section id="next-steps">
+    <div id="docs">
+      <svg class="icon" role="presentation" aria-hidden="true">
+        <use href="/icons.svg#documentation-icon"></use>
+      </svg>
+      <h2>Documentation</h2>
+      <p>Your questions, answered</p>
+      <ul>
+        <li>
+          <a href="https://vite.dev/" target="_blank">
+            <img class="logo" :src="viteLogo" alt="" />
+            Explore Vite
+          </a>
+        </li>
+        <li>
+          <a href="https://vuejs.org/" target="_blank">
+            <img class="button-icon" :src="vueLogo" alt="" />
+            Learn more
+          </a>
+        </li>
+      </ul>
+    </div>
+    <div id="social">
+      <svg class="icon" role="presentation" aria-hidden="true">
+        <use href="/icons.svg#social-icon"></use>
+      </svg>
+      <h2>Connect with us</h2>
+      <p>Join the Vite community</p>
+      <ul>
+        <li>
+          <a href="https://github.com/vitejs/vite" target="_blank">
+            <svg class="button-icon" role="presentation" aria-hidden="true">
+              <use href="/icons.svg#github-icon"></use>
+            </svg>
+            GitHub
+          </a>
+        </li>
+        <li>
+          <a href="https://chat.vite.dev/" target="_blank">
+            <svg class="button-icon" role="presentation" aria-hidden="true">
+              <use href="/icons.svg#discord-icon"></use>
+            </svg>
+            Discord
+          </a>
+        </li>
+        <li>
+          <a href="https://x.com/vite_js" target="_blank">
+            <svg class="button-icon" role="presentation" aria-hidden="true">
+              <use href="/icons.svg#x-icon"></use>
+            </svg>
+            X.com
+          </a>
+        </li>
+        <li>
+          <a href="https://bsky.app/profile/vite.dev" target="_blank">
+            <svg class="button-icon" role="presentation" aria-hidden="true">
+              <use href="/icons.svg#bluesky-icon"></use>
+            </svg>
+            Bluesky
+          </a>
+        </li>
+      </ul>
+    </div>
+  </section>
+
+  <div class="ticks"></div>
+  <section id="spacer"></section>
+</template>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/main.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/main.ts
new file mode 100644
index 0000000..2425c0f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/main.ts
@@ -0,0 +1,5 @@
+import { createApp } from 'vue'
+import './style.css'
+import App from './App.vue'
+
+createApp(App).mount('#app')
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/style.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/style.css
new file mode 100644
index 0000000..527d4fb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/src/style.css
@@ -0,0 +1,296 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
+
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/tsconfig.app.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/tsconfig.app.json
new file mode 100644
index 0000000..5c750c5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/tsconfig.app.json
@@ -0,0 +1,14 @@
+{
+  "extends": "@vue/tsconfig/tsconfig.dom.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "types": ["vite/client"],
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/tsconfig.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/tsconfig.json
new file mode 100644
index 0000000..1ffef60
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/tsconfig.node.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/tsconfig.node.json
new file mode 100644
index 0000000..d3c52ea
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/tsconfig.node.json
@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "es2023",
+    "lib": ["ES2023"],
+    "module": "esnext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/vite.config.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/vite.config.ts
new file mode 100644
index 0000000..bbcf80c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue-ts/vite.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [vue()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/.vscode/extensions.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/.vscode/extensions.json
new file mode 100644
index 0000000..a7cea0b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/.vscode/extensions.json
@@ -0,0 +1,3 @@
+{
+  "recommendations": ["Vue.volar"]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/README.md
new file mode 100644
index 0000000..1511959
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/README.md
@@ -0,0 +1,5 @@
+# Vue 3 + Vite
+
+This template should help get you started developing with Vue 3 in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
+
+Learn more about IDE Support for Vue in the [Vue Docs Scaling up Guide](https://vuejs.org/guide/scaling-up/tooling.html#ide-support).
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/_gitignore b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/_gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/_gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/index.html b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/index.html
new file mode 100644
index 0000000..e5cc3e7
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + Vue</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/package.json
new file mode 100644
index 0000000..cf2f314
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "vite-vue-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "vue": "^3.5.34"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^6.0.6",
+    "vite": "^8.0.12"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/public/favicon.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/public/icons.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/App.vue b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/App.vue
new file mode 100644
index 0000000..62ebe1b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/App.vue
@@ -0,0 +1,7 @@
+<script setup>
+import HelloWorld from './components/HelloWorld.vue'
+</script>
+
+<template>
+  <HelloWorld />
+</template>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/assets/hero.png b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/assets/hero.png
new file mode 100644
index 0000000..02251f4
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/assets/hero.png differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/assets/vite.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/assets/vue.svg b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/assets/vue.svg
new file mode 100644
index 0000000..770e9d3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/assets/vue.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="37.07" height="36" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 198"><path fill="#41B883" d="M204.8 0H256L128 220.8L0 0h97.92L128 51.2L157.44 0h47.36Z"></path><path fill="#41B883" d="m0 0l128 220.8L256 0h-51.2L128 132.48L50.56 0H0Z"></path><path fill="#35495E" d="M50.56 0L128 133.12L204.8 0h-47.36L128 51.2L97.92 0H50.56Z"></path></svg>
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/components/HelloWorld.vue b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/components/HelloWorld.vue
new file mode 100644
index 0000000..f91553d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/components/HelloWorld.vue
@@ -0,0 +1,95 @@
+<script setup>
+import { ref } from 'vue'
+import viteLogo from '../assets/vite.svg'
+import heroImg from '../assets/hero.png'
+import vueLogo from '../assets/vue.svg'
+
+const count = ref(0)
+</script>
+
+<template>
+  <section id="center">
+    <div class="hero">
+      <img :src="heroImg" class="base" width="170" height="179" alt="" />
+      <img :src="vueLogo" class="framework" alt="Vue logo" />
+      <img :src="viteLogo" class="vite" alt="Vite logo" />
+    </div>
+    <div>
+      <h1>Get started</h1>
+      <p>Edit <code>src/App.vue</code> and save to test <code>HMR</code></p>
+    </div>
+    <button type="button" class="counter" @click="count++">
+      Count is {{ count }}
+    </button>
+  </section>
+
+  <div class="ticks"></div>
+
+  <section id="next-steps">
+    <div id="docs">
+      <svg class="icon" role="presentation" aria-hidden="true">
+        <use href="/icons.svg#documentation-icon"></use>
+      </svg>
+      <h2>Documentation</h2>
+      <p>Your questions, answered</p>
+      <ul>
+        <li>
+          <a href="https://vite.dev/" target="_blank">
+            <img class="logo" :src="viteLogo" alt="" />
+            Explore Vite
+          </a>
+        </li>
+        <li>
+          <a href="https://vuejs.org/" target="_blank">
+            <img class="button-icon" :src="vueLogo" alt="" />
+            Learn more
+          </a>
+        </li>
+      </ul>
+    </div>
+    <div id="social">
+      <svg class="icon" role="presentation" aria-hidden="true">
+        <use href="/icons.svg#social-icon"></use>
+      </svg>
+      <h2>Connect with us</h2>
+      <p>Join the Vite community</p>
+      <ul>
+        <li>
+          <a href="https://github.com/vitejs/vite" target="_blank">
+            <svg class="button-icon" role="presentation" aria-hidden="true">
+              <use href="/icons.svg#github-icon"></use>
+            </svg>
+            GitHub
+          </a>
+        </li>
+        <li>
+          <a href="https://chat.vite.dev/" target="_blank">
+            <svg class="button-icon" role="presentation" aria-hidden="true">
+              <use href="/icons.svg#discord-icon"></use>
+            </svg>
+            Discord
+          </a>
+        </li>
+        <li>
+          <a href="https://x.com/vite_js" target="_blank">
+            <svg class="button-icon" role="presentation" aria-hidden="true">
+              <use href="/icons.svg#x-icon"></use>
+            </svg>
+            X.com
+          </a>
+        </li>
+        <li>
+          <a href="https://bsky.app/profile/vite.dev" target="_blank">
+            <svg class="button-icon" role="presentation" aria-hidden="true">
+              <use href="/icons.svg#bluesky-icon"></use>
+            </svg>
+            Bluesky
+          </a>
+        </li>
+      </ul>
+    </div>
+  </section>
+
+  <div class="ticks"></div>
+  <section id="spacer"></section>
+</template>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/main.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/main.js
new file mode 100644
index 0000000..2425c0f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/main.js
@@ -0,0 +1,5 @@
+import { createApp } from 'vue'
+import './style.css'
+import App from './App.vue'
+
+createApp(App).mount('#app')
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/style.css b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/style.css
new file mode 100644
index 0000000..527d4fb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/src/style.css
@@ -0,0 +1,296 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
+
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#app {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/vite.config.js b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/vite.config.js
new file mode 100644
index 0000000..bbcf80c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/create-vite/template-vue/vite.config.js
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [vue()],
+})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/LICENSE
new file mode 100644
index 0000000..8dada3e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/README.md
new file mode 100644
index 0000000..23212fd
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/README.md
@@ -0,0 +1,163 @@
+# detect-libc
+
+Node.js module to detect details of the C standard library (libc)
+implementation provided by a given Linux system.
+
+Currently supports detection of GNU glibc and MUSL libc.
+
+Provides asychronous and synchronous functions for the
+family (e.g. `glibc`, `musl`) and version (e.g. `1.23`, `1.2.3`).
+
+The version numbers of libc implementations
+are not guaranteed to be semver-compliant.
+
+For previous v1.x releases, please see the
+[v1](https://github.com/lovell/detect-libc/tree/v1) branch.
+
+## Install
+
+```sh
+npm install detect-libc
+```
+
+## API
+
+### GLIBC
+
+```ts
+const GLIBC: string = 'glibc';
+```
+
+A String constant containing the value `glibc`.
+
+### MUSL
+
+```ts
+const MUSL: string = 'musl';
+```
+
+A String constant containing the value `musl`.
+
+### family
+
+```ts
+function family(): Promise<string | null>;
+```
+
+Resolves asychronously with:
+
+* `glibc` or `musl` when the libc family can be determined
+* `null` when the libc family cannot be determined
+* `null` when run on a non-Linux platform
+
+```js
+const { family, GLIBC, MUSL } = require('detect-libc');
+
+switch (await family()) {
+  case GLIBC: ...
+  case MUSL: ...
+  case null: ...
+}
+```
+
+### familySync
+
+```ts
+function familySync(): string | null;
+```
+
+Synchronous version of `family()`.
+
+```js
+const { familySync, GLIBC, MUSL } = require('detect-libc');
+
+switch (familySync()) {
+  case GLIBC: ...
+  case MUSL: ...
+  case null: ...
+}
+```
+
+### version
+
+```ts
+function version(): Promise<string | null>;
+```
+
+Resolves asychronously with:
+
+* The version when it can be determined
+* `null` when the libc family cannot be determined
+* `null` when run on a non-Linux platform
+
+```js
+const { version } = require('detect-libc');
+
+const v = await version();
+if (v) {
+  const [major, minor, patch] = v.split('.');
+}
+```
+
+### versionSync
+
+```ts
+function versionSync(): string | null;
+```
+
+Synchronous version of `version()`.
+
+```js
+const { versionSync } = require('detect-libc');
+
+const v = versionSync();
+if (v) {
+  const [major, minor, patch] = v.split('.');
+}
+```
+
+### isNonGlibcLinux
+
+```ts
+function isNonGlibcLinux(): Promise<boolean>;
+```
+
+Resolves asychronously with:
+
+* `false` when the libc family is `glibc`
+* `true` when the libc family is not `glibc`
+* `false` when run on a non-Linux platform
+
+```js
+const { isNonGlibcLinux } = require('detect-libc');
+
+if (await isNonGlibcLinux()) { ... }
+```
+
+### isNonGlibcLinuxSync
+
+```ts
+function isNonGlibcLinuxSync(): boolean;
+```
+
+Synchronous version of `isNonGlibcLinux()`.
+
+```js
+const { isNonGlibcLinuxSync } = require('detect-libc');
+
+if (isNonGlibcLinuxSync()) { ... }
+```
+
+## Licensing
+
+Copyright 2017 Lovell Fuller and others.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/index.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/index.d.ts
new file mode 100644
index 0000000..4c0fb2b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/index.d.ts
@@ -0,0 +1,14 @@
+// Copyright 2017 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+export const GLIBC: 'glibc';
+export const MUSL: 'musl';
+
+export function family(): Promise<string | null>;
+export function familySync(): string | null;
+
+export function isNonGlibcLinux(): Promise<boolean>;
+export function isNonGlibcLinuxSync(): boolean;
+
+export function version(): Promise<string | null>;
+export function versionSync(): string | null;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/detect-libc.js b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/detect-libc.js
new file mode 100644
index 0000000..01299b4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/detect-libc.js
@@ -0,0 +1,313 @@
+// Copyright 2017 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+'use strict';
+
+const childProcess = require('child_process');
+const { isLinux, getReport } = require('./process');
+const { LDD_PATH, SELF_PATH, readFile, readFileSync } = require('./filesystem');
+const { interpreterPath } = require('./elf');
+
+let cachedFamilyInterpreter;
+let cachedFamilyFilesystem;
+let cachedVersionFilesystem;
+
+const command = 'getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true';
+let commandOut = '';
+
+const safeCommand = () => {
+  if (!commandOut) {
+    return new Promise((resolve) => {
+      childProcess.exec(command, (err, out) => {
+        commandOut = err ? ' ' : out;
+        resolve(commandOut);
+      });
+    });
+  }
+  return commandOut;
+};
+
+const safeCommandSync = () => {
+  if (!commandOut) {
+    try {
+      commandOut = childProcess.execSync(command, { encoding: 'utf8' });
+    } catch (_err) {
+      commandOut = ' ';
+    }
+  }
+  return commandOut;
+};
+
+/**
+ * A String constant containing the value `glibc`.
+ * @type {string}
+ * @public
+ */
+const GLIBC = 'glibc';
+
+/**
+ * A Regexp constant to get the GLIBC Version.
+ * @type {string}
+ */
+const RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
+
+/**
+ * A String constant containing the value `musl`.
+ * @type {string}
+ * @public
+ */
+const MUSL = 'musl';
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-');
+
+const familyFromReport = () => {
+  const report = getReport();
+  if (report.header && report.header.glibcVersionRuntime) {
+    return GLIBC;
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return MUSL;
+    }
+  }
+  return null;
+};
+
+const familyFromCommand = (out) => {
+  const [getconf, ldd1] = out.split(/[\r\n]+/);
+  if (getconf && getconf.includes(GLIBC)) {
+    return GLIBC;
+  }
+  if (ldd1 && ldd1.includes(MUSL)) {
+    return MUSL;
+  }
+  return null;
+};
+
+const familyFromInterpreterPath = (path) => {
+  if (path) {
+    if (path.includes('/ld-musl-')) {
+      return MUSL;
+    } else if (path.includes('/ld-linux-')) {
+      return GLIBC;
+    }
+  }
+  return null;
+};
+
+const getFamilyFromLddContent = (content) => {
+  content = content.toString();
+  if (content.includes('musl')) {
+    return MUSL;
+  }
+  if (content.includes('GNU C Library')) {
+    return GLIBC;
+  }
+  return null;
+};
+
+const familyFromFilesystem = async () => {
+  if (cachedFamilyFilesystem !== undefined) {
+    return cachedFamilyFilesystem;
+  }
+  cachedFamilyFilesystem = null;
+  try {
+    const lddContent = await readFile(LDD_PATH);
+    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+  } catch (e) {}
+  return cachedFamilyFilesystem;
+};
+
+const familyFromFilesystemSync = () => {
+  if (cachedFamilyFilesystem !== undefined) {
+    return cachedFamilyFilesystem;
+  }
+  cachedFamilyFilesystem = null;
+  try {
+    const lddContent = readFileSync(LDD_PATH);
+    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+  } catch (e) {}
+  return cachedFamilyFilesystem;
+};
+
+const familyFromInterpreter = async () => {
+  if (cachedFamilyInterpreter !== undefined) {
+    return cachedFamilyInterpreter;
+  }
+  cachedFamilyInterpreter = null;
+  try {
+    const selfContent = await readFile(SELF_PATH);
+    const path = interpreterPath(selfContent);
+    cachedFamilyInterpreter = familyFromInterpreterPath(path);
+  } catch (e) {}
+  return cachedFamilyInterpreter;
+};
+
+const familyFromInterpreterSync = () => {
+  if (cachedFamilyInterpreter !== undefined) {
+    return cachedFamilyInterpreter;
+  }
+  cachedFamilyInterpreter = null;
+  try {
+    const selfContent = readFileSync(SELF_PATH);
+    const path = interpreterPath(selfContent);
+    cachedFamilyInterpreter = familyFromInterpreterPath(path);
+  } catch (e) {}
+  return cachedFamilyInterpreter;
+};
+
+/**
+ * Resolves with the libc family when it can be determined, `null` otherwise.
+ * @returns {Promise<?string>}
+ */
+const family = async () => {
+  let family = null;
+  if (isLinux()) {
+    family = await familyFromInterpreter();
+    if (!family) {
+      family = await familyFromFilesystem();
+      if (!family) {
+        family = familyFromReport();
+      }
+      if (!family) {
+        const out = await safeCommand();
+        family = familyFromCommand(out);
+      }
+    }
+  }
+  return family;
+};
+
+/**
+ * Returns the libc family when it can be determined, `null` otherwise.
+ * @returns {?string}
+ */
+const familySync = () => {
+  let family = null;
+  if (isLinux()) {
+    family = familyFromInterpreterSync();
+    if (!family) {
+      family = familyFromFilesystemSync();
+      if (!family) {
+        family = familyFromReport();
+      }
+      if (!family) {
+        const out = safeCommandSync();
+        family = familyFromCommand(out);
+      }
+    }
+  }
+  return family;
+};
+
+/**
+ * Resolves `true` only when the platform is Linux and the libc family is not `glibc`.
+ * @returns {Promise<boolean>}
+ */
+const isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+
+/**
+ * Returns `true` only when the platform is Linux and the libc family is not `glibc`.
+ * @returns {boolean}
+ */
+const isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+
+const versionFromFilesystem = async () => {
+  if (cachedVersionFilesystem !== undefined) {
+    return cachedVersionFilesystem;
+  }
+  cachedVersionFilesystem = null;
+  try {
+    const lddContent = await readFile(LDD_PATH);
+    const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+    if (versionMatch) {
+      cachedVersionFilesystem = versionMatch[1];
+    }
+  } catch (e) {}
+  return cachedVersionFilesystem;
+};
+
+const versionFromFilesystemSync = () => {
+  if (cachedVersionFilesystem !== undefined) {
+    return cachedVersionFilesystem;
+  }
+  cachedVersionFilesystem = null;
+  try {
+    const lddContent = readFileSync(LDD_PATH);
+    const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+    if (versionMatch) {
+      cachedVersionFilesystem = versionMatch[1];
+    }
+  } catch (e) {}
+  return cachedVersionFilesystem;
+};
+
+const versionFromReport = () => {
+  const report = getReport();
+  if (report.header && report.header.glibcVersionRuntime) {
+    return report.header.glibcVersionRuntime;
+  }
+  return null;
+};
+
+const versionSuffix = (s) => s.trim().split(/\s+/)[1];
+
+const versionFromCommand = (out) => {
+  const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+  if (getconf && getconf.includes(GLIBC)) {
+    return versionSuffix(getconf);
+  }
+  if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+    return versionSuffix(ldd2);
+  }
+  return null;
+};
+
+/**
+ * Resolves with the libc version when it can be determined, `null` otherwise.
+ * @returns {Promise<?string>}
+ */
+const version = async () => {
+  let version = null;
+  if (isLinux()) {
+    version = await versionFromFilesystem();
+    if (!version) {
+      version = versionFromReport();
+    }
+    if (!version) {
+      const out = await safeCommand();
+      version = versionFromCommand(out);
+    }
+  }
+  return version;
+};
+
+/**
+ * Returns the libc version when it can be determined, `null` otherwise.
+ * @returns {?string}
+ */
+const versionSync = () => {
+  let version = null;
+  if (isLinux()) {
+    version = versionFromFilesystemSync();
+    if (!version) {
+      version = versionFromReport();
+    }
+    if (!version) {
+      const out = safeCommandSync();
+      version = versionFromCommand(out);
+    }
+  }
+  return version;
+};
+
+module.exports = {
+  GLIBC,
+  MUSL,
+  family,
+  familySync,
+  isNonGlibcLinux,
+  isNonGlibcLinuxSync,
+  version,
+  versionSync
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/elf.js b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/elf.js
new file mode 100644
index 0000000..aa166aa
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/elf.js
@@ -0,0 +1,39 @@
+// Copyright 2017 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+'use strict';
+
+const interpreterPath = (elf) => {
+  if (elf.length < 64) {
+    return null;
+  }
+  if (elf.readUInt32BE(0) !== 0x7F454C46) {
+    // Unexpected magic bytes
+    return null;
+  }
+  if (elf.readUInt8(4) !== 2) {
+    // Not a 64-bit ELF
+    return null;
+  }
+  if (elf.readUInt8(5) !== 1) {
+    // Not little-endian
+    return null;
+  }
+  const offset = elf.readUInt32LE(32);
+  const size = elf.readUInt16LE(54);
+  const count = elf.readUInt16LE(56);
+  for (let i = 0; i < count; i++) {
+    const headerOffset = offset + (i * size);
+    const type = elf.readUInt32LE(headerOffset);
+    if (type === 3) {
+      const fileOffset = elf.readUInt32LE(headerOffset + 8);
+      const fileSize = elf.readUInt32LE(headerOffset + 32);
+      return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, '');
+    }
+  }
+  return null;
+};
+
+module.exports = {
+  interpreterPath
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/filesystem.js b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/filesystem.js
new file mode 100644
index 0000000..4c2443c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/filesystem.js
@@ -0,0 +1,51 @@
+// Copyright 2017 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+'use strict';
+
+const fs = require('fs');
+
+const LDD_PATH = '/usr/bin/ldd';
+const SELF_PATH = '/proc/self/exe';
+const MAX_LENGTH = 2048;
+
+/**
+ * Read the content of a file synchronous
+ *
+ * @param {string} path
+ * @returns {Buffer}
+ */
+const readFileSync = (path) => {
+  const fd = fs.openSync(path, 'r');
+  const buffer = Buffer.alloc(MAX_LENGTH);
+  const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+  fs.close(fd, () => {});
+  return buffer.subarray(0, bytesRead);
+};
+
+/**
+ * Read the content of a file
+ *
+ * @param {string} path
+ * @returns {Promise<Buffer>}
+ */
+const readFile = (path) => new Promise((resolve, reject) => {
+  fs.open(path, 'r', (err, fd) => {
+    if (err) {
+      reject(err);
+    } else {
+      const buffer = Buffer.alloc(MAX_LENGTH);
+      fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+        resolve(buffer.subarray(0, bytesRead));
+        fs.close(fd, () => {});
+      });
+    }
+  });
+});
+
+module.exports = {
+  LDD_PATH,
+  SELF_PATH,
+  readFileSync,
+  readFile
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/process.js b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/process.js
new file mode 100644
index 0000000..ee78ad2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/lib/process.js
@@ -0,0 +1,24 @@
+// Copyright 2017 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+'use strict';
+
+const isLinux = () => process.platform === 'linux';
+
+let report = null;
+const getReport = () => {
+  if (!report) {
+    /* istanbul ignore next */
+    if (isLinux() && process.report) {
+      const orig = process.report.excludeNetwork;
+      process.report.excludeNetwork = true;
+      report = process.report.getReport();
+      process.report.excludeNetwork = orig;
+    } else {
+      report = {};
+    }
+  }
+  return report;
+};
+
+module.exports = { isLinux, getReport };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/package.json
new file mode 100644
index 0000000..36d0f2b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/detect-libc/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "detect-libc",
+  "version": "2.1.2",
+  "description": "Node.js module to detect the C standard library (libc) implementation family and version",
+  "main": "lib/detect-libc.js",
+  "files": [
+    "lib/",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "test": "semistandard && nyc --reporter=text --check-coverage --branches=100 ava test/unit.js",
+    "changelog": "conventional-changelog -i CHANGELOG.md -s",
+    "bench": "node benchmark/detect-libc",
+    "bench:calls": "node benchmark/call-familySync.js && sleep 1 && node benchmark/call-isNonGlibcLinuxSync.js && sleep 1 && node benchmark/call-versionSync.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/lovell/detect-libc.git"
+  },
+  "keywords": [
+    "libc",
+    "glibc",
+    "musl"
+  ],
+  "author": "Lovell Fuller <npm@lovell.info>",
+  "contributors": [
+    "Niklas Salmoukas <niklas@salmoukas.com>",
+    "Vinícius Lourenço <vinyygamerlol@gmail.com>"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "ava": "^2.4.0",
+    "benchmark": "^2.1.4",
+    "conventional-changelog-cli": "^5.0.0",
+    "eslint-config-standard": "^13.0.1",
+    "nyc": "^15.1.0",
+    "proxyquire": "^2.1.3",
+    "semistandard": "^14.2.3"
+  },
+  "engines": {
+    "node": ">=8"
+  },
+  "types": "index.d.ts"
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/LICENSE
new file mode 100644
index 0000000..bb7fdee
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/LICENSE
@@ -0,0 +1,7 @@
+Copyright 2023 Abdullah Atta
+
+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.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/README.md
new file mode 100644
index 0000000..5c70530
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/README.md
@@ -0,0 +1,91 @@
+<p align="center">
+<img src="https://github.com/thecodrr/fdir/raw/master/assets/fdir.gif" width="75%"/>
+
+<h1 align="center">The Fastest Directory Crawler & Globber for NodeJS</h1>
+<p align="center">
+  <a href="https://www.npmjs.com/package/fdir"><img src="https://img.shields.io/npm/v/fdir?style=for-the-badge"/></a>
+  <a href="https://www.npmjs.com/package/fdir"><img src="https://img.shields.io/npm/dw/fdir?style=for-the-badge"/></a>
+  <a href="https://codeclimate.com/github/thecodrr/fdir/maintainability"><img src="https://img.shields.io/codeclimate/maintainability-percentage/thecodrr/fdir?style=for-the-badge"/></a>
+  <a href="https://coveralls.io/github/thecodrr/fdir?branch=master"><img src="https://img.shields.io/coveralls/github/thecodrr/fdir?style=for-the-badge"/></a>
+  <a href="https://www.npmjs.com/package/fdir"><img src="https://img.shields.io/bundlephobia/minzip/fdir?style=for-the-badge"/></a>
+  <a href="https://www.producthunt.com/posts/fdir-every-millisecond-matters"><img src="https://img.shields.io/badge/ProductHunt-Upvote-red?style=for-the-badge&logo=product-hunt"/></a>
+  <a href="https://dev.to/thecodrr/how-i-wrote-the-fastest-directory-crawler-ever-3p9c"><img src="https://img.shields.io/badge/dev.to-Read%20Blog-black?style=for-the-badge&logo=dev.to"/></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/github/license/thecodrr/fdir?style=for-the-badge"/></a>
+</p>
+</p>
+
+⚡ **The Fastest:** Nothing similar (in the NodeJS world) beats `fdir` in speed. It can easily crawl a directory containing **1 million files in < 1 second.**
+
+💡 **Stupidly Easy:** `fdir` uses expressive Builder pattern to build the crawler increasing code readability.
+
+🤖 **Zero Dependencies\*:** `fdir` only uses NodeJS `fs` & `path` modules.
+
+🕺 **Astonishingly Small:** < 2KB in size gzipped & minified.
+
+🖮 **Hackable:** Extending `fdir` is extremely simple now that the new Builder API is here. Feel free to experiment around.
+
+_\* `picomatch` must be installed manually by the user to support globbing._
+
+## 🚄 Quickstart
+
+### Installation
+
+You can install using `npm`:
+
+```sh
+$ npm i fdir
+```
+
+or Yarn:
+
+```sh
+$ yarn add fdir
+```
+
+### Usage
+
+```ts
+import { fdir } from "fdir";
+
+// create the builder
+const api = new fdir().withFullPaths().crawl("path/to/dir");
+
+// get all files in a directory synchronously
+const files = api.sync();
+
+// or asynchronously
+api.withPromise().then((files) => {
+  // do something with the result here.
+});
+```
+
+## Documentation:
+
+Documentation for all methods is available [here](/documentation.md).
+
+## 📊 Benchmarks:
+
+Please check the benchmark against the latest version [here](/BENCHMARKS.md).
+
+## 🙏Used by:
+
+`fdir` is downloaded over 200k+ times a week by projects around the world. Here's a list of some notable projects using `fdir` in production:
+
+> Note: if you think your project should be here, feel free to open an issue. Notable is anything with a considerable amount of GitHub stars.
+
+1. [rollup/plugins](https://github.com/rollup/plugins)
+2. [SuperchupuDev/tinyglobby](https://github.com/SuperchupuDev/tinyglobby)
+3. [pulumi/pulumi](https://github.com/pulumi/pulumi)
+4. [dotenvx/dotenvx](https://github.com/dotenvx/dotenvx)
+5. [mdn/yari](https://github.com/mdn/yari)
+6. [streetwriters/notesnook](https://github.com/streetwriters/notesnook)
+7. [imba/imba](https://github.com/imba/imba)
+8. [moroshko/react-scanner](https://github.com/moroshko/react-scanner)
+9. [netlify/build](https://github.com/netlify/build)
+10. [yassinedoghri/astro-i18next](https://github.com/yassinedoghri/astro-i18next)
+11. [selfrefactor/rambda](https://github.com/selfrefactor/rambda)
+12. [whyboris/Video-Hub-App](https://github.com/whyboris/Video-Hub-App)
+
+## 🦮 LICENSE
+
+Copyright &copy; 2024 Abdullah Atta under MIT. [Read full text here.](https://github.com/thecodrr/fdir/raw/master/LICENSE)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.cjs b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.cjs
new file mode 100644
index 0000000..4868ffb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.cjs
@@ -0,0 +1,588 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const path = __toESM(require("path"));
+const fs = __toESM(require("fs"));
+
+//#region src/utils.ts
+function cleanPath(path$1) {
+	let normalized = (0, path.normalize)(path$1);
+	if (normalized.length > 1 && normalized[normalized.length - 1] === path.sep) normalized = normalized.substring(0, normalized.length - 1);
+	return normalized;
+}
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path$1, separator) {
+	return path$1.replace(SLASHES_REGEX, separator);
+}
+const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path$1) {
+	return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1);
+}
+function normalizePath(path$1, options) {
+	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+	const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith(".");
+	if (resolvePaths) path$1 = (0, path.resolve)(path$1);
+	if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1);
+	if (path$1 === ".") return "";
+	const needsSeperator = path$1[path$1.length - 1] !== pathSeparator;
+	return convertSlashes(needsSeperator ? path$1 + pathSeparator : path$1, pathSeparator);
+}
+
+//#endregion
+//#region src/api/functions/join-path.ts
+function joinPathWithBasePath(filename, directoryPath) {
+	return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+	return function(filename, directoryPath) {
+		const sameRoot = directoryPath.startsWith(root);
+		if (sameRoot) return directoryPath.slice(root.length) + filename;
+		else return convertSlashes((0, path.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+	};
+}
+function joinPath(filename) {
+	return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+	return directoryPath + filename + separator;
+}
+function build$7(root, options) {
+	const { relativePaths, includeBasePath } = options;
+	return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+}
+
+//#endregion
+//#region src/api/functions/push-directory.ts
+function pushDirectoryWithRelativePath(root) {
+	return function(directoryPath, paths) {
+		paths.push(directoryPath.substring(root.length) || ".");
+	};
+}
+function pushDirectoryFilterWithRelativePath(root) {
+	return function(directoryPath, paths, filters) {
+		const relativePath = directoryPath.substring(root.length) || ".";
+		if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath);
+	};
+}
+const pushDirectory = (directoryPath, paths) => {
+	paths.push(directoryPath || ".");
+};
+const pushDirectoryFilter = (directoryPath, paths, filters) => {
+	const path$1 = directoryPath || ".";
+	if (filters.every((filter) => filter(path$1, true))) paths.push(path$1);
+};
+const empty$2 = () => {};
+function build$6(root, options) {
+	const { includeDirs, filters, relativePaths } = options;
+	if (!includeDirs) return empty$2;
+	if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+	return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+}
+
+//#endregion
+//#region src/api/functions/push-file.ts
+const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+	if (filters.every((filter) => filter(filename, false))) counts.files++;
+};
+const pushFileFilter = (filename, paths, _counts, filters) => {
+	if (filters.every((filter) => filter(filename, false))) paths.push(filename);
+};
+const pushFileCount = (_filename, _paths, counts, _filters) => {
+	counts.files++;
+};
+const pushFile = (filename, paths) => {
+	paths.push(filename);
+};
+const empty$1 = () => {};
+function build$5(options) {
+	const { excludeFiles, filters, onlyCounts } = options;
+	if (excludeFiles) return empty$1;
+	if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+	else if (onlyCounts) return pushFileCount;
+	else return pushFile;
+}
+
+//#endregion
+//#region src/api/functions/get-array.ts
+const getArray = (paths) => {
+	return paths;
+};
+const getArrayGroup = () => {
+	return [""].slice(0, 0);
+};
+function build$4(options) {
+	return options.group ? getArrayGroup : getArray;
+}
+
+//#endregion
+//#region src/api/functions/group-files.ts
+const groupFiles = (groups, directory, files) => {
+	groups.push({
+		directory,
+		files,
+		dir: directory
+	});
+};
+const empty = () => {};
+function build$3(options) {
+	return options.group ? groupFiles : empty;
+}
+
+//#endregion
+//#region src/api/functions/resolve-symlink.ts
+const resolveSymlinksAsync = function(path$1, state, callback$1) {
+	const { queue, fs: fs$1, options: { suppressErrors } } = state;
+	queue.enqueue();
+	fs$1.realpath(path$1, (error, resolvedPath) => {
+		if (error) return queue.dequeue(suppressErrors ? null : error, state);
+		fs$1.stat(resolvedPath, (error$1, stat) => {
+			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+			if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state);
+			callback$1(stat, resolvedPath);
+			queue.dequeue(null, state);
+		});
+	});
+};
+const resolveSymlinks = function(path$1, state, callback$1) {
+	const { queue, fs: fs$1, options: { suppressErrors } } = state;
+	queue.enqueue();
+	try {
+		const resolvedPath = fs$1.realpathSync(path$1);
+		const stat = fs$1.statSync(resolvedPath);
+		if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return;
+		callback$1(stat, resolvedPath);
+	} catch (e) {
+		if (!suppressErrors) throw e;
+	}
+};
+function build$2(options, isSynchronous) {
+	if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path$1, resolved, state) {
+	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+	let parent = (0, path.dirname)(path$1);
+	let depth = 1;
+	while (parent !== state.root && depth < 2) {
+		const resolvedPath = state.symlinks.get(parent);
+		const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+		if (isSameRoot) depth++;
+		else parent = (0, path.dirname)(parent);
+	}
+	state.symlinks.set(path$1, resolved);
+	return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+	return state.visited.includes(resolved + state.options.pathSeparator);
+}
+
+//#endregion
+//#region src/api/functions/invoke-callback.ts
+const onlyCountsSync = (state) => {
+	return state.counts;
+};
+const groupsSync = (state) => {
+	return state.groups;
+};
+const defaultSync = (state) => {
+	return state.paths;
+};
+const limitFilesSync = (state) => {
+	return state.paths.slice(0, state.options.maxFiles);
+};
+const onlyCountsAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.counts, state.options.suppressErrors);
+	return null;
+};
+const defaultAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.paths, state.options.suppressErrors);
+	return null;
+};
+const limitFilesAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+	return null;
+};
+const groupsAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.groups, state.options.suppressErrors);
+	return null;
+};
+function report(error, callback$1, output, suppressErrors) {
+	if (error && !suppressErrors) callback$1(error, output);
+	else callback$1(null, output);
+}
+function build$1(options, isSynchronous) {
+	const { onlyCounts, group, maxFiles } = options;
+	if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+	else if (group) return isSynchronous ? groupsSync : groupsAsync;
+	else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
+	else return isSynchronous ? defaultSync : defaultAsync;
+}
+
+//#endregion
+//#region src/api/functions/walk-directory.ts
+const readdirOpts = { withFileTypes: true };
+const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	state.queue.enqueue();
+	if (currentDepth < 0) return state.queue.dequeue(null, state);
+	const { fs: fs$1 } = state;
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	fs$1.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+		callback$1(entries, directoryPath, currentDepth);
+		state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+	});
+};
+const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	const { fs: fs$1 } = state;
+	if (currentDepth < 0) return;
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	let entries = [];
+	try {
+		entries = fs$1.readdirSync(crawlPath || ".", readdirOpts);
+	} catch (e) {
+		if (!state.options.suppressErrors) throw e;
+	}
+	callback$1(entries, directoryPath, currentDepth);
+};
+function build(isSynchronous) {
+	return isSynchronous ? walkSync : walkAsync;
+}
+
+//#endregion
+//#region src/api/queue.ts
+/**
+* This is a custom stateless queue to track concurrent async fs calls.
+* It increments a counter whenever a call is queued and decrements it
+* as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+*/
+var Queue = class {
+	count = 0;
+	constructor(onQueueEmpty) {
+		this.onQueueEmpty = onQueueEmpty;
+	}
+	enqueue() {
+		this.count++;
+		return this.count;
+	}
+	dequeue(error, output) {
+		if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+			this.onQueueEmpty(error, output);
+			if (error) {
+				output.controller.abort();
+				this.onQueueEmpty = void 0;
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/api/counter.ts
+var Counter = class {
+	_files = 0;
+	_directories = 0;
+	set files(num) {
+		this._files = num;
+	}
+	get files() {
+		return this._files;
+	}
+	set directories(num) {
+		this._directories = num;
+	}
+	get directories() {
+		return this._directories;
+	}
+	/**
+	* @deprecated use `directories` instead
+	*/
+	/* c8 ignore next 3 */
+	get dirs() {
+		return this._directories;
+	}
+};
+
+//#endregion
+//#region src/api/aborter.ts
+/**
+* AbortController is not supported on Node 14 so we use this until we can drop
+* support for Node 14.
+*/
+var Aborter = class {
+	aborted = false;
+	abort() {
+		this.aborted = true;
+	}
+};
+
+//#endregion
+//#region src/api/walker.ts
+var Walker = class {
+	root;
+	isSynchronous;
+	state;
+	joinPath;
+	pushDirectory;
+	pushFile;
+	getArray;
+	groupFiles;
+	resolveSymlink;
+	walkDirectory;
+	callbackInvoker;
+	constructor(root, options, callback$1) {
+		this.isSynchronous = !callback$1;
+		this.callbackInvoker = build$1(options, this.isSynchronous);
+		this.root = normalizePath(root, options);
+		this.state = {
+			root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+			paths: [""].slice(0, 0),
+			groups: [],
+			counts: new Counter(),
+			options,
+			queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
+			symlinks: /* @__PURE__ */ new Map(),
+			visited: [""].slice(0, 0),
+			controller: new Aborter(),
+			fs: options.fs || fs
+		};
+		this.joinPath = build$7(this.root, options);
+		this.pushDirectory = build$6(this.root, options);
+		this.pushFile = build$5(options);
+		this.getArray = build$4(options);
+		this.groupFiles = build$3(options);
+		this.resolveSymlink = build$2(options, this.isSynchronous);
+		this.walkDirectory = build(this.isSynchronous);
+	}
+	start() {
+		this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+		this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+		return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+	}
+	walk = (entries, directoryPath, depth) => {
+		const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+		if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+		const files = this.getArray(this.state.paths);
+		for (let i = 0; i < entries.length; ++i) {
+			const entry = entries[i];
+			if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+				const filename = this.joinPath(entry.name, directoryPath);
+				this.pushFile(filename, files, this.state.counts, filters);
+			} else if (entry.isDirectory()) {
+				let path$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+				if (exclude && exclude(entry.name, path$1)) continue;
+				this.pushDirectory(path$1, paths, filters);
+				this.walkDirectory(this.state, path$1, path$1, depth - 1, this.walk);
+			} else if (this.resolveSymlink && entry.isSymbolicLink()) {
+				let path$1 = joinPathWithBasePath(entry.name, directoryPath);
+				this.resolveSymlink(path$1, this.state, (stat, resolvedPath) => {
+					if (stat.isDirectory()) {
+						resolvedPath = normalizePath(resolvedPath, this.state.options);
+						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return;
+						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth - 1, this.walk);
+					} else {
+						resolvedPath = useRealPaths ? resolvedPath : path$1;
+						const filename = (0, path.basename)(resolvedPath);
+						const directoryPath$1 = normalizePath((0, path.dirname)(resolvedPath), this.state.options);
+						resolvedPath = this.joinPath(filename, directoryPath$1);
+						this.pushFile(resolvedPath, files, this.state.counts, filters);
+					}
+				});
+			}
+		}
+		this.groupFiles(this.state.groups, directoryPath, files);
+	};
+};
+
+//#endregion
+//#region src/api/async.ts
+function promise(root, options) {
+	return new Promise((resolve$1, reject) => {
+		callback(root, options, (err, output) => {
+			if (err) return reject(err);
+			resolve$1(output);
+		});
+	});
+}
+function callback(root, options, callback$1) {
+	let walker = new Walker(root, options, callback$1);
+	walker.start();
+}
+
+//#endregion
+//#region src/api/sync.ts
+function sync(root, options) {
+	const walker = new Walker(root, options);
+	return walker.start();
+}
+
+//#endregion
+//#region src/builder/api-builder.ts
+var APIBuilder = class {
+	constructor(root, options) {
+		this.root = root;
+		this.options = options;
+	}
+	withPromise() {
+		return promise(this.root, this.options);
+	}
+	withCallback(cb) {
+		callback(this.root, this.options, cb);
+	}
+	sync() {
+		return sync(this.root, this.options);
+	}
+};
+
+//#endregion
+//#region src/builder/index.ts
+let pm = null;
+/* c8 ignore next 6 */
+try {
+	require.resolve("picomatch");
+	pm = require("picomatch");
+} catch {}
+var Builder = class {
+	globCache = {};
+	options = {
+		maxDepth: Infinity,
+		suppressErrors: true,
+		pathSeparator: path.sep,
+		filters: []
+	};
+	globFunction;
+	constructor(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		this.globFunction = this.options.globFunction;
+	}
+	group() {
+		this.options.group = true;
+		return this;
+	}
+	withPathSeparator(separator) {
+		this.options.pathSeparator = separator;
+		return this;
+	}
+	withBasePath() {
+		this.options.includeBasePath = true;
+		return this;
+	}
+	withRelativePaths() {
+		this.options.relativePaths = true;
+		return this;
+	}
+	withDirs() {
+		this.options.includeDirs = true;
+		return this;
+	}
+	withMaxDepth(depth) {
+		this.options.maxDepth = depth;
+		return this;
+	}
+	withMaxFiles(limit) {
+		this.options.maxFiles = limit;
+		return this;
+	}
+	withFullPaths() {
+		this.options.resolvePaths = true;
+		this.options.includeBasePath = true;
+		return this;
+	}
+	withErrors() {
+		this.options.suppressErrors = false;
+		return this;
+	}
+	withSymlinks({ resolvePaths = true } = {}) {
+		this.options.resolveSymlinks = true;
+		this.options.useRealPaths = resolvePaths;
+		return this.withFullPaths();
+	}
+	withAbortSignal(signal) {
+		this.options.signal = signal;
+		return this;
+	}
+	normalize() {
+		this.options.normalizePath = true;
+		return this;
+	}
+	filter(predicate) {
+		this.options.filters.push(predicate);
+		return this;
+	}
+	onlyDirs() {
+		this.options.excludeFiles = true;
+		this.options.includeDirs = true;
+		return this;
+	}
+	exclude(predicate) {
+		this.options.exclude = predicate;
+		return this;
+	}
+	onlyCounts() {
+		this.options.onlyCounts = true;
+		return this;
+	}
+	crawl(root) {
+		return new APIBuilder(root || ".", this.options);
+	}
+	withGlobFunction(fn) {
+		this.globFunction = fn;
+		return this;
+	}
+	/**
+	* @deprecated Pass options using the constructor instead:
+	* ```ts
+	* new fdir(options).crawl("/path/to/root");
+	* ```
+	* This method will be removed in v7.0
+	*/
+	/* c8 ignore next 4 */
+	crawlWithOptions(root, options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		return new APIBuilder(root || ".", this.options);
+	}
+	glob(...patterns) {
+		if (this.globFunction) return this.globWithOptions(patterns);
+		return this.globWithOptions(patterns, ...[{ dot: true }]);
+	}
+	globWithOptions(patterns, ...options) {
+		const globFn = this.globFunction || pm;
+		/* c8 ignore next 5 */
+		if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
+		var isMatch = this.globCache[patterns.join("\0")];
+		if (!isMatch) {
+			isMatch = globFn(patterns, ...options);
+			this.globCache[patterns.join("\0")] = isMatch;
+		}
+		this.options.filters.push((path$1) => isMatch(path$1));
+		return this;
+	}
+};
+
+//#endregion
+exports.fdir = Builder;
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.d.cts b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.d.cts
new file mode 100644
index 0000000..f448ef5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.d.cts
@@ -0,0 +1,155 @@
+/// <reference types="node" />
+import * as nativeFs from "fs";
+import picomatch from "picomatch";
+
+//#region src/api/aborter.d.ts
+/**
+ * AbortController is not supported on Node 14 so we use this until we can drop
+ * support for Node 14.
+ */
+declare class Aborter {
+  aborted: boolean;
+  abort(): void;
+}
+//#endregion
+//#region src/api/queue.d.ts
+type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void;
+/**
+ * This is a custom stateless queue to track concurrent async fs calls.
+ * It increments a counter whenever a call is queued and decrements it
+ * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+ */
+declare class Queue {
+  private onQueueEmpty?;
+  count: number;
+  constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined);
+  enqueue(): number;
+  dequeue(error: Error | null, output: WalkerState): void;
+}
+//#endregion
+//#region src/types.d.ts
+type Counts = {
+  files: number;
+  directories: number;
+  /**
+   * @deprecated use `directories` instead. Will be removed in v7.0.
+   */
+  dirs: number;
+};
+type Group = {
+  directory: string;
+  files: string[];
+  /**
+   * @deprecated use `directory` instead. Will be removed in v7.0.
+   */
+  dir: string;
+};
+type GroupOutput = Group[];
+type OnlyCountsOutput = Counts;
+type PathsOutput = string[];
+type Output = OnlyCountsOutput | PathsOutput | GroupOutput;
+type FSLike = {
+  readdir: typeof nativeFs.readdir;
+  readdirSync: typeof nativeFs.readdirSync;
+  realpath: typeof nativeFs.realpath;
+  realpathSync: typeof nativeFs.realpathSync;
+  stat: typeof nativeFs.stat;
+  statSync: typeof nativeFs.statSync;
+};
+type WalkerState = {
+  root: string;
+  paths: string[];
+  groups: Group[];
+  counts: Counts;
+  options: Options;
+  queue: Queue;
+  controller: Aborter;
+  fs: FSLike;
+  symlinks: Map<string, string>;
+  visited: string[];
+};
+type ResultCallback<TOutput extends Output> = (error: Error | null, output: TOutput) => void;
+type FilterPredicate = (path: string, isDirectory: boolean) => boolean;
+type ExcludePredicate = (dirName: string, dirPath: string) => boolean;
+type PathSeparator = "/" | "\\";
+type Options<TGlobFunction = unknown> = {
+  includeBasePath?: boolean;
+  includeDirs?: boolean;
+  normalizePath?: boolean;
+  maxDepth: number;
+  maxFiles?: number;
+  resolvePaths?: boolean;
+  suppressErrors: boolean;
+  group?: boolean;
+  onlyCounts?: boolean;
+  filters: FilterPredicate[];
+  resolveSymlinks?: boolean;
+  useRealPaths?: boolean;
+  excludeFiles?: boolean;
+  excludeSymlinks?: boolean;
+  exclude?: ExcludePredicate;
+  relativePaths?: boolean;
+  pathSeparator: PathSeparator;
+  signal?: AbortSignal;
+  globFunction?: TGlobFunction;
+  fs?: FSLike;
+};
+type GlobMatcher = (test: string) => boolean;
+type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher;
+type GlobParams<T> = T extends ((globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher) ? TParams : [];
+//#endregion
+//#region src/builder/api-builder.d.ts
+declare class APIBuilder<TReturnType extends Output> {
+  private readonly root;
+  private readonly options;
+  constructor(root: string, options: Options);
+  withPromise(): Promise<TReturnType>;
+  withCallback(cb: ResultCallback<TReturnType>): void;
+  sync(): TReturnType;
+}
+//#endregion
+//#region src/builder/index.d.ts
+declare class Builder<TReturnType extends Output = PathsOutput, TGlobFunction = typeof picomatch> {
+  private readonly globCache;
+  private options;
+  private globFunction?;
+  constructor(options?: Partial<Options<TGlobFunction>>);
+  group(): Builder<GroupOutput, TGlobFunction>;
+  withPathSeparator(separator: "/" | "\\"): this;
+  withBasePath(): this;
+  withRelativePaths(): this;
+  withDirs(): this;
+  withMaxDepth(depth: number): this;
+  withMaxFiles(limit: number): this;
+  withFullPaths(): this;
+  withErrors(): this;
+  withSymlinks({
+    resolvePaths
+  }?: {
+    resolvePaths?: boolean | undefined;
+  }): this;
+  withAbortSignal(signal: AbortSignal): this;
+  normalize(): this;
+  filter(predicate: FilterPredicate): this;
+  onlyDirs(): this;
+  exclude(predicate: ExcludePredicate): this;
+  onlyCounts(): Builder<OnlyCountsOutput, TGlobFunction>;
+  crawl(root?: string): APIBuilder<TReturnType>;
+  withGlobFunction<TFunc>(fn: TFunc): Builder<TReturnType, TFunc>;
+  /**
+   * @deprecated Pass options using the constructor instead:
+   * ```ts
+   * new fdir(options).crawl("/path/to/root");
+   * ```
+   * This method will be removed in v7.0
+   */
+  crawlWithOptions(root: string, options: Partial<Options<TGlobFunction>>): APIBuilder<TReturnType>;
+  glob(...patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[], ...options: GlobParams<TGlobFunction>): Builder<TReturnType, TGlobFunction>;
+}
+//#endregion
+//#region src/index.d.ts
+type Fdir = typeof Builder;
+//#endregion
+export { Counts, ExcludePredicate, FSLike, Fdir, FilterPredicate, GlobFunction, GlobMatcher, GlobParams, Group, GroupOutput, OnlyCountsOutput, Options, Output, PathSeparator, PathsOutput, ResultCallback, WalkerState, Builder as fdir };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.d.mts
new file mode 100644
index 0000000..f448ef5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.d.mts
@@ -0,0 +1,155 @@
+/// <reference types="node" />
+import * as nativeFs from "fs";
+import picomatch from "picomatch";
+
+//#region src/api/aborter.d.ts
+/**
+ * AbortController is not supported on Node 14 so we use this until we can drop
+ * support for Node 14.
+ */
+declare class Aborter {
+  aborted: boolean;
+  abort(): void;
+}
+//#endregion
+//#region src/api/queue.d.ts
+type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void;
+/**
+ * This is a custom stateless queue to track concurrent async fs calls.
+ * It increments a counter whenever a call is queued and decrements it
+ * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+ */
+declare class Queue {
+  private onQueueEmpty?;
+  count: number;
+  constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined);
+  enqueue(): number;
+  dequeue(error: Error | null, output: WalkerState): void;
+}
+//#endregion
+//#region src/types.d.ts
+type Counts = {
+  files: number;
+  directories: number;
+  /**
+   * @deprecated use `directories` instead. Will be removed in v7.0.
+   */
+  dirs: number;
+};
+type Group = {
+  directory: string;
+  files: string[];
+  /**
+   * @deprecated use `directory` instead. Will be removed in v7.0.
+   */
+  dir: string;
+};
+type GroupOutput = Group[];
+type OnlyCountsOutput = Counts;
+type PathsOutput = string[];
+type Output = OnlyCountsOutput | PathsOutput | GroupOutput;
+type FSLike = {
+  readdir: typeof nativeFs.readdir;
+  readdirSync: typeof nativeFs.readdirSync;
+  realpath: typeof nativeFs.realpath;
+  realpathSync: typeof nativeFs.realpathSync;
+  stat: typeof nativeFs.stat;
+  statSync: typeof nativeFs.statSync;
+};
+type WalkerState = {
+  root: string;
+  paths: string[];
+  groups: Group[];
+  counts: Counts;
+  options: Options;
+  queue: Queue;
+  controller: Aborter;
+  fs: FSLike;
+  symlinks: Map<string, string>;
+  visited: string[];
+};
+type ResultCallback<TOutput extends Output> = (error: Error | null, output: TOutput) => void;
+type FilterPredicate = (path: string, isDirectory: boolean) => boolean;
+type ExcludePredicate = (dirName: string, dirPath: string) => boolean;
+type PathSeparator = "/" | "\\";
+type Options<TGlobFunction = unknown> = {
+  includeBasePath?: boolean;
+  includeDirs?: boolean;
+  normalizePath?: boolean;
+  maxDepth: number;
+  maxFiles?: number;
+  resolvePaths?: boolean;
+  suppressErrors: boolean;
+  group?: boolean;
+  onlyCounts?: boolean;
+  filters: FilterPredicate[];
+  resolveSymlinks?: boolean;
+  useRealPaths?: boolean;
+  excludeFiles?: boolean;
+  excludeSymlinks?: boolean;
+  exclude?: ExcludePredicate;
+  relativePaths?: boolean;
+  pathSeparator: PathSeparator;
+  signal?: AbortSignal;
+  globFunction?: TGlobFunction;
+  fs?: FSLike;
+};
+type GlobMatcher = (test: string) => boolean;
+type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher;
+type GlobParams<T> = T extends ((globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher) ? TParams : [];
+//#endregion
+//#region src/builder/api-builder.d.ts
+declare class APIBuilder<TReturnType extends Output> {
+  private readonly root;
+  private readonly options;
+  constructor(root: string, options: Options);
+  withPromise(): Promise<TReturnType>;
+  withCallback(cb: ResultCallback<TReturnType>): void;
+  sync(): TReturnType;
+}
+//#endregion
+//#region src/builder/index.d.ts
+declare class Builder<TReturnType extends Output = PathsOutput, TGlobFunction = typeof picomatch> {
+  private readonly globCache;
+  private options;
+  private globFunction?;
+  constructor(options?: Partial<Options<TGlobFunction>>);
+  group(): Builder<GroupOutput, TGlobFunction>;
+  withPathSeparator(separator: "/" | "\\"): this;
+  withBasePath(): this;
+  withRelativePaths(): this;
+  withDirs(): this;
+  withMaxDepth(depth: number): this;
+  withMaxFiles(limit: number): this;
+  withFullPaths(): this;
+  withErrors(): this;
+  withSymlinks({
+    resolvePaths
+  }?: {
+    resolvePaths?: boolean | undefined;
+  }): this;
+  withAbortSignal(signal: AbortSignal): this;
+  normalize(): this;
+  filter(predicate: FilterPredicate): this;
+  onlyDirs(): this;
+  exclude(predicate: ExcludePredicate): this;
+  onlyCounts(): Builder<OnlyCountsOutput, TGlobFunction>;
+  crawl(root?: string): APIBuilder<TReturnType>;
+  withGlobFunction<TFunc>(fn: TFunc): Builder<TReturnType, TFunc>;
+  /**
+   * @deprecated Pass options using the constructor instead:
+   * ```ts
+   * new fdir(options).crawl("/path/to/root");
+   * ```
+   * This method will be removed in v7.0
+   */
+  crawlWithOptions(root: string, options: Partial<Options<TGlobFunction>>): APIBuilder<TReturnType>;
+  glob(...patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[], ...options: GlobParams<TGlobFunction>): Builder<TReturnType, TGlobFunction>;
+}
+//#endregion
+//#region src/index.d.ts
+type Fdir = typeof Builder;
+//#endregion
+export { Counts, ExcludePredicate, FSLike, Fdir, FilterPredicate, GlobFunction, GlobMatcher, GlobParams, Group, GroupOutput, OnlyCountsOutput, Options, Output, PathSeparator, PathsOutput, ResultCallback, WalkerState, Builder as fdir };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.mjs
new file mode 100644
index 0000000..5c37e09
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/dist/index.mjs
@@ -0,0 +1,570 @@
+import { createRequire } from "module";
+import { basename, dirname, normalize, relative, resolve, sep } from "path";
+import * as nativeFs from "fs";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/utils.ts
+function cleanPath(path) {
+	let normalized = normalize(path);
+	if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
+	return normalized;
+}
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+	return path.replace(SLASHES_REGEX, separator);
+}
+const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path) {
+	return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
+}
+function normalizePath(path, options) {
+	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+	const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
+	if (resolvePaths) path = resolve(path);
+	if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path);
+	if (path === ".") return "";
+	const needsSeperator = path[path.length - 1] !== pathSeparator;
+	return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+}
+
+//#endregion
+//#region src/api/functions/join-path.ts
+function joinPathWithBasePath(filename, directoryPath) {
+	return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+	return function(filename, directoryPath) {
+		const sameRoot = directoryPath.startsWith(root);
+		if (sameRoot) return directoryPath.slice(root.length) + filename;
+		else return convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+	};
+}
+function joinPath(filename) {
+	return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+	return directoryPath + filename + separator;
+}
+function build$7(root, options) {
+	const { relativePaths, includeBasePath } = options;
+	return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+}
+
+//#endregion
+//#region src/api/functions/push-directory.ts
+function pushDirectoryWithRelativePath(root) {
+	return function(directoryPath, paths) {
+		paths.push(directoryPath.substring(root.length) || ".");
+	};
+}
+function pushDirectoryFilterWithRelativePath(root) {
+	return function(directoryPath, paths, filters) {
+		const relativePath = directoryPath.substring(root.length) || ".";
+		if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath);
+	};
+}
+const pushDirectory = (directoryPath, paths) => {
+	paths.push(directoryPath || ".");
+};
+const pushDirectoryFilter = (directoryPath, paths, filters) => {
+	const path = directoryPath || ".";
+	if (filters.every((filter) => filter(path, true))) paths.push(path);
+};
+const empty$2 = () => {};
+function build$6(root, options) {
+	const { includeDirs, filters, relativePaths } = options;
+	if (!includeDirs) return empty$2;
+	if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+	return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+}
+
+//#endregion
+//#region src/api/functions/push-file.ts
+const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+	if (filters.every((filter) => filter(filename, false))) counts.files++;
+};
+const pushFileFilter = (filename, paths, _counts, filters) => {
+	if (filters.every((filter) => filter(filename, false))) paths.push(filename);
+};
+const pushFileCount = (_filename, _paths, counts, _filters) => {
+	counts.files++;
+};
+const pushFile = (filename, paths) => {
+	paths.push(filename);
+};
+const empty$1 = () => {};
+function build$5(options) {
+	const { excludeFiles, filters, onlyCounts } = options;
+	if (excludeFiles) return empty$1;
+	if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+	else if (onlyCounts) return pushFileCount;
+	else return pushFile;
+}
+
+//#endregion
+//#region src/api/functions/get-array.ts
+const getArray = (paths) => {
+	return paths;
+};
+const getArrayGroup = () => {
+	return [""].slice(0, 0);
+};
+function build$4(options) {
+	return options.group ? getArrayGroup : getArray;
+}
+
+//#endregion
+//#region src/api/functions/group-files.ts
+const groupFiles = (groups, directory, files) => {
+	groups.push({
+		directory,
+		files,
+		dir: directory
+	});
+};
+const empty = () => {};
+function build$3(options) {
+	return options.group ? groupFiles : empty;
+}
+
+//#endregion
+//#region src/api/functions/resolve-symlink.ts
+const resolveSymlinksAsync = function(path, state, callback$1) {
+	const { queue, fs, options: { suppressErrors } } = state;
+	queue.enqueue();
+	fs.realpath(path, (error, resolvedPath) => {
+		if (error) return queue.dequeue(suppressErrors ? null : error, state);
+		fs.stat(resolvedPath, (error$1, stat) => {
+			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+			if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
+			callback$1(stat, resolvedPath);
+			queue.dequeue(null, state);
+		});
+	});
+};
+const resolveSymlinks = function(path, state, callback$1) {
+	const { queue, fs, options: { suppressErrors } } = state;
+	queue.enqueue();
+	try {
+		const resolvedPath = fs.realpathSync(path);
+		const stat = fs.statSync(resolvedPath);
+		if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+		callback$1(stat, resolvedPath);
+	} catch (e) {
+		if (!suppressErrors) throw e;
+	}
+};
+function build$2(options, isSynchronous) {
+	if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path, resolved, state) {
+	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+	let parent = dirname(path);
+	let depth = 1;
+	while (parent !== state.root && depth < 2) {
+		const resolvedPath = state.symlinks.get(parent);
+		const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+		if (isSameRoot) depth++;
+		else parent = dirname(parent);
+	}
+	state.symlinks.set(path, resolved);
+	return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+	return state.visited.includes(resolved + state.options.pathSeparator);
+}
+
+//#endregion
+//#region src/api/functions/invoke-callback.ts
+const onlyCountsSync = (state) => {
+	return state.counts;
+};
+const groupsSync = (state) => {
+	return state.groups;
+};
+const defaultSync = (state) => {
+	return state.paths;
+};
+const limitFilesSync = (state) => {
+	return state.paths.slice(0, state.options.maxFiles);
+};
+const onlyCountsAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.counts, state.options.suppressErrors);
+	return null;
+};
+const defaultAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.paths, state.options.suppressErrors);
+	return null;
+};
+const limitFilesAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+	return null;
+};
+const groupsAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.groups, state.options.suppressErrors);
+	return null;
+};
+function report(error, callback$1, output, suppressErrors) {
+	if (error && !suppressErrors) callback$1(error, output);
+	else callback$1(null, output);
+}
+function build$1(options, isSynchronous) {
+	const { onlyCounts, group, maxFiles } = options;
+	if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+	else if (group) return isSynchronous ? groupsSync : groupsAsync;
+	else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
+	else return isSynchronous ? defaultSync : defaultAsync;
+}
+
+//#endregion
+//#region src/api/functions/walk-directory.ts
+const readdirOpts = { withFileTypes: true };
+const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	state.queue.enqueue();
+	if (currentDepth < 0) return state.queue.dequeue(null, state);
+	const { fs } = state;
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+		callback$1(entries, directoryPath, currentDepth);
+		state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+	});
+};
+const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	const { fs } = state;
+	if (currentDepth < 0) return;
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	let entries = [];
+	try {
+		entries = fs.readdirSync(crawlPath || ".", readdirOpts);
+	} catch (e) {
+		if (!state.options.suppressErrors) throw e;
+	}
+	callback$1(entries, directoryPath, currentDepth);
+};
+function build(isSynchronous) {
+	return isSynchronous ? walkSync : walkAsync;
+}
+
+//#endregion
+//#region src/api/queue.ts
+/**
+* This is a custom stateless queue to track concurrent async fs calls.
+* It increments a counter whenever a call is queued and decrements it
+* as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+*/
+var Queue = class {
+	count = 0;
+	constructor(onQueueEmpty) {
+		this.onQueueEmpty = onQueueEmpty;
+	}
+	enqueue() {
+		this.count++;
+		return this.count;
+	}
+	dequeue(error, output) {
+		if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+			this.onQueueEmpty(error, output);
+			if (error) {
+				output.controller.abort();
+				this.onQueueEmpty = void 0;
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/api/counter.ts
+var Counter = class {
+	_files = 0;
+	_directories = 0;
+	set files(num) {
+		this._files = num;
+	}
+	get files() {
+		return this._files;
+	}
+	set directories(num) {
+		this._directories = num;
+	}
+	get directories() {
+		return this._directories;
+	}
+	/**
+	* @deprecated use `directories` instead
+	*/
+	/* c8 ignore next 3 */
+	get dirs() {
+		return this._directories;
+	}
+};
+
+//#endregion
+//#region src/api/aborter.ts
+/**
+* AbortController is not supported on Node 14 so we use this until we can drop
+* support for Node 14.
+*/
+var Aborter = class {
+	aborted = false;
+	abort() {
+		this.aborted = true;
+	}
+};
+
+//#endregion
+//#region src/api/walker.ts
+var Walker = class {
+	root;
+	isSynchronous;
+	state;
+	joinPath;
+	pushDirectory;
+	pushFile;
+	getArray;
+	groupFiles;
+	resolveSymlink;
+	walkDirectory;
+	callbackInvoker;
+	constructor(root, options, callback$1) {
+		this.isSynchronous = !callback$1;
+		this.callbackInvoker = build$1(options, this.isSynchronous);
+		this.root = normalizePath(root, options);
+		this.state = {
+			root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+			paths: [""].slice(0, 0),
+			groups: [],
+			counts: new Counter(),
+			options,
+			queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
+			symlinks: /* @__PURE__ */ new Map(),
+			visited: [""].slice(0, 0),
+			controller: new Aborter(),
+			fs: options.fs || nativeFs
+		};
+		this.joinPath = build$7(this.root, options);
+		this.pushDirectory = build$6(this.root, options);
+		this.pushFile = build$5(options);
+		this.getArray = build$4(options);
+		this.groupFiles = build$3(options);
+		this.resolveSymlink = build$2(options, this.isSynchronous);
+		this.walkDirectory = build(this.isSynchronous);
+	}
+	start() {
+		this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+		this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+		return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+	}
+	walk = (entries, directoryPath, depth) => {
+		const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+		if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+		const files = this.getArray(this.state.paths);
+		for (let i = 0; i < entries.length; ++i) {
+			const entry = entries[i];
+			if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+				const filename = this.joinPath(entry.name, directoryPath);
+				this.pushFile(filename, files, this.state.counts, filters);
+			} else if (entry.isDirectory()) {
+				let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+				if (exclude && exclude(entry.name, path)) continue;
+				this.pushDirectory(path, paths, filters);
+				this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+			} else if (this.resolveSymlink && entry.isSymbolicLink()) {
+				let path = joinPathWithBasePath(entry.name, directoryPath);
+				this.resolveSymlink(path, this.state, (stat, resolvedPath) => {
+					if (stat.isDirectory()) {
+						resolvedPath = normalizePath(resolvedPath, this.state.options);
+						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
+						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+					} else {
+						resolvedPath = useRealPaths ? resolvedPath : path;
+						const filename = basename(resolvedPath);
+						const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
+						resolvedPath = this.joinPath(filename, directoryPath$1);
+						this.pushFile(resolvedPath, files, this.state.counts, filters);
+					}
+				});
+			}
+		}
+		this.groupFiles(this.state.groups, directoryPath, files);
+	};
+};
+
+//#endregion
+//#region src/api/async.ts
+function promise(root, options) {
+	return new Promise((resolve$1, reject) => {
+		callback(root, options, (err, output) => {
+			if (err) return reject(err);
+			resolve$1(output);
+		});
+	});
+}
+function callback(root, options, callback$1) {
+	let walker = new Walker(root, options, callback$1);
+	walker.start();
+}
+
+//#endregion
+//#region src/api/sync.ts
+function sync(root, options) {
+	const walker = new Walker(root, options);
+	return walker.start();
+}
+
+//#endregion
+//#region src/builder/api-builder.ts
+var APIBuilder = class {
+	constructor(root, options) {
+		this.root = root;
+		this.options = options;
+	}
+	withPromise() {
+		return promise(this.root, this.options);
+	}
+	withCallback(cb) {
+		callback(this.root, this.options, cb);
+	}
+	sync() {
+		return sync(this.root, this.options);
+	}
+};
+
+//#endregion
+//#region src/builder/index.ts
+let pm = null;
+/* c8 ignore next 6 */
+try {
+	__require.resolve("picomatch");
+	pm = __require("picomatch");
+} catch {}
+var Builder = class {
+	globCache = {};
+	options = {
+		maxDepth: Infinity,
+		suppressErrors: true,
+		pathSeparator: sep,
+		filters: []
+	};
+	globFunction;
+	constructor(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		this.globFunction = this.options.globFunction;
+	}
+	group() {
+		this.options.group = true;
+		return this;
+	}
+	withPathSeparator(separator) {
+		this.options.pathSeparator = separator;
+		return this;
+	}
+	withBasePath() {
+		this.options.includeBasePath = true;
+		return this;
+	}
+	withRelativePaths() {
+		this.options.relativePaths = true;
+		return this;
+	}
+	withDirs() {
+		this.options.includeDirs = true;
+		return this;
+	}
+	withMaxDepth(depth) {
+		this.options.maxDepth = depth;
+		return this;
+	}
+	withMaxFiles(limit) {
+		this.options.maxFiles = limit;
+		return this;
+	}
+	withFullPaths() {
+		this.options.resolvePaths = true;
+		this.options.includeBasePath = true;
+		return this;
+	}
+	withErrors() {
+		this.options.suppressErrors = false;
+		return this;
+	}
+	withSymlinks({ resolvePaths = true } = {}) {
+		this.options.resolveSymlinks = true;
+		this.options.useRealPaths = resolvePaths;
+		return this.withFullPaths();
+	}
+	withAbortSignal(signal) {
+		this.options.signal = signal;
+		return this;
+	}
+	normalize() {
+		this.options.normalizePath = true;
+		return this;
+	}
+	filter(predicate) {
+		this.options.filters.push(predicate);
+		return this;
+	}
+	onlyDirs() {
+		this.options.excludeFiles = true;
+		this.options.includeDirs = true;
+		return this;
+	}
+	exclude(predicate) {
+		this.options.exclude = predicate;
+		return this;
+	}
+	onlyCounts() {
+		this.options.onlyCounts = true;
+		return this;
+	}
+	crawl(root) {
+		return new APIBuilder(root || ".", this.options);
+	}
+	withGlobFunction(fn) {
+		this.globFunction = fn;
+		return this;
+	}
+	/**
+	* @deprecated Pass options using the constructor instead:
+	* ```ts
+	* new fdir(options).crawl("/path/to/root");
+	* ```
+	* This method will be removed in v7.0
+	*/
+	/* c8 ignore next 4 */
+	crawlWithOptions(root, options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		return new APIBuilder(root || ".", this.options);
+	}
+	glob(...patterns) {
+		if (this.globFunction) return this.globWithOptions(patterns);
+		return this.globWithOptions(patterns, ...[{ dot: true }]);
+	}
+	globWithOptions(patterns, ...options) {
+		const globFn = this.globFunction || pm;
+		/* c8 ignore next 5 */
+		if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
+		var isMatch = this.globCache[patterns.join("\0")];
+		if (!isMatch) {
+			isMatch = globFn(patterns, ...options);
+			this.globCache[patterns.join("\0")] = isMatch;
+		}
+		this.options.filters.push((path) => isMatch(path));
+		return this;
+	}
+};
+
+//#endregion
+export { Builder as fdir };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/package.json
new file mode 100644
index 0000000..e229dff
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/fdir/package.json
@@ -0,0 +1,103 @@
+{
+  "name": "fdir",
+  "version": "6.5.0",
+  "description": "The fastest directory crawler & globbing alternative to glob, fast-glob, & tiny-glob. Crawls 1m files in < 1s",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
+  "type": "module",
+  "scripts": {
+    "prepublishOnly": "npm run test && npm run build",
+    "build": "tsdown",
+    "format": "prettier --write src __tests__ benchmarks",
+    "test": "vitest run __tests__/",
+    "test:coverage": "vitest run --coverage __tests__/",
+    "test:watch": "vitest __tests__/",
+    "bench": "ts-node benchmarks/benchmark.js",
+    "bench:glob": "ts-node benchmarks/glob-benchmark.ts",
+    "bench:fdir": "ts-node benchmarks/fdir-benchmark.ts",
+    "release": "./scripts/release.sh"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thecodrr/fdir.git"
+  },
+  "keywords": [
+    "util",
+    "os",
+    "sys",
+    "fs",
+    "walk",
+    "crawler",
+    "directory",
+    "files",
+    "io",
+    "tiny-glob",
+    "glob",
+    "fast-glob",
+    "speed",
+    "javascript",
+    "nodejs"
+  ],
+  "author": "thecodrr <thecodrr@protonmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thecodrr/fdir/issues"
+  },
+  "homepage": "https://github.com/thecodrr/fdir#readme",
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/mock-fs": "^4.13.4",
+    "@types/node": "^20.9.4",
+    "@types/picomatch": "^4.0.0",
+    "@types/tap": "^15.0.11",
+    "@vitest/coverage-v8": "^0.34.6",
+    "all-files-in-tree": "^1.1.2",
+    "benny": "^3.7.1",
+    "csv-to-markdown-table": "^1.3.1",
+    "expect": "^29.7.0",
+    "fast-glob": "^3.3.2",
+    "fdir1": "npm:fdir@1.2.0",
+    "fdir2": "npm:fdir@2.1.0",
+    "fdir3": "npm:fdir@3.4.2",
+    "fdir4": "npm:fdir@4.1.0",
+    "fdir5": "npm:fdir@5.0.0",
+    "fs-readdir-recursive": "^1.1.0",
+    "get-all-files": "^4.1.0",
+    "glob": "^10.3.10",
+    "klaw-sync": "^6.0.0",
+    "mock-fs": "^5.2.0",
+    "picomatch": "^4.0.2",
+    "prettier": "^3.5.3",
+    "recur-readdir": "0.0.1",
+    "recursive-files": "^1.0.2",
+    "recursive-fs": "^2.1.0",
+    "recursive-readdir": "^2.2.3",
+    "rrdir": "^12.1.0",
+    "systeminformation": "^5.21.17",
+    "tiny-glob": "^0.2.9",
+    "ts-node": "^10.9.1",
+    "tsdown": "^0.12.5",
+    "typescript": "^5.3.2",
+    "vitest": "^0.34.6",
+    "walk-sync": "^3.0.0"
+  },
+  "peerDependencies": {
+    "picomatch": "^3 || ^4"
+  },
+  "peerDependenciesMeta": {
+    "picomatch": {
+      "optional": true
+    }
+  },
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/LICENSE
new file mode 100644
index 0000000..89fe5b2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/LICENSE
@@ -0,0 +1,373 @@
+ Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+means each individual or legal entity that creates, contributes to
+the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+means the combination of the Contributions of others (if any) used
+by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+means Source Code Form to which the initial Contributor has attached
+the notice in Exhibit A, the Executable Form of such Source Code
+Form, and Modifications of such Source Code Form, in each case
+including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+means
+
+(a) that the initial Contributor has attached the notice described
+in Exhibit B to the Covered Software; or
+
+(b) that the Covered Software was made available under the terms of
+version 1.1 or earlier of the License, but not also under the
+terms of a Secondary License.
+
+1.6. "Executable Form"
+means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+means a work that combines Covered Software with other material, in
+a separate file or files, that is not Covered Software.
+
+1.8. "License"
+means this document.
+
+1.9. "Licensable"
+means having the right to grant, to the maximum extent possible,
+whether at the time of the initial grant or subsequently, any and
+all of the rights conveyed by this License.
+
+1.10. "Modifications"
+means any of the following:
+
+(a) any file in Source Code Form that results from an addition to,
+deletion from, or modification of the contents of Covered
+Software; or
+
+(b) any new file in Source Code Form that contains any Covered
+Software.
+
+1.11. "Patent Claims" of a Contributor
+means any patent claim(s), including without limitation, method,
+process, and apparatus claims, in any patent Licensable by such
+Contributor that would be infringed, but for the grant of the
+License, by the making, using, selling, offering for sale, having
+made, import, or transfer of either its Contributions or its
+Contributor Version.
+
+1.12. "Secondary License"
+means either the GNU General Public License, Version 2.0, the GNU
+Lesser General Public License, Version 2.1, the GNU Affero General
+Public License, Version 3.0, or any later versions of those
+licenses.
+
+1.13. "Source Code Form"
+means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+means an individual or a legal entity exercising rights under this
+License. For legal entities, "You" includes any entity that
+controls, is controlled by, or is under common control with You. For
+purposes of this definition, "control" means (a) the power, direct
+or indirect, to cause the direction or management of such entity,
+whether by contract or otherwise, or (b) ownership of more than
+fifty percent (50%) of the outstanding shares or beneficial
+ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+Licensable by such Contributor to use, reproduce, make available,
+modify, display, perform, distribute, and otherwise exploit its
+Contributions, either on an unmodified basis, with Modifications, or
+as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+for sale, have made, import, and otherwise transfer either its
+Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+or
+
+(b) for infringements caused by: (i) Your and any other third party's
+modifications of Covered Software, or (ii) the combination of its
+Contributions with other software (except as part of its Contributor
+Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+Form, as described in Section 3.1, and You must inform recipients of
+the Executable Form how they can obtain a copy of such Source Code
+Form by reasonable means in a timely manner, at a charge no more
+than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+License, or sublicense it under different terms, provided that the
+license for the Executable Form does not attempt to limit or alter
+the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+* *
+* 6. Disclaimer of Warranty *
+* ------------------------- *
+* *
+* Covered Software is provided under this License on an "as is" *
+* basis, without warranty of any kind, either expressed, implied, or *
+* statutory, including, without limitation, warranties that the *
+* Covered Software is free of defects, merchantable, fit for a *
+* particular purpose or non-infringing. The entire risk as to the *
+* quality and performance of the Covered Software is with You. *
+* Should any Covered Software prove defective in any respect, You *
+* (not any Contributor) assume the cost of any necessary servicing, *
+* repair, or correction. This disclaimer of warranty constitutes an *
+* essential part of this License. No use of any Covered Software is *
+* authorized under this License except under this disclaimer. *
+* *
+************************************************************************
+
+************************************************************************
+* *
+* 7. Limitation of Liability *
+* -------------------------- *
+* *
+* Under no circumstances and under no legal theory, whether tort *
+* (including negligence), contract, or otherwise, shall any *
+* Contributor, or anyone who distributes Covered Software as *
+* permitted above, be liable to You for any direct, indirect, *
+* special, incidental, or consequential damages of any character *
+* including, without limitation, damages for lost profits, loss of *
+* goodwill, work stoppage, computer failure or malfunction, or any *
+* and all other commercial damages or losses, even if such party *
+* shall have been informed of the possibility of such damages. This *
+* limitation of liability shall not apply to liability for death or *
+* personal injury resulting from such party's negligence to the *
+* extent applicable law prohibits such limitation. Some *
+* jurisdictions do not allow the exclusion or limitation of *
+* incidental or consequential damages, so this exclusion and *
+* limitation may not apply to You. *
+* *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+This Source Code Form is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+This Source Code Form is "Incompatible With Secondary Licenses", as
+defined by the Mozilla Public License, v. 2.0.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/README.md
new file mode 100644
index 0000000..71b8938
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/README.md
@@ -0,0 +1 @@
+This is the x86_64-pc-windows-msvc build of lightningcss. See https://github.com/parcel-bundler/lightningcss for details.
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/lightningcss.win32-x64-msvc.node b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/lightningcss.win32-x64-msvc.node
new file mode 100644
index 0000000..ab1e99d
Binary files /dev/null and b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/lightningcss.win32-x64-msvc.node differ
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/package.json
new file mode 100644
index 0000000..ab27506
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss-win32-x64-msvc/package.json
@@ -0,0 +1,34 @@
+{
+  "name": "lightningcss-win32-x64-msvc",
+  "version": "1.32.0",
+  "license": "MPL-2.0",
+  "description": "A CSS parser, transformer, and minifier written in Rust",
+  "main": "lightningcss.win32-x64-msvc.node",
+  "browserslist": "last 2 versions, not dead",
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/lightningcss.git"
+  },
+  "engines": {
+    "node": ">= 12.0.0"
+  },
+  "files": [
+    "lightningcss.win32-x64-msvc.node"
+  ],
+  "resolutions": {
+    "lightningcss": "link:."
+  },
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/LICENSE
new file mode 100644
index 0000000..89fe5b2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/LICENSE
@@ -0,0 +1,373 @@
+ Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+means each individual or legal entity that creates, contributes to
+the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+means the combination of the Contributions of others (if any) used
+by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+means Source Code Form to which the initial Contributor has attached
+the notice in Exhibit A, the Executable Form of such Source Code
+Form, and Modifications of such Source Code Form, in each case
+including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+means
+
+(a) that the initial Contributor has attached the notice described
+in Exhibit B to the Covered Software; or
+
+(b) that the Covered Software was made available under the terms of
+version 1.1 or earlier of the License, but not also under the
+terms of a Secondary License.
+
+1.6. "Executable Form"
+means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+means a work that combines Covered Software with other material, in
+a separate file or files, that is not Covered Software.
+
+1.8. "License"
+means this document.
+
+1.9. "Licensable"
+means having the right to grant, to the maximum extent possible,
+whether at the time of the initial grant or subsequently, any and
+all of the rights conveyed by this License.
+
+1.10. "Modifications"
+means any of the following:
+
+(a) any file in Source Code Form that results from an addition to,
+deletion from, or modification of the contents of Covered
+Software; or
+
+(b) any new file in Source Code Form that contains any Covered
+Software.
+
+1.11. "Patent Claims" of a Contributor
+means any patent claim(s), including without limitation, method,
+process, and apparatus claims, in any patent Licensable by such
+Contributor that would be infringed, but for the grant of the
+License, by the making, using, selling, offering for sale, having
+made, import, or transfer of either its Contributions or its
+Contributor Version.
+
+1.12. "Secondary License"
+means either the GNU General Public License, Version 2.0, the GNU
+Lesser General Public License, Version 2.1, the GNU Affero General
+Public License, Version 3.0, or any later versions of those
+licenses.
+
+1.13. "Source Code Form"
+means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+means an individual or a legal entity exercising rights under this
+License. For legal entities, "You" includes any entity that
+controls, is controlled by, or is under common control with You. For
+purposes of this definition, "control" means (a) the power, direct
+or indirect, to cause the direction or management of such entity,
+whether by contract or otherwise, or (b) ownership of more than
+fifty percent (50%) of the outstanding shares or beneficial
+ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+Licensable by such Contributor to use, reproduce, make available,
+modify, display, perform, distribute, and otherwise exploit its
+Contributions, either on an unmodified basis, with Modifications, or
+as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+for sale, have made, import, and otherwise transfer either its
+Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+or
+
+(b) for infringements caused by: (i) Your and any other third party's
+modifications of Covered Software, or (ii) the combination of its
+Contributions with other software (except as part of its Contributor
+Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+Form, as described in Section 3.1, and You must inform recipients of
+the Executable Form how they can obtain a copy of such Source Code
+Form by reasonable means in a timely manner, at a charge no more
+than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+License, or sublicense it under different terms, provided that the
+license for the Executable Form does not attempt to limit or alter
+the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+* *
+* 6. Disclaimer of Warranty *
+* ------------------------- *
+* *
+* Covered Software is provided under this License on an "as is" *
+* basis, without warranty of any kind, either expressed, implied, or *
+* statutory, including, without limitation, warranties that the *
+* Covered Software is free of defects, merchantable, fit for a *
+* particular purpose or non-infringing. The entire risk as to the *
+* quality and performance of the Covered Software is with You. *
+* Should any Covered Software prove defective in any respect, You *
+* (not any Contributor) assume the cost of any necessary servicing, *
+* repair, or correction. This disclaimer of warranty constitutes an *
+* essential part of this License. No use of any Covered Software is *
+* authorized under this License except under this disclaimer. *
+* *
+************************************************************************
+
+************************************************************************
+* *
+* 7. Limitation of Liability *
+* -------------------------- *
+* *
+* Under no circumstances and under no legal theory, whether tort *
+* (including negligence), contract, or otherwise, shall any *
+* Contributor, or anyone who distributes Covered Software as *
+* permitted above, be liable to You for any direct, indirect, *
+* special, incidental, or consequential damages of any character *
+* including, without limitation, damages for lost profits, loss of *
+* goodwill, work stoppage, computer failure or malfunction, or any *
+* and all other commercial damages or losses, even if such party *
+* shall have been informed of the possibility of such damages. This *
+* limitation of liability shall not apply to liability for death or *
+* personal injury resulting from such party's negligence to the *
+* extent applicable law prohibits such limitation. Some *
+* jurisdictions do not allow the exclusion or limitation of *
+* incidental or consequential damages, so this exclusion and *
+* limitation may not apply to You. *
+* *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+This Source Code Form is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+This Source Code Form is "Incompatible With Secondary Licenses", as
+defined by the Mozilla Public License, v. 2.0.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/README.md
new file mode 100644
index 0000000..f44d7b3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/README.md
@@ -0,0 +1,105 @@
+# ⚡️ Lightning CSS
+
+An extremely fast CSS parser, transformer, and minifier written in Rust. Use it with [Parcel](https://parceljs.org), as a standalone library or CLI, or via a plugin with any other tool.
+
+<img width="680" alt="performance and build size charts" src="https://user-images.githubusercontent.com/19409/189022599-28246659-f94a-46a4-9de0-b6d17adb0e22.png#gh-light-mode-only">
+<img width="680" alt="performance and build size charts" src="https://user-images.githubusercontent.com/19409/189022693-6956b044-422b-4f56-9628-d59c6f791095.png#gh-dark-mode-only">
+
+## Features
+
+- **Extremely fast** – Parsing and minifying large files is completed in milliseconds, often with significantly smaller output than other tools. See [benchmarks](#benchmarks) below.
+- **Typed property values** – many other CSS parsers treat property values as an untyped series of tokens. This means that each transformer that wants to do something with these values must interpret them itself, leading to duplicate work and inconsistencies. Lightning CSS parses all values using the grammar from the CSS specification, and exposes a specific value type for each property.
+- **Browser-grade parser** – Lightning CSS is built on the [cssparser](https://github.com/servo/rust-cssparser) and [selectors](https://github.com/servo/stylo/tree/main/selectors) crates created by Mozilla and used by Firefox and Servo. These provide a solid general purpose CSS-parsing foundation on top of which Lightning CSS implements support for all specific CSS rules and properties.
+- **Minification** – One of the main purposes of Lightning CSS is to minify CSS to make it smaller. This includes many optimizations including:
+  - Combining longhand properties into shorthands where possible.
+  - Merging adjacent rules with the same selectors or declarations when it is safe to do so.
+  - Combining CSS transforms into a single matrix or vice versa when smaller.
+  - Removing vendor prefixes that are not needed, based on the provided browser targets.
+  - Reducing `calc()` expressions where possible.
+  - Converting colors to shorter hex notation where possible.
+  - Minifying gradients.
+  - Minifying CSS grid templates.
+  - Normalizing property value order.
+  - Removing default property sub-values which will be inferred by browsers.
+  - Many micro-optimizations, e.g. converting to shorter units, removing unnecessary quotation marks, etc.
+- **Vendor prefixing** – Lightning CSS accepts a list of browser targets, and automatically adds (and removes) vendor prefixes.
+- **Browserslist configuration** – Lightning CSS supports opt-in browserslist configuration discovery to resolve browser targets and integrate with your existing tools and config setup.
+- **Syntax lowering** – Lightning CSS parses modern CSS syntax, and generates more compatible output where needed, based on browser targets.
+  - CSS Nesting
+  - Custom media queries (draft spec)
+  - Logical properties
+  * [Color Level 5](https://drafts.csswg.org/css-color-5/)
+    - `color-mix()` function
+    - Relative color syntax, e.g. `lab(from purple calc(l * .8) a b)`
+  - [Color Level 4](https://drafts.csswg.org/css-color-4/)
+    - `lab()`, `lch()`, `oklab()`, and `oklch()` colors
+    - `color()` function supporting predefined color spaces such as `display-p3` and `xyz`
+    - Space separated components in `rgb` and `hsl` functions
+    - Hex with alpha syntax
+    - `hwb()` color syntax
+    - Percent syntax for opacity
+    - `#rgba` and `#rrggbbaa` hex colors
+  - Selectors
+    - `:not` with multiple arguments
+    - `:lang` with multiple arguments
+    - `:dir`
+    - `:is`
+  - Double position gradient stops (e.g. `red 40% 80%`)
+  - `clamp()`, `round()`, `rem()`, and `mod()` math functions
+  - Alignment shorthands (e.g. `place-items`)
+  - Two-value `overflow` shorthand
+  - Media query range syntax (e.g. `@media (width <= 100px)` or `@media (100px < width < 500px)`)
+  - Multi-value `display` property (e.g. `inline flex`)
+  - `system-ui` font family fallbacks
+- **CSS modules** – Lightning CSS supports compiling a subset of [CSS modules](https://github.com/css-modules/css-modules) features.
+  - Locally scoped class and id selectors
+  - Locally scoped custom identifiers, e.g. `@keyframes` names, grid lines/areas, `@counter-style` names, etc.
+  - Opt-in support for locally scoped CSS variables and other dashed identifiers.
+  - `:local()` and `:global()` selectors
+  - The `composes` property
+- **Custom transforms** – The Lightning CSS visitor API can be used to implement custom transform plugins.
+
+## Documentation
+
+Lightning CSS can be used from [Parcel](https://parceljs.org), as a standalone library from JavaScript or Rust, using a standalone CLI, or wrapped as a plugin within any other tool. See the [Lightning CSS website](https://lightningcss.dev/docs.html) for documentation.
+
+## Benchmarks
+
+<img width="680" alt="performance and build size charts" src="https://user-images.githubusercontent.com/19409/189022599-28246659-f94a-46a4-9de0-b6d17adb0e22.png#gh-light-mode-only">
+<img width="680" alt="performance and build size charts" src="https://user-images.githubusercontent.com/19409/189022693-6956b044-422b-4f56-9628-d59c6f791095.png#gh-dark-mode-only">
+
+```
+$ node bench.js bootstrap-4.css
+cssnano: 544.809ms
+159636 bytes
+
+esbuild: 17.199ms
+160332 bytes
+
+lightningcss: 4.16ms
+143091 bytes
+
+
+$ node bench.js animate.css
+cssnano: 283.105ms
+71723 bytes
+
+esbuild: 11.858ms
+72183 bytes
+
+lightningcss: 1.973ms
+23666 bytes
+
+
+$ node bench.js tailwind.css
+cssnano: 2.198s
+1925626 bytes
+
+esbuild: 107.668ms
+1961642 bytes
+
+lightningcss: 43.368ms
+1824130 bytes
+```
+
+For more benchmarks comparing more tools and input, see [here](http://goalsmashers.github.io/css-minification-benchmark/). Note that some of the tools shown perform unsafe optimizations that may change the behavior of the original CSS in favor of smaller file size. Lightning CSS does not do this – the output CSS should always behave identically to the input. Keep this in mind when comparing file sizes between tools.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/ast.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/ast.d.ts
new file mode 100644
index 0000000..28e9d09
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/ast.d.ts
@@ -0,0 +1,9892 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+
+export type String = string;
+/**
+ * A CSS rule.
+ */
+export type Rule<D = Declaration, M = MediaQuery> = | {
+    type: "media";
+    value: MediaRule<D, M>;
+  }
+| {
+    type: "import";
+    value: ImportRule<M>;
+  }
+| {
+    type: "style";
+    value: StyleRule<D, M>;
+  }
+| {
+    type: "keyframes";
+    value: KeyframesRule<D>;
+  }
+| {
+    type: "font-face";
+    value: FontFaceRule;
+  }
+| {
+    type: "font-palette-values";
+    value: FontPaletteValuesRule;
+  }
+| {
+    type: "font-feature-values";
+    value: FontFeatureValuesRule;
+  }
+| {
+    type: "page";
+    value: PageRule<D>;
+  }
+| {
+    type: "supports";
+    value: SupportsRule<D, M>;
+  }
+| {
+    type: "counter-style";
+    value: CounterStyleRule<D>;
+  }
+| {
+    type: "namespace";
+    value: NamespaceRule;
+  }
+| {
+    type: "moz-document";
+    value: MozDocumentRule<D, M>;
+  }
+| {
+    type: "nesting";
+    value: NestingRule<D, M>;
+  }
+| {
+    type: "nested-declarations";
+    value: NestedDeclarationsRule<D>;
+  }
+| {
+    type: "viewport";
+    value: ViewportRule<D>;
+  }
+| {
+    type: "custom-media";
+    value: CustomMediaRule<M>;
+  }
+| {
+    type: "layer-statement";
+    value: LayerStatementRule;
+  }
+| {
+    type: "layer-block";
+    value: LayerBlockRule<D, M>;
+  }
+| {
+    type: "property";
+    value: PropertyRule;
+  }
+| {
+    type: "container";
+    value: ContainerRule<D, M>;
+  }
+| {
+    type: "scope";
+    value: ScopeRule<D, M>;
+  }
+| {
+    type: "starting-style";
+    value: StartingStyleRule<D, M>;
+  }
+| {
+    type: "view-transition";
+    value: ViewTransitionRule;
+  }
+| {
+    type: "ignored";
+  }
+| {
+    type: "unknown";
+    value: UnknownAtRule;
+  }
+| {
+    type: "custom";
+    value: DefaultAtRule;
+  };
+/**
+ * Represents a media condition.
+ */
+export type MediaCondition =
+  | {
+      type: "feature";
+      value: QueryFeatureFor_MediaFeatureId;
+    }
+  | {
+      type: "not";
+      value: MediaCondition;
+    }
+  | {
+      /**
+       * The conditions for the operator.
+       */
+      conditions: MediaCondition[];
+      /**
+       * The operator for the conditions.
+       */
+      operator: Operator;
+      type: "operation";
+    }
+  | {
+      type: "unknown";
+      value: TokenOrValue[];
+    };
+/**
+ * A generic media feature or container feature.
+ */
+export type QueryFeatureFor_MediaFeatureId =
+  | {
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_MediaFeatureId;
+      type: "plain";
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue;
+    }
+  | {
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_MediaFeatureId;
+      type: "boolean";
+    }
+  | {
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_MediaFeatureId;
+      /**
+       * A comparator.
+       */
+      operator: MediaFeatureComparison;
+      type: "range";
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue;
+    }
+  | {
+      /**
+       * The end value.
+       */
+      end: MediaFeatureValue;
+      /**
+       * A comparator for the end value.
+       */
+      endOperator: MediaFeatureComparison;
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_MediaFeatureId;
+      /**
+       * A start value.
+       */
+      start: MediaFeatureValue;
+      /**
+       * A comparator for the start value.
+       */
+      startOperator: MediaFeatureComparison;
+      type: "interval";
+    };
+/**
+ * A media feature name.
+ */
+export type MediaFeatureNameFor_MediaFeatureId = MediaFeatureId | String | String;
+/**
+ * A media query feature identifier.
+ */
+export type MediaFeatureId =
+  | "width"
+  | "height"
+  | "aspect-ratio"
+  | "orientation"
+  | "overflow-block"
+  | "overflow-inline"
+  | "horizontal-viewport-segments"
+  | "vertical-viewport-segments"
+  | "display-mode"
+  | "resolution"
+  | "scan"
+  | "grid"
+  | "update"
+  | "environment-blending"
+  | "color"
+  | "color-index"
+  | "monochrome"
+  | "color-gamut"
+  | "dynamic-range"
+  | "inverted-colors"
+  | "pointer"
+  | "hover"
+  | "any-pointer"
+  | "any-hover"
+  | "nav-controls"
+  | "video-color-gamut"
+  | "video-dynamic-range"
+  | "scripting"
+  | "prefers-reduced-motion"
+  | "prefers-reduced-transparency"
+  | "prefers-contrast"
+  | "forced-colors"
+  | "prefers-color-scheme"
+  | "prefers-reduced-data"
+  | "device-width"
+  | "device-height"
+  | "device-aspect-ratio"
+  | "-webkit-device-pixel-ratio"
+  | "-moz-device-pixel-ratio";
+/**
+ * [media feature value](https://drafts.csswg.org/mediaqueries/#typedef-mf-value) within a media query.
+ *
+ * See [MediaFeature](MediaFeature).
+ */
+export type MediaFeatureValue =
+  | {
+      type: "length";
+      value: Length;
+    }
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "integer";
+      value: number;
+    }
+  | {
+      type: "boolean";
+      value: boolean;
+    }
+  | {
+      type: "resolution";
+      value: Resolution;
+    }
+  | {
+      type: "ratio";
+      value: Ratio;
+    }
+  | {
+      type: "ident";
+      value: String;
+    }
+  | {
+      type: "env";
+      value: EnvironmentVariable;
+    };
+/**
+ * A CSS [`<length>`](https://www.w3.org/TR/css-values-4/#lengths) value, with support for `calc()`.
+ */
+export type Length =
+  | {
+      type: "value";
+      value: LengthValue;
+    }
+  | {
+      type: "calc";
+      value: CalcFor_Length;
+    };
+export type LengthUnit =
+  | "px"
+  | "in"
+  | "cm"
+  | "mm"
+  | "q"
+  | "pt"
+  | "pc"
+  | "em"
+  | "rem"
+  | "ex"
+  | "rex"
+  | "ch"
+  | "rch"
+  | "cap"
+  | "rcap"
+  | "ic"
+  | "ric"
+  | "lh"
+  | "rlh"
+  | "vw"
+  | "lvw"
+  | "svw"
+  | "dvw"
+  | "cqw"
+  | "vh"
+  | "lvh"
+  | "svh"
+  | "dvh"
+  | "cqh"
+  | "vi"
+  | "svi"
+  | "lvi"
+  | "dvi"
+  | "cqi"
+  | "vb"
+  | "svb"
+  | "lvb"
+  | "dvb"
+  | "cqb"
+  | "vmin"
+  | "svmin"
+  | "lvmin"
+  | "dvmin"
+  | "cqmin"
+  | "vmax"
+  | "svmax"
+  | "lvmax"
+  | "dvmax"
+  | "cqmax";
+/**
+ * A mathematical expression used within the [`calc()`](https://www.w3.org/TR/css-values-4/#calc-func) function.
+ *
+ * This type supports generic value types. Values such as [Length](super::length::Length), [Percentage](super::percentage::Percentage), [Time](super::time::Time), and [Angle](super::angle::Angle) support `calc()` expressions.
+ */
+export type CalcFor_Length =
+  | {
+      type: "value";
+      value: Length;
+    }
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "sum";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_Length, CalcFor_Length];
+    }
+  | {
+      type: "product";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [number, CalcFor_Length];
+    }
+  | {
+      type: "function";
+      value: MathFunctionFor_Length;
+    };
+/**
+ * A CSS [math function](https://www.w3.org/TR/css-values-4/#math-function).
+ *
+ * Math functions may be used in most properties and values that accept numeric values, including lengths, percentages, angles, times, etc.
+ */
+export type MathFunctionFor_Length =
+  | {
+      type: "calc";
+      value: CalcFor_Length;
+    }
+  | {
+      type: "min";
+      value: CalcFor_Length[];
+    }
+  | {
+      type: "max";
+      value: CalcFor_Length[];
+    }
+  | {
+      type: "clamp";
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [CalcFor_Length, CalcFor_Length, CalcFor_Length];
+    }
+  | {
+      type: "round";
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [RoundingStrategy, CalcFor_Length, CalcFor_Length];
+    }
+  | {
+      type: "rem";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_Length, CalcFor_Length];
+    }
+  | {
+      type: "mod";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_Length, CalcFor_Length];
+    }
+  | {
+      type: "abs";
+      value: CalcFor_Length;
+    }
+  | {
+      type: "sign";
+      value: CalcFor_Length;
+    }
+  | {
+      type: "hypot";
+      value: CalcFor_Length[];
+    };
+/**
+ * A [rounding strategy](https://www.w3.org/TR/css-values-4/#typedef-rounding-strategy), as used in the `round()` function.
+ */
+export type RoundingStrategy = "nearest" | "up" | "down" | "to-zero";
+/**
+ * A CSS [`<resolution>`](https://www.w3.org/TR/css-values-4/#resolution) value.
+ */
+export type Resolution =
+  | {
+      type: "dpi";
+      value: number;
+    }
+  | {
+      type: "dpcm";
+      value: number;
+    }
+  | {
+      type: "dppx";
+      value: number;
+    };
+/**
+ * A CSS [`<ratio>`](https://www.w3.org/TR/css-values-4/#ratios) value, representing the ratio of two numeric values.
+ *
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Ratio = [number, number];
+/**
+ * A raw CSS token, or a parsed value.
+ */
+export type TokenOrValue =
+  | {
+      type: "token";
+      value: Token;
+    }
+  | {
+      type: "color";
+      value: CssColor;
+    }
+  | {
+      type: "unresolved-color";
+      value: UnresolvedColor;
+    }
+  | {
+      type: "url";
+      value: Url;
+    }
+  | {
+      type: "var";
+      value: Variable;
+    }
+  | {
+      type: "env";
+      value: EnvironmentVariable;
+    }
+  | {
+      type: "function";
+      value: Function;
+    }
+  | {
+      type: "length";
+      value: LengthValue;
+    }
+  | {
+      type: "angle";
+      value: Angle;
+    }
+  | {
+      type: "time";
+      value: Time;
+    }
+  | {
+      type: "resolution";
+      value: Resolution;
+    }
+  | {
+      type: "dashed-ident";
+      value: String;
+    }
+  | {
+      type: "animation-name";
+      value: AnimationName;
+    };
+/**
+ * A raw CSS token.
+ */
+export type Token =
+  | {
+      type: "ident";
+      value: String;
+    }
+  | {
+      type: "at-keyword";
+      value: String;
+    }
+  | {
+      type: "hash";
+      value: String;
+    }
+  | {
+      type: "id-hash";
+      value: String;
+    }
+  | {
+      type: "string";
+      value: String;
+    }
+  | {
+      type: "unquoted-url";
+      value: String;
+    }
+  | {
+      type: "delim";
+      value: string;
+    }
+  | {
+      type: "number";
+      /**
+       * The value as a float
+       */
+      value: number;
+    }
+  | {
+      type: "percentage";
+      /**
+       * The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0.
+       */
+      value: number;
+    }
+  | {
+      type: "dimension";
+      /**
+       * The unit, e.g. "px" in `12px`
+       */
+      unit: String;
+      /**
+       * The value as a float
+       */
+      value: number;
+    }
+  | {
+      type: "white-space";
+      value: String;
+    }
+  | {
+      type: "comment";
+      value: String;
+    }
+  | {
+      type: "colon";
+    }
+  | {
+      type: "semicolon";
+    }
+  | {
+      type: "comma";
+    }
+  | {
+      type: "include-match";
+    }
+  | {
+      type: "dash-match";
+    }
+  | {
+      type: "prefix-match";
+    }
+  | {
+      type: "suffix-match";
+    }
+  | {
+      type: "substring-match";
+    }
+  | {
+      type: "cdo";
+    }
+  | {
+      type: "cdc";
+    }
+  | {
+      type: "function";
+      value: String;
+    }
+  | {
+      type: "parenthesis-block";
+    }
+  | {
+      type: "square-bracket-block";
+    }
+  | {
+      type: "curly-bracket-block";
+    }
+  | {
+      type: "bad-url";
+      value: String;
+    }
+  | {
+      type: "bad-string";
+      value: String;
+    }
+  | {
+      type: "close-parenthesis";
+    }
+  | {
+      type: "close-square-bracket";
+    }
+  | {
+      type: "close-curly-bracket";
+    };
+/**
+ * A CSS [`<color>`](https://www.w3.org/TR/css-color-4/#color-type) value.
+ *
+ * CSS supports many different color spaces to represent colors. The most common values are stored as RGBA using a single byte per component. Less common values are stored using a `Box` to reduce the amount of memory used per color.
+ *
+ * Each color space is represented as a struct that implements the `From` and `Into` traits for all other color spaces, so it is possible to convert between color spaces easily. In addition, colors support [interpolation](#method.interpolate) as in the `color-mix()` function.
+ */
+export type CssColor = CurrentColor | RGBColor | LABColor | PredefinedColor | FloatColor | LightDark | SystemColor;
+export type CurrentColor = {
+  type: "currentcolor";
+};
+export type RGBColor = {
+  /**
+   * The alpha component.
+   */
+  alpha: number;
+  /**
+   * The blue component.
+   */
+  b: number;
+  /**
+   * The green component.
+   */
+  g: number;
+  /**
+   * The red component.
+   */
+  r: number;
+  type: "rgb";
+};
+/**
+ * A color in a LAB color space, including the `lab()`, `lch()`, `oklab()`, and `oklch()` functions.
+ */
+export type LABColor =
+  | {
+      /**
+       * The a component.
+       */
+      a: number;
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The b component.
+       */
+      b: number;
+      /**
+       * The lightness component.
+       */
+      l: number;
+      type: "lab";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The chroma component.
+       */
+      c: number;
+      /**
+       * The hue component.
+       */
+      h: number;
+      /**
+       * The lightness component.
+       */
+      l: number;
+      type: "lch";
+    }
+  | {
+      /**
+       * The a component.
+       */
+      a: number;
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The b component.
+       */
+      b: number;
+      /**
+       * The lightness component.
+       */
+      l: number;
+      type: "oklab";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The chroma component.
+       */
+      c: number;
+      /**
+       * The hue component.
+       */
+      h: number;
+      /**
+       * The lightness component.
+       */
+      l: number;
+      type: "oklch";
+    };
+/**
+ * A color in a predefined color space, e.g. `display-p3`.
+ */
+export type PredefinedColor =
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The blue component.
+       */
+      b: number;
+      /**
+       * The green component.
+       */
+      g: number;
+      /**
+       * The red component.
+       */
+      r: number;
+      type: "srgb";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The blue component.
+       */
+      b: number;
+      /**
+       * The green component.
+       */
+      g: number;
+      /**
+       * The red component.
+       */
+      r: number;
+      type: "srgb-linear";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The blue component.
+       */
+      b: number;
+      /**
+       * The green component.
+       */
+      g: number;
+      /**
+       * The red component.
+       */
+      r: number;
+      type: "display-p3";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The blue component.
+       */
+      b: number;
+      /**
+       * The green component.
+       */
+      g: number;
+      /**
+       * The red component.
+       */
+      r: number;
+      type: "a98-rgb";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The blue component.
+       */
+      b: number;
+      /**
+       * The green component.
+       */
+      g: number;
+      /**
+       * The red component.
+       */
+      r: number;
+      type: "prophoto-rgb";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The blue component.
+       */
+      b: number;
+      /**
+       * The green component.
+       */
+      g: number;
+      /**
+       * The red component.
+       */
+      r: number;
+      type: "rec2020";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      type: "xyz-d50";
+      /**
+       * The x component.
+       */
+      x: number;
+      /**
+       * The y component.
+       */
+      y: number;
+      /**
+       * The z component.
+       */
+      z: number;
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      type: "xyz-d65";
+      /**
+       * The x component.
+       */
+      x: number;
+      /**
+       * The y component.
+       */
+      y: number;
+      /**
+       * The z component.
+       */
+      z: number;
+    };
+/**
+ * A floating point representation of color types that are usually stored as RGBA. These are used when there are any `none` components, which are represented as NaN.
+ */
+export type FloatColor =
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The blue component.
+       */
+      b: number;
+      /**
+       * The green component.
+       */
+      g: number;
+      /**
+       * The red component.
+       */
+      r: number;
+      type: "rgb";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The hue component.
+       */
+      h: number;
+      /**
+       * The lightness component.
+       */
+      l: number;
+      /**
+       * The saturation component.
+       */
+      s: number;
+      type: "hsl";
+    }
+  | {
+      /**
+       * The alpha component.
+       */
+      alpha: number;
+      /**
+       * The blackness component.
+       */
+      b: number;
+      /**
+       * The hue component.
+       */
+      h: number;
+      type: "hwb";
+      /**
+       * The whiteness component.
+       */
+      w: number;
+    };
+export type LightDark = {
+  dark: CssColor;
+  light: CssColor;
+  type: "light-dark";
+};
+/**
+ * A CSS [system color](https://drafts.csswg.org/css-color/#css-system-colors) keyword.
+ */
+export type SystemColor =
+  | "accentcolor"
+  | "accentcolortext"
+  | "activetext"
+  | "buttonborder"
+  | "buttonface"
+  | "buttontext"
+  | "canvas"
+  | "canvastext"
+  | "field"
+  | "fieldtext"
+  | "graytext"
+  | "highlight"
+  | "highlighttext"
+  | "linktext"
+  | "mark"
+  | "marktext"
+  | "selecteditem"
+  | "selecteditemtext"
+  | "visitedtext"
+  | "activeborder"
+  | "activecaption"
+  | "appworkspace"
+  | "background"
+  | "buttonhighlight"
+  | "buttonshadow"
+  | "captiontext"
+  | "inactiveborder"
+  | "inactivecaption"
+  | "inactivecaptiontext"
+  | "infobackground"
+  | "infotext"
+  | "menu"
+  | "menutext"
+  | "scrollbar"
+  | "threeddarkshadow"
+  | "threedface"
+  | "threedhighlight"
+  | "threedlightshadow"
+  | "threedshadow"
+  | "window"
+  | "windowframe"
+  | "windowtext";
+/**
+ * A color value with an unresolved alpha value (e.g. a variable). These can be converted from the modern slash syntax to older comma syntax. This can only be done when the only unresolved component is the alpha since variables can resolve to multiple tokens.
+ */
+export type UnresolvedColor =
+  | {
+      /**
+       * The unresolved alpha component.
+       */
+      alpha: TokenOrValue[];
+      /**
+       * The blue component.
+       */
+      b: number;
+      /**
+       * The green component.
+       */
+      g: number;
+      /**
+       * The red component.
+       */
+      r: number;
+      type: "rgb";
+    }
+  | {
+      /**
+       * The unresolved alpha component.
+       */
+      alpha: TokenOrValue[];
+      /**
+       * The hue component.
+       */
+      h: number;
+      /**
+       * The lightness component.
+       */
+      l: number;
+      /**
+       * The saturation component.
+       */
+      s: number;
+      type: "hsl";
+    }
+  | {
+      /**
+       * The dark value.
+       */
+      dark: TokenOrValue[];
+      /**
+       * The light value.
+       */
+      light: TokenOrValue[];
+      type: "light-dark";
+    };
+/**
+ * Defines where the class names referenced in the `composes` property are located.
+ *
+ * See [Composes](Composes).
+ */
+export type Specifier =
+  | {
+      type: "global";
+    }
+  | {
+      type: "file";
+      value: String;
+    }
+  | {
+      type: "source-index";
+      value: number;
+    };
+/**
+ * A CSS [`<angle>`](https://www.w3.org/TR/css-values-4/#angles) value.
+ *
+ * Angles may be explicit or computed by `calc()`, but are always stored and serialized as their computed value.
+ */
+export type Angle =
+  | {
+      type: "deg";
+      value: number;
+    }
+  | {
+      type: "rad";
+      value: number;
+    }
+  | {
+      type: "grad";
+      value: number;
+    }
+  | {
+      type: "turn";
+      value: number;
+    };
+/**
+ * A CSS [`<time>`](https://www.w3.org/TR/css-values-4/#time) value, in either seconds or milliseconds.
+ *
+ * Time values may be explicit or computed by `calc()`, but are always stored and serialized as their computed value.
+ */
+export type Time =
+  | {
+      type: "seconds";
+      value: number;
+    }
+  | {
+      type: "milliseconds";
+      value: number;
+    };
+/**
+ * A value for the [animation-name](https://drafts.csswg.org/css-animations/#animation-name) property.
+ */
+export type AnimationName =
+  | {
+      type: "none";
+    }
+  | {
+      type: "ident";
+      value: String;
+    }
+  | {
+      type: "string";
+      value: String;
+    };
+/**
+ * A CSS environment variable name.
+ */
+export type EnvironmentVariableName =
+  | {
+      type: "ua";
+      value: UAEnvironmentVariable;
+    }
+  | {
+      /**
+       * CSS modules extension: the filename where the variable is defined. Only enabled when the CSS modules `dashed_idents` option is turned on.
+       */
+      from?: Specifier | null;
+      /**
+       * The referenced identifier.
+       */
+      ident: String;
+      type: "custom";
+    }
+  | {
+      type: "unknown";
+      value: String;
+    };
+/**
+ * A UA-defined environment variable name.
+ */
+export type UAEnvironmentVariable =
+  | "safe-area-inset-top"
+  | "safe-area-inset-right"
+  | "safe-area-inset-bottom"
+  | "safe-area-inset-left"
+  | "viewport-segment-width"
+  | "viewport-segment-height"
+  | "viewport-segment-top"
+  | "viewport-segment-left"
+  | "viewport-segment-bottom"
+  | "viewport-segment-right";
+/**
+ * A [comparator](https://drafts.csswg.org/mediaqueries/#typedef-mf-comparison) within a media query.
+ */
+export type MediaFeatureComparison = "equal" | "greater-than" | "greater-than-equal" | "less-than" | "less-than-equal";
+/**
+ * A binary `and` or `or` operator.
+ */
+export type Operator = "and" | "or";
+export type MediaType = string;
+/**
+ * A [media query qualifier](https://drafts.csswg.org/mediaqueries/#mq-prefix).
+ */
+export type Qualifier = "only" | "not";
+/**
+ * A [`<supports-condition>`](https://drafts.csswg.org/css-conditional-3/#typedef-supports-condition), as used in the `@supports` and `@import` rules.
+ */
+export type SupportsCondition =
+  | {
+      type: "not";
+      value: SupportsCondition;
+    }
+  | {
+      type: "and";
+      value: SupportsCondition[];
+    }
+  | {
+      type: "or";
+      value: SupportsCondition[];
+    }
+  | {
+      /**
+       * The property id for the declaration.
+       */
+      propertyId: PropertyId;
+      type: "declaration";
+      /**
+       * The raw value of the declaration.
+       */
+      value: String;
+    }
+  | {
+      type: "selector";
+      value: String;
+    }
+  | {
+      type: "unknown";
+      value: String;
+    };
+export type PropertyId =
+  | {
+      property: "background-color";
+    }
+  | {
+      property: "background-image";
+    }
+  | {
+      property: "background-position-x";
+    }
+  | {
+      property: "background-position-y";
+    }
+  | {
+      property: "background-position";
+    }
+  | {
+      property: "background-size";
+    }
+  | {
+      property: "background-repeat";
+    }
+  | {
+      property: "background-attachment";
+    }
+  | {
+      property: "background-clip";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "background-origin";
+    }
+  | {
+      property: "background";
+    }
+  | {
+      property: "box-shadow";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "opacity";
+    }
+  | {
+      property: "color";
+    }
+  | {
+      property: "display";
+    }
+  | {
+      property: "visibility";
+    }
+  | {
+      property: "width";
+    }
+  | {
+      property: "height";
+    }
+  | {
+      property: "min-width";
+    }
+  | {
+      property: "min-height";
+    }
+  | {
+      property: "max-width";
+    }
+  | {
+      property: "max-height";
+    }
+  | {
+      property: "block-size";
+    }
+  | {
+      property: "inline-size";
+    }
+  | {
+      property: "min-block-size";
+    }
+  | {
+      property: "min-inline-size";
+    }
+  | {
+      property: "max-block-size";
+    }
+  | {
+      property: "max-inline-size";
+    }
+  | {
+      property: "box-sizing";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "aspect-ratio";
+    }
+  | {
+      property: "overflow";
+    }
+  | {
+      property: "overflow-x";
+    }
+  | {
+      property: "overflow-y";
+    }
+  | {
+      property: "text-overflow";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "position";
+    }
+  | {
+      property: "top";
+    }
+  | {
+      property: "bottom";
+    }
+  | {
+      property: "left";
+    }
+  | {
+      property: "right";
+    }
+  | {
+      property: "inset-block-start";
+    }
+  | {
+      property: "inset-block-end";
+    }
+  | {
+      property: "inset-inline-start";
+    }
+  | {
+      property: "inset-inline-end";
+    }
+  | {
+      property: "inset-block";
+    }
+  | {
+      property: "inset-inline";
+    }
+  | {
+      property: "inset";
+    }
+  | {
+      property: "border-spacing";
+    }
+  | {
+      property: "border-top-color";
+    }
+  | {
+      property: "border-bottom-color";
+    }
+  | {
+      property: "border-left-color";
+    }
+  | {
+      property: "border-right-color";
+    }
+  | {
+      property: "border-block-start-color";
+    }
+  | {
+      property: "border-block-end-color";
+    }
+  | {
+      property: "border-inline-start-color";
+    }
+  | {
+      property: "border-inline-end-color";
+    }
+  | {
+      property: "border-top-style";
+    }
+  | {
+      property: "border-bottom-style";
+    }
+  | {
+      property: "border-left-style";
+    }
+  | {
+      property: "border-right-style";
+    }
+  | {
+      property: "border-block-start-style";
+    }
+  | {
+      property: "border-block-end-style";
+    }
+  | {
+      property: "border-inline-start-style";
+    }
+  | {
+      property: "border-inline-end-style";
+    }
+  | {
+      property: "border-top-width";
+    }
+  | {
+      property: "border-bottom-width";
+    }
+  | {
+      property: "border-left-width";
+    }
+  | {
+      property: "border-right-width";
+    }
+  | {
+      property: "border-block-start-width";
+    }
+  | {
+      property: "border-block-end-width";
+    }
+  | {
+      property: "border-inline-start-width";
+    }
+  | {
+      property: "border-inline-end-width";
+    }
+  | {
+      property: "border-top-left-radius";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-top-right-radius";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-bottom-left-radius";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-bottom-right-radius";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-start-start-radius";
+    }
+  | {
+      property: "border-start-end-radius";
+    }
+  | {
+      property: "border-end-start-radius";
+    }
+  | {
+      property: "border-end-end-radius";
+    }
+  | {
+      property: "border-radius";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-image-source";
+    }
+  | {
+      property: "border-image-outset";
+    }
+  | {
+      property: "border-image-repeat";
+    }
+  | {
+      property: "border-image-width";
+    }
+  | {
+      property: "border-image-slice";
+    }
+  | {
+      property: "border-image";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-color";
+    }
+  | {
+      property: "border-style";
+    }
+  | {
+      property: "border-width";
+    }
+  | {
+      property: "border-block-color";
+    }
+  | {
+      property: "border-block-style";
+    }
+  | {
+      property: "border-block-width";
+    }
+  | {
+      property: "border-inline-color";
+    }
+  | {
+      property: "border-inline-style";
+    }
+  | {
+      property: "border-inline-width";
+    }
+  | {
+      property: "border";
+    }
+  | {
+      property: "border-top";
+    }
+  | {
+      property: "border-bottom";
+    }
+  | {
+      property: "border-left";
+    }
+  | {
+      property: "border-right";
+    }
+  | {
+      property: "border-block";
+    }
+  | {
+      property: "border-block-start";
+    }
+  | {
+      property: "border-block-end";
+    }
+  | {
+      property: "border-inline";
+    }
+  | {
+      property: "border-inline-start";
+    }
+  | {
+      property: "border-inline-end";
+    }
+  | {
+      property: "outline";
+    }
+  | {
+      property: "outline-color";
+    }
+  | {
+      property: "outline-style";
+    }
+  | {
+      property: "outline-width";
+    }
+  | {
+      property: "flex-direction";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-wrap";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-flow";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-grow";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-shrink";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-basis";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "order";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "align-content";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "justify-content";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "place-content";
+    }
+  | {
+      property: "align-self";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "justify-self";
+    }
+  | {
+      property: "place-self";
+    }
+  | {
+      property: "align-items";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "justify-items";
+    }
+  | {
+      property: "place-items";
+    }
+  | {
+      property: "row-gap";
+    }
+  | {
+      property: "column-gap";
+    }
+  | {
+      property: "gap";
+    }
+  | {
+      property: "box-orient";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-direction";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-ordinal-group";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-align";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-flex";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-flex-group";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-pack";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-lines";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-pack";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-order";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-align";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-item-align";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-line-pack";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-positive";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-negative";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-preferred-size";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "grid-template-columns";
+    }
+  | {
+      property: "grid-template-rows";
+    }
+  | {
+      property: "grid-auto-columns";
+    }
+  | {
+      property: "grid-auto-rows";
+    }
+  | {
+      property: "grid-auto-flow";
+    }
+  | {
+      property: "grid-template-areas";
+    }
+  | {
+      property: "grid-template";
+    }
+  | {
+      property: "grid";
+    }
+  | {
+      property: "grid-row-start";
+    }
+  | {
+      property: "grid-row-end";
+    }
+  | {
+      property: "grid-column-start";
+    }
+  | {
+      property: "grid-column-end";
+    }
+  | {
+      property: "grid-row";
+    }
+  | {
+      property: "grid-column";
+    }
+  | {
+      property: "grid-area";
+    }
+  | {
+      property: "margin-top";
+    }
+  | {
+      property: "margin-bottom";
+    }
+  | {
+      property: "margin-left";
+    }
+  | {
+      property: "margin-right";
+    }
+  | {
+      property: "margin-block-start";
+    }
+  | {
+      property: "margin-block-end";
+    }
+  | {
+      property: "margin-inline-start";
+    }
+  | {
+      property: "margin-inline-end";
+    }
+  | {
+      property: "margin-block";
+    }
+  | {
+      property: "margin-inline";
+    }
+  | {
+      property: "margin";
+    }
+  | {
+      property: "padding-top";
+    }
+  | {
+      property: "padding-bottom";
+    }
+  | {
+      property: "padding-left";
+    }
+  | {
+      property: "padding-right";
+    }
+  | {
+      property: "padding-block-start";
+    }
+  | {
+      property: "padding-block-end";
+    }
+  | {
+      property: "padding-inline-start";
+    }
+  | {
+      property: "padding-inline-end";
+    }
+  | {
+      property: "padding-block";
+    }
+  | {
+      property: "padding-inline";
+    }
+  | {
+      property: "padding";
+    }
+  | {
+      property: "scroll-margin-top";
+    }
+  | {
+      property: "scroll-margin-bottom";
+    }
+  | {
+      property: "scroll-margin-left";
+    }
+  | {
+      property: "scroll-margin-right";
+    }
+  | {
+      property: "scroll-margin-block-start";
+    }
+  | {
+      property: "scroll-margin-block-end";
+    }
+  | {
+      property: "scroll-margin-inline-start";
+    }
+  | {
+      property: "scroll-margin-inline-end";
+    }
+  | {
+      property: "scroll-margin-block";
+    }
+  | {
+      property: "scroll-margin-inline";
+    }
+  | {
+      property: "scroll-margin";
+    }
+  | {
+      property: "scroll-padding-top";
+    }
+  | {
+      property: "scroll-padding-bottom";
+    }
+  | {
+      property: "scroll-padding-left";
+    }
+  | {
+      property: "scroll-padding-right";
+    }
+  | {
+      property: "scroll-padding-block-start";
+    }
+  | {
+      property: "scroll-padding-block-end";
+    }
+  | {
+      property: "scroll-padding-inline-start";
+    }
+  | {
+      property: "scroll-padding-inline-end";
+    }
+  | {
+      property: "scroll-padding-block";
+    }
+  | {
+      property: "scroll-padding-inline";
+    }
+  | {
+      property: "scroll-padding";
+    }
+  | {
+      property: "font-weight";
+    }
+  | {
+      property: "font-size";
+    }
+  | {
+      property: "font-stretch";
+    }
+  | {
+      property: "font-family";
+    }
+  | {
+      property: "font-style";
+    }
+  | {
+      property: "font-variant-caps";
+    }
+  | {
+      property: "line-height";
+    }
+  | {
+      property: "font";
+    }
+  | {
+      property: "vertical-align";
+    }
+  | {
+      property: "font-palette";
+    }
+  | {
+      property: "transition-property";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transition-duration";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transition-delay";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transition-timing-function";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transition";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-name";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-duration";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-timing-function";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-iteration-count";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-direction";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-play-state";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-delay";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-fill-mode";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-composition";
+    }
+  | {
+      property: "animation-timeline";
+    }
+  | {
+      property: "animation-range-start";
+    }
+  | {
+      property: "animation-range-end";
+    }
+  | {
+      property: "animation-range";
+    }
+  | {
+      property: "animation";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transform";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transform-origin";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transform-style";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transform-box";
+    }
+  | {
+      property: "backface-visibility";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "perspective";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "perspective-origin";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "translate";
+    }
+  | {
+      property: "rotate";
+    }
+  | {
+      property: "scale";
+    }
+  | {
+      property: "text-transform";
+    }
+  | {
+      property: "white-space";
+    }
+  | {
+      property: "tab-size";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "word-break";
+    }
+  | {
+      property: "line-break";
+    }
+  | {
+      property: "hyphens";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "overflow-wrap";
+    }
+  | {
+      property: "word-wrap";
+    }
+  | {
+      property: "text-align";
+    }
+  | {
+      property: "text-align-last";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-justify";
+    }
+  | {
+      property: "word-spacing";
+    }
+  | {
+      property: "letter-spacing";
+    }
+  | {
+      property: "text-indent";
+    }
+  | {
+      property: "text-decoration-line";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-decoration-style";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-decoration-color";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-decoration-thickness";
+    }
+  | {
+      property: "text-decoration";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-decoration-skip-ink";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-emphasis-style";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-emphasis-color";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-emphasis";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-emphasis-position";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-shadow";
+    }
+  | {
+      property: "text-size-adjust";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "direction";
+    }
+  | {
+      property: "unicode-bidi";
+    }
+  | {
+      property: "box-decoration-break";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "resize";
+    }
+  | {
+      property: "cursor";
+    }
+  | {
+      property: "caret-color";
+    }
+  | {
+      property: "caret-shape";
+    }
+  | {
+      property: "caret";
+    }
+  | {
+      property: "user-select";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "accent-color";
+    }
+  | {
+      property: "appearance";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "list-style-type";
+    }
+  | {
+      property: "list-style-image";
+    }
+  | {
+      property: "list-style-position";
+    }
+  | {
+      property: "list-style";
+    }
+  | {
+      property: "marker-side";
+    }
+  | {
+      property: "composes";
+    }
+  | {
+      property: "fill";
+    }
+  | {
+      property: "fill-rule";
+    }
+  | {
+      property: "fill-opacity";
+    }
+  | {
+      property: "stroke";
+    }
+  | {
+      property: "stroke-opacity";
+    }
+  | {
+      property: "stroke-width";
+    }
+  | {
+      property: "stroke-linecap";
+    }
+  | {
+      property: "stroke-linejoin";
+    }
+  | {
+      property: "stroke-miterlimit";
+    }
+  | {
+      property: "stroke-dasharray";
+    }
+  | {
+      property: "stroke-dashoffset";
+    }
+  | {
+      property: "marker-start";
+    }
+  | {
+      property: "marker-mid";
+    }
+  | {
+      property: "marker-end";
+    }
+  | {
+      property: "marker";
+    }
+  | {
+      property: "color-interpolation";
+    }
+  | {
+      property: "color-interpolation-filters";
+    }
+  | {
+      property: "color-rendering";
+    }
+  | {
+      property: "shape-rendering";
+    }
+  | {
+      property: "text-rendering";
+    }
+  | {
+      property: "image-rendering";
+    }
+  | {
+      property: "clip-path";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "clip-rule";
+    }
+  | {
+      property: "mask-image";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-mode";
+    }
+  | {
+      property: "mask-repeat";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-position-x";
+    }
+  | {
+      property: "mask-position-y";
+    }
+  | {
+      property: "mask-position";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-clip";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-origin";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-size";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-composite";
+    }
+  | {
+      property: "mask-type";
+    }
+  | {
+      property: "mask";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-border-source";
+    }
+  | {
+      property: "mask-border-mode";
+    }
+  | {
+      property: "mask-border-slice";
+    }
+  | {
+      property: "mask-border-width";
+    }
+  | {
+      property: "mask-border-outset";
+    }
+  | {
+      property: "mask-border-repeat";
+    }
+  | {
+      property: "mask-border";
+    }
+  | {
+      property: "-webkit-mask-composite";
+    }
+  | {
+      property: "mask-source-type";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-source";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-slice";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-width";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-outset";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-repeat";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "filter";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "backdrop-filter";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "z-index";
+    }
+  | {
+      property: "container-type";
+    }
+  | {
+      property: "container-name";
+    }
+  | {
+      property: "container";
+    }
+  | {
+      property: "view-transition-name";
+    }
+  | {
+      property: "view-transition-class";
+    }
+  | {
+      property: "view-transition-group";
+    }
+  | {
+      property: "color-scheme";
+    }
+  | {
+      property: "print-color-adjust";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "all";
+    }
+  | {
+      property: string;
+    };
+export type Prefix = "none" | "webkit" | "moz" | "ms" | "o";
+export type VendorPrefix = Prefix[];
+export type Declaration =
+  | {
+      property: "background-color";
+      value: CssColor;
+    }
+  | {
+      property: "background-image";
+      value: Image[];
+    }
+  | {
+      property: "background-position-x";
+      value: PositionComponentFor_HorizontalPositionKeyword[];
+    }
+  | {
+      property: "background-position-y";
+      value: PositionComponentFor_VerticalPositionKeyword[];
+    }
+  | {
+      property: "background-position";
+      value: BackgroundPosition[];
+    }
+  | {
+      property: "background-size";
+      value: BackgroundSize[];
+    }
+  | {
+      property: "background-repeat";
+      value: BackgroundRepeat[];
+    }
+  | {
+      property: "background-attachment";
+      value: BackgroundAttachment[];
+    }
+  | {
+      property: "background-clip";
+      value: BackgroundClip[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "background-origin";
+      value: BackgroundOrigin[];
+    }
+  | {
+      property: "background";
+      value: Background[];
+    }
+  | {
+      property: "box-shadow";
+      value: BoxShadow[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "opacity";
+      value: number;
+    }
+  | {
+      property: "color";
+      value: CssColor;
+    }
+  | {
+      property: "display";
+      value: Display;
+    }
+  | {
+      property: "visibility";
+      value: Visibility;
+    }
+  | {
+      property: "width";
+      value: Size;
+    }
+  | {
+      property: "height";
+      value: Size;
+    }
+  | {
+      property: "min-width";
+      value: Size;
+    }
+  | {
+      property: "min-height";
+      value: Size;
+    }
+  | {
+      property: "max-width";
+      value: MaxSize;
+    }
+  | {
+      property: "max-height";
+      value: MaxSize;
+    }
+  | {
+      property: "block-size";
+      value: Size;
+    }
+  | {
+      property: "inline-size";
+      value: Size;
+    }
+  | {
+      property: "min-block-size";
+      value: Size;
+    }
+  | {
+      property: "min-inline-size";
+      value: Size;
+    }
+  | {
+      property: "max-block-size";
+      value: MaxSize;
+    }
+  | {
+      property: "max-inline-size";
+      value: MaxSize;
+    }
+  | {
+      property: "box-sizing";
+      value: BoxSizing;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "aspect-ratio";
+      value: AspectRatio;
+    }
+  | {
+      property: "overflow";
+      value: Overflow;
+    }
+  | {
+      property: "overflow-x";
+      value: OverflowKeyword;
+    }
+  | {
+      property: "overflow-y";
+      value: OverflowKeyword;
+    }
+  | {
+      property: "text-overflow";
+      value: TextOverflow;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "position";
+      value: Position2;
+    }
+  | {
+      property: "top";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "bottom";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "left";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "right";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "inset-block-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "inset-block-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "inset-inline-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "inset-inline-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "inset-block";
+      value: InsetBlock;
+    }
+  | {
+      property: "inset-inline";
+      value: InsetInline;
+    }
+  | {
+      property: "inset";
+      value: Inset;
+    }
+  | {
+      property: "border-spacing";
+      value: Size2DFor_Length;
+    }
+  | {
+      property: "border-top-color";
+      value: CssColor;
+    }
+  | {
+      property: "border-bottom-color";
+      value: CssColor;
+    }
+  | {
+      property: "border-left-color";
+      value: CssColor;
+    }
+  | {
+      property: "border-right-color";
+      value: CssColor;
+    }
+  | {
+      property: "border-block-start-color";
+      value: CssColor;
+    }
+  | {
+      property: "border-block-end-color";
+      value: CssColor;
+    }
+  | {
+      property: "border-inline-start-color";
+      value: CssColor;
+    }
+  | {
+      property: "border-inline-end-color";
+      value: CssColor;
+    }
+  | {
+      property: "border-top-style";
+      value: LineStyle;
+    }
+  | {
+      property: "border-bottom-style";
+      value: LineStyle;
+    }
+  | {
+      property: "border-left-style";
+      value: LineStyle;
+    }
+  | {
+      property: "border-right-style";
+      value: LineStyle;
+    }
+  | {
+      property: "border-block-start-style";
+      value: LineStyle;
+    }
+  | {
+      property: "border-block-end-style";
+      value: LineStyle;
+    }
+  | {
+      property: "border-inline-start-style";
+      value: LineStyle;
+    }
+  | {
+      property: "border-inline-end-style";
+      value: LineStyle;
+    }
+  | {
+      property: "border-top-width";
+      value: BorderSideWidth;
+    }
+  | {
+      property: "border-bottom-width";
+      value: BorderSideWidth;
+    }
+  | {
+      property: "border-left-width";
+      value: BorderSideWidth;
+    }
+  | {
+      property: "border-right-width";
+      value: BorderSideWidth;
+    }
+  | {
+      property: "border-block-start-width";
+      value: BorderSideWidth;
+    }
+  | {
+      property: "border-block-end-width";
+      value: BorderSideWidth;
+    }
+  | {
+      property: "border-inline-start-width";
+      value: BorderSideWidth;
+    }
+  | {
+      property: "border-inline-end-width";
+      value: BorderSideWidth;
+    }
+  | {
+      property: "border-top-left-radius";
+      value: Size2DFor_DimensionPercentageFor_LengthValue;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-top-right-radius";
+      value: Size2DFor_DimensionPercentageFor_LengthValue;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-bottom-left-radius";
+      value: Size2DFor_DimensionPercentageFor_LengthValue;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-bottom-right-radius";
+      value: Size2DFor_DimensionPercentageFor_LengthValue;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-start-start-radius";
+      value: Size2DFor_DimensionPercentageFor_LengthValue;
+    }
+  | {
+      property: "border-start-end-radius";
+      value: Size2DFor_DimensionPercentageFor_LengthValue;
+    }
+  | {
+      property: "border-end-start-radius";
+      value: Size2DFor_DimensionPercentageFor_LengthValue;
+    }
+  | {
+      property: "border-end-end-radius";
+      value: Size2DFor_DimensionPercentageFor_LengthValue;
+    }
+  | {
+      property: "border-radius";
+      value: BorderRadius;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-image-source";
+      value: Image;
+    }
+  | {
+      property: "border-image-outset";
+      value: RectFor_LengthOrNumber;
+    }
+  | {
+      property: "border-image-repeat";
+      value: BorderImageRepeat;
+    }
+  | {
+      property: "border-image-width";
+      value: RectFor_BorderImageSideWidth;
+    }
+  | {
+      property: "border-image-slice";
+      value: BorderImageSlice;
+    }
+  | {
+      property: "border-image";
+      value: BorderImage;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "border-color";
+      value: BorderColor;
+    }
+  | {
+      property: "border-style";
+      value: BorderStyle;
+    }
+  | {
+      property: "border-width";
+      value: BorderWidth;
+    }
+  | {
+      property: "border-block-color";
+      value: BorderBlockColor;
+    }
+  | {
+      property: "border-block-style";
+      value: BorderBlockStyle;
+    }
+  | {
+      property: "border-block-width";
+      value: BorderBlockWidth;
+    }
+  | {
+      property: "border-inline-color";
+      value: BorderInlineColor;
+    }
+  | {
+      property: "border-inline-style";
+      value: BorderInlineStyle;
+    }
+  | {
+      property: "border-inline-width";
+      value: BorderInlineWidth;
+    }
+  | {
+      property: "border";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-top";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-bottom";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-left";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-right";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-block";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-block-start";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-block-end";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-inline";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-inline-start";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "border-inline-end";
+      value: GenericBorderFor_LineStyle;
+    }
+  | {
+      property: "outline";
+      value: GenericBorderFor_OutlineStyleAnd_11;
+    }
+  | {
+      property: "outline-color";
+      value: CssColor;
+    }
+  | {
+      property: "outline-style";
+      value: OutlineStyle;
+    }
+  | {
+      property: "outline-width";
+      value: BorderSideWidth;
+    }
+  | {
+      property: "flex-direction";
+      value: FlexDirection;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-wrap";
+      value: FlexWrap;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-flow";
+      value: FlexFlow;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-grow";
+      value: number;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-shrink";
+      value: number;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-basis";
+      value: LengthPercentageOrAuto;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex";
+      value: Flex;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "order";
+      value: number;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "align-content";
+      value: AlignContent;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "justify-content";
+      value: JustifyContent;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "place-content";
+      value: PlaceContent;
+    }
+  | {
+      property: "align-self";
+      value: AlignSelf;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "justify-self";
+      value: JustifySelf;
+    }
+  | {
+      property: "place-self";
+      value: PlaceSelf;
+    }
+  | {
+      property: "align-items";
+      value: AlignItems;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "justify-items";
+      value: JustifyItems;
+    }
+  | {
+      property: "place-items";
+      value: PlaceItems;
+    }
+  | {
+      property: "row-gap";
+      value: GapValue;
+    }
+  | {
+      property: "column-gap";
+      value: GapValue;
+    }
+  | {
+      property: "gap";
+      value: Gap;
+    }
+  | {
+      property: "box-orient";
+      value: BoxOrient;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-direction";
+      value: BoxDirection;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-ordinal-group";
+      value: number;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-align";
+      value: BoxAlign;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-flex";
+      value: number;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-flex-group";
+      value: number;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-pack";
+      value: BoxPack;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "box-lines";
+      value: BoxLines;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-pack";
+      value: FlexPack;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-order";
+      value: number;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-align";
+      value: BoxAlign;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-item-align";
+      value: FlexItemAlign;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-line-pack";
+      value: FlexLinePack;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-positive";
+      value: number;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-negative";
+      value: number;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "flex-preferred-size";
+      value: LengthPercentageOrAuto;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "grid-template-columns";
+      value: TrackSizing;
+    }
+  | {
+      property: "grid-template-rows";
+      value: TrackSizing;
+    }
+  | {
+      property: "grid-auto-columns";
+      value: TrackSize[];
+    }
+  | {
+      property: "grid-auto-rows";
+      value: TrackSize[];
+    }
+  | {
+      property: "grid-auto-flow";
+      value: GridAutoFlow;
+    }
+  | {
+      property: "grid-template-areas";
+      value: GridTemplateAreas;
+    }
+  | {
+      property: "grid-template";
+      value: GridTemplate;
+    }
+  | {
+      property: "grid";
+      value: Grid;
+    }
+  | {
+      property: "grid-row-start";
+      value: GridLine;
+    }
+  | {
+      property: "grid-row-end";
+      value: GridLine;
+    }
+  | {
+      property: "grid-column-start";
+      value: GridLine;
+    }
+  | {
+      property: "grid-column-end";
+      value: GridLine;
+    }
+  | {
+      property: "grid-row";
+      value: GridRow;
+    }
+  | {
+      property: "grid-column";
+      value: GridColumn;
+    }
+  | {
+      property: "grid-area";
+      value: GridArea;
+    }
+  | {
+      property: "margin-top";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "margin-bottom";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "margin-left";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "margin-right";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "margin-block-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "margin-block-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "margin-inline-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "margin-inline-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "margin-block";
+      value: MarginBlock;
+    }
+  | {
+      property: "margin-inline";
+      value: MarginInline;
+    }
+  | {
+      property: "margin";
+      value: Margin;
+    }
+  | {
+      property: "padding-top";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "padding-bottom";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "padding-left";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "padding-right";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "padding-block-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "padding-block-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "padding-inline-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "padding-inline-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "padding-block";
+      value: PaddingBlock;
+    }
+  | {
+      property: "padding-inline";
+      value: PaddingInline;
+    }
+  | {
+      property: "padding";
+      value: Padding;
+    }
+  | {
+      property: "scroll-margin-top";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-margin-bottom";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-margin-left";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-margin-right";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-margin-block-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-margin-block-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-margin-inline-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-margin-inline-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-margin-block";
+      value: ScrollMarginBlock;
+    }
+  | {
+      property: "scroll-margin-inline";
+      value: ScrollMarginInline;
+    }
+  | {
+      property: "scroll-margin";
+      value: ScrollMargin;
+    }
+  | {
+      property: "scroll-padding-top";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-padding-bottom";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-padding-left";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-padding-right";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-padding-block-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-padding-block-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-padding-inline-start";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-padding-inline-end";
+      value: LengthPercentageOrAuto;
+    }
+  | {
+      property: "scroll-padding-block";
+      value: ScrollPaddingBlock;
+    }
+  | {
+      property: "scroll-padding-inline";
+      value: ScrollPaddingInline;
+    }
+  | {
+      property: "scroll-padding";
+      value: ScrollPadding;
+    }
+  | {
+      property: "font-weight";
+      value: FontWeight;
+    }
+  | {
+      property: "font-size";
+      value: FontSize;
+    }
+  | {
+      property: "font-stretch";
+      value: FontStretch;
+    }
+  | {
+      property: "font-family";
+      value: FontFamily[];
+    }
+  | {
+      property: "font-style";
+      value: FontStyle;
+    }
+  | {
+      property: "font-variant-caps";
+      value: FontVariantCaps;
+    }
+  | {
+      property: "line-height";
+      value: LineHeight;
+    }
+  | {
+      property: "font";
+      value: Font;
+    }
+  | {
+      property: "vertical-align";
+      value: VerticalAlign;
+    }
+  | {
+      property: "font-palette";
+      value: DashedIdentReference;
+    }
+  | {
+      property: "transition-property";
+      value: PropertyId[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transition-duration";
+      value: Time[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transition-delay";
+      value: Time[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transition-timing-function";
+      value: EasingFunction[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transition";
+      value: Transition[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-name";
+      value: AnimationName[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-duration";
+      value: Time[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-timing-function";
+      value: EasingFunction[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-iteration-count";
+      value: AnimationIterationCount[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-direction";
+      value: AnimationDirection[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-play-state";
+      value: AnimationPlayState[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-delay";
+      value: Time[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-fill-mode";
+      value: AnimationFillMode[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "animation-composition";
+      value: AnimationComposition[];
+    }
+  | {
+      property: "animation-timeline";
+      value: AnimationTimeline[];
+    }
+  | {
+      property: "animation-range-start";
+      value: AnimationRangeStart[];
+    }
+  | {
+      property: "animation-range-end";
+      value: AnimationRangeEnd[];
+    }
+  | {
+      property: "animation-range";
+      value: AnimationRange[];
+    }
+  | {
+      property: "animation";
+      value: Animation[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transform";
+      value: Transform[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transform-origin";
+      value: Position;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transform-style";
+      value: TransformStyle;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "transform-box";
+      value: TransformBox;
+    }
+  | {
+      property: "backface-visibility";
+      value: BackfaceVisibility;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "perspective";
+      value: Perspective;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "perspective-origin";
+      value: Position;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "translate";
+      value: Translate;
+    }
+  | {
+      property: "rotate";
+      value: Rotate;
+    }
+  | {
+      property: "scale";
+      value: Scale;
+    }
+  | {
+      property: "text-transform";
+      value: TextTransform;
+    }
+  | {
+      property: "white-space";
+      value: WhiteSpace;
+    }
+  | {
+      property: "tab-size";
+      value: LengthOrNumber;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "word-break";
+      value: WordBreak;
+    }
+  | {
+      property: "line-break";
+      value: LineBreak;
+    }
+  | {
+      property: "hyphens";
+      value: Hyphens;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "overflow-wrap";
+      value: OverflowWrap;
+    }
+  | {
+      property: "word-wrap";
+      value: OverflowWrap;
+    }
+  | {
+      property: "text-align";
+      value: TextAlign;
+    }
+  | {
+      property: "text-align-last";
+      value: TextAlignLast;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-justify";
+      value: TextJustify;
+    }
+  | {
+      property: "word-spacing";
+      value: Spacing;
+    }
+  | {
+      property: "letter-spacing";
+      value: Spacing;
+    }
+  | {
+      property: "text-indent";
+      value: TextIndent;
+    }
+  | {
+      property: "text-decoration-line";
+      value: TextDecorationLine;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-decoration-style";
+      value: TextDecorationStyle;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-decoration-color";
+      value: CssColor;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-decoration-thickness";
+      value: TextDecorationThickness;
+    }
+  | {
+      property: "text-decoration";
+      value: TextDecoration;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-decoration-skip-ink";
+      value: TextDecorationSkipInk;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-emphasis-style";
+      value: TextEmphasisStyle;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-emphasis-color";
+      value: CssColor;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-emphasis";
+      value: TextEmphasis;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-emphasis-position";
+      value: TextEmphasisPosition;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "text-shadow";
+      value: TextShadow[];
+    }
+  | {
+      property: "text-size-adjust";
+      value: TextSizeAdjust;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "direction";
+      value: Direction2;
+    }
+  | {
+      property: "unicode-bidi";
+      value: UnicodeBidi;
+    }
+  | {
+      property: "box-decoration-break";
+      value: BoxDecorationBreak;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "resize";
+      value: Resize;
+    }
+  | {
+      property: "cursor";
+      value: Cursor;
+    }
+  | {
+      property: "caret-color";
+      value: ColorOrAuto;
+    }
+  | {
+      property: "caret-shape";
+      value: CaretShape;
+    }
+  | {
+      property: "caret";
+      value: Caret;
+    }
+  | {
+      property: "user-select";
+      value: UserSelect;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "accent-color";
+      value: ColorOrAuto;
+    }
+  | {
+      property: "appearance";
+      value: Appearance;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "list-style-type";
+      value: ListStyleType;
+    }
+  | {
+      property: "list-style-image";
+      value: Image;
+    }
+  | {
+      property: "list-style-position";
+      value: ListStylePosition;
+    }
+  | {
+      property: "list-style";
+      value: ListStyle;
+    }
+  | {
+      property: "marker-side";
+      value: MarkerSide;
+    }
+  | {
+      property: "composes";
+      value: Composes;
+    }
+  | {
+      property: "fill";
+      value: SVGPaint;
+    }
+  | {
+      property: "fill-rule";
+      value: FillRule;
+    }
+  | {
+      property: "fill-opacity";
+      value: number;
+    }
+  | {
+      property: "stroke";
+      value: SVGPaint;
+    }
+  | {
+      property: "stroke-opacity";
+      value: number;
+    }
+  | {
+      property: "stroke-width";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      property: "stroke-linecap";
+      value: StrokeLinecap;
+    }
+  | {
+      property: "stroke-linejoin";
+      value: StrokeLinejoin;
+    }
+  | {
+      property: "stroke-miterlimit";
+      value: number;
+    }
+  | {
+      property: "stroke-dasharray";
+      value: StrokeDasharray;
+    }
+  | {
+      property: "stroke-dashoffset";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      property: "marker-start";
+      value: Marker;
+    }
+  | {
+      property: "marker-mid";
+      value: Marker;
+    }
+  | {
+      property: "marker-end";
+      value: Marker;
+    }
+  | {
+      property: "marker";
+      value: Marker;
+    }
+  | {
+      property: "color-interpolation";
+      value: ColorInterpolation;
+    }
+  | {
+      property: "color-interpolation-filters";
+      value: ColorInterpolation;
+    }
+  | {
+      property: "color-rendering";
+      value: ColorRendering;
+    }
+  | {
+      property: "shape-rendering";
+      value: ShapeRendering;
+    }
+  | {
+      property: "text-rendering";
+      value: TextRendering;
+    }
+  | {
+      property: "image-rendering";
+      value: ImageRendering;
+    }
+  | {
+      property: "clip-path";
+      value: ClipPath;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "clip-rule";
+      value: FillRule;
+    }
+  | {
+      property: "mask-image";
+      value: Image[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-mode";
+      value: MaskMode[];
+    }
+  | {
+      property: "mask-repeat";
+      value: BackgroundRepeat[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-position-x";
+      value: PositionComponentFor_HorizontalPositionKeyword[];
+    }
+  | {
+      property: "mask-position-y";
+      value: PositionComponentFor_VerticalPositionKeyword[];
+    }
+  | {
+      property: "mask-position";
+      value: Position[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-clip";
+      value: MaskClip[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-origin";
+      value: GeometryBox[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-size";
+      value: BackgroundSize[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-composite";
+      value: MaskComposite[];
+    }
+  | {
+      property: "mask-type";
+      value: MaskType;
+    }
+  | {
+      property: "mask";
+      value: Mask[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-border-source";
+      value: Image;
+    }
+  | {
+      property: "mask-border-mode";
+      value: MaskBorderMode;
+    }
+  | {
+      property: "mask-border-slice";
+      value: BorderImageSlice;
+    }
+  | {
+      property: "mask-border-width";
+      value: RectFor_BorderImageSideWidth;
+    }
+  | {
+      property: "mask-border-outset";
+      value: RectFor_LengthOrNumber;
+    }
+  | {
+      property: "mask-border-repeat";
+      value: BorderImageRepeat;
+    }
+  | {
+      property: "mask-border";
+      value: MaskBorder;
+    }
+  | {
+      property: "-webkit-mask-composite";
+      value: WebKitMaskComposite[];
+    }
+  | {
+      property: "mask-source-type";
+      value: WebKitMaskSourceType[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image";
+      value: BorderImage;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-source";
+      value: Image;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-slice";
+      value: BorderImageSlice;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-width";
+      value: RectFor_BorderImageSideWidth;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-outset";
+      value: RectFor_LengthOrNumber;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "mask-box-image-repeat";
+      value: BorderImageRepeat;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "filter";
+      value: FilterList;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "backdrop-filter";
+      value: FilterList;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "z-index";
+      value: ZIndex;
+    }
+  | {
+      property: "container-type";
+      value: ContainerType;
+    }
+  | {
+      property: "container-name";
+      value: ContainerNameList;
+    }
+  | {
+      property: "container";
+      value: Container;
+    }
+  | {
+      property: "view-transition-name";
+      value: ViewTransitionName;
+    }
+  | {
+      property: "view-transition-class";
+      value: NoneOrCustomIdentList;
+    }
+  | {
+      property: "view-transition-group";
+      value: ViewTransitionGroup;
+    }
+  | {
+      property: "color-scheme";
+      value: ColorScheme;
+    }
+  | {
+      property: "print-color-adjust";
+      value: PrintColorAdjust;
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      property: "all";
+      value: CSSWideKeyword;
+    }
+  | {
+      property: "unparsed";
+      value: UnparsedProperty;
+    }
+  | {
+      property: "custom";
+      value: CustomProperty;
+    };
+/**
+ * A CSS [`<image>`](https://www.w3.org/TR/css-images-3/#image-values) value.
+ */
+export type Image =
+  | {
+      type: "none";
+    }
+  | {
+      type: "url";
+      value: Url;
+    }
+  | {
+      type: "gradient";
+      value: Gradient;
+    }
+  | {
+      type: "image-set";
+      value: ImageSet;
+    };
+/**
+ * A CSS [`<gradient>`](https://www.w3.org/TR/css-images-3/#gradients) value.
+ */
+export type Gradient =
+  | {
+      /**
+       * The direction of the gradient.
+       */
+      direction: LineDirection;
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_LengthValue[];
+      type: "linear";
+      /**
+       * The vendor prefixes for the gradient.
+       */
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      /**
+       * The direction of the gradient.
+       */
+      direction: LineDirection;
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_LengthValue[];
+      type: "repeating-linear";
+      /**
+       * The vendor prefixes for the gradient.
+       */
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_LengthValue[];
+      /**
+       * The position of the gradient.
+       */
+      position: Position;
+      /**
+       * The shape of the gradient.
+       */
+      shape: EndingShape;
+      type: "radial";
+      /**
+       * The vendor prefixes for the gradient.
+       */
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_LengthValue[];
+      /**
+       * The position of the gradient.
+       */
+      position: Position;
+      /**
+       * The shape of the gradient.
+       */
+      shape: EndingShape;
+      type: "repeating-radial";
+      /**
+       * The vendor prefixes for the gradient.
+       */
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      /**
+       * The angle of the gradient.
+       */
+      angle: Angle;
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_Angle[];
+      /**
+       * The position of the gradient.
+       */
+      position: Position;
+      type: "conic";
+    }
+  | {
+      /**
+       * The angle of the gradient.
+       */
+      angle: Angle;
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_Angle[];
+      /**
+       * The position of the gradient.
+       */
+      position: Position;
+      type: "repeating-conic";
+    }
+  | (
+      | {
+          type: "webkit-gradient";
+          /**
+           * The starting point of the gradient.
+           */
+          from: WebKitGradientPoint;
+          kind: "linear";
+          /**
+           * The color stops in the gradient.
+           */
+          stops: WebKitColorStop[];
+          /**
+           * The ending point of the gradient.
+           */
+          to: WebKitGradientPoint;
+        }
+      | {
+          type: "webkit-gradient";
+          /**
+           * The starting point of the gradient.
+           */
+          from: WebKitGradientPoint;
+          kind: "radial";
+          /**
+           * The starting radius of the gradient.
+           */
+          r0: number;
+          /**
+           * The ending radius of the gradient.
+           */
+          r1: number;
+          /**
+           * The color stops in the gradient.
+           */
+          stops: WebKitColorStop[];
+          /**
+           * The ending point of the gradient.
+           */
+          to: WebKitGradientPoint;
+        }
+    );
+/**
+ * The direction of a CSS `linear-gradient()`.
+ *
+ * See [LinearGradient](LinearGradient).
+ */
+export type LineDirection =
+  | {
+      type: "angle";
+      value: Angle;
+    }
+  | {
+      type: "horizontal";
+      value: HorizontalPositionKeyword;
+    }
+  | {
+      type: "vertical";
+      value: VerticalPositionKeyword;
+    }
+  | {
+      /**
+       * A horizontal position keyword, e.g. `left` or `right.
+       */
+      horizontal: HorizontalPositionKeyword;
+      type: "corner";
+      /**
+       * A vertical posision keyword, e.g. `top` or `bottom`.
+       */
+      vertical: VerticalPositionKeyword;
+    };
+/**
+ * A horizontal position keyword.
+ */
+export type HorizontalPositionKeyword = "left" | "right";
+/**
+ * A vertical position keyword.
+ */
+export type VerticalPositionKeyword = "top" | "bottom";
+/**
+ * Either a color stop or interpolation hint within a gradient.
+ *
+ * This type is generic, and items may be either a [LengthPercentage](super::length::LengthPercentage) or [Angle](super::angle::Angle) depending on what type of gradient it is within.
+ */
+export type GradientItemFor_DimensionPercentageFor_LengthValue =
+  | {
+      /**
+       * The color of the color stop.
+       */
+      color: CssColor;
+      /**
+       * The position of the color stop.
+       */
+      position?: DimensionPercentageFor_LengthValue | null;
+      type: "color-stop";
+    }
+  | {
+      type: "hint";
+      value: DimensionPercentageFor_LengthValue;
+    };
+/**
+ * A generic type that allows any kind of dimension and percentage to be used standalone or mixed within a `calc()` expression.
+ *
+ * <https://drafts.csswg.org/css-values-4/#mixed-percentages>
+ */
+export type DimensionPercentageFor_LengthValue =
+  | {
+      type: "dimension";
+      value: LengthValue;
+    }
+  | {
+      type: "percentage";
+      value: number;
+    }
+  | {
+      type: "calc";
+      value: CalcFor_DimensionPercentageFor_LengthValue;
+    };
+/**
+ * A mathematical expression used within the [`calc()`](https://www.w3.org/TR/css-values-4/#calc-func) function.
+ *
+ * This type supports generic value types. Values such as [Length](super::length::Length), [Percentage](super::percentage::Percentage), [Time](super::time::Time), and [Angle](super::angle::Angle) support `calc()` expressions.
+ */
+export type CalcFor_DimensionPercentageFor_LengthValue =
+  | {
+      type: "value";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "sum";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_DimensionPercentageFor_LengthValue, CalcFor_DimensionPercentageFor_LengthValue];
+    }
+  | {
+      type: "product";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [number, CalcFor_DimensionPercentageFor_LengthValue];
+    }
+  | {
+      type: "function";
+      value: MathFunctionFor_DimensionPercentageFor_LengthValue;
+    };
+/**
+ * A CSS [math function](https://www.w3.org/TR/css-values-4/#math-function).
+ *
+ * Math functions may be used in most properties and values that accept numeric values, including lengths, percentages, angles, times, etc.
+ */
+export type MathFunctionFor_DimensionPercentageFor_LengthValue =
+  | {
+      type: "calc";
+      value: CalcFor_DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "min";
+      value: CalcFor_DimensionPercentageFor_LengthValue[];
+    }
+  | {
+      type: "max";
+      value: CalcFor_DimensionPercentageFor_LengthValue[];
+    }
+  | {
+      type: "clamp";
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_LengthValue,
+        CalcFor_DimensionPercentageFor_LengthValue,
+        CalcFor_DimensionPercentageFor_LengthValue
+      ];
+    }
+  | {
+      type: "round";
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [RoundingStrategy, CalcFor_DimensionPercentageFor_LengthValue, CalcFor_DimensionPercentageFor_LengthValue];
+    }
+  | {
+      type: "rem";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_DimensionPercentageFor_LengthValue, CalcFor_DimensionPercentageFor_LengthValue];
+    }
+  | {
+      type: "mod";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_DimensionPercentageFor_LengthValue, CalcFor_DimensionPercentageFor_LengthValue];
+    }
+  | {
+      type: "abs";
+      value: CalcFor_DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "sign";
+      value: CalcFor_DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "hypot";
+      value: CalcFor_DimensionPercentageFor_LengthValue[];
+    };
+/**
+ * A component within a [Position](Position) value, representing a position along either the horizontal or vertical axis of a box.
+ *
+ * This type is generic over side keywords.
+ */
+export type PositionComponentFor_HorizontalPositionKeyword =
+  | {
+      type: "center";
+    }
+  | {
+      type: "length";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      /**
+       * Offset from the side.
+       */
+      offset?: DimensionPercentageFor_LengthValue | null;
+      /**
+       * A side keyword.
+       */
+      side: HorizontalPositionKeyword;
+      type: "side";
+    };
+/**
+ * A component within a [Position](Position) value, representing a position along either the horizontal or vertical axis of a box.
+ *
+ * This type is generic over side keywords.
+ */
+export type PositionComponentFor_VerticalPositionKeyword =
+  | {
+      type: "center";
+    }
+  | {
+      type: "length";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      /**
+       * Offset from the side.
+       */
+      offset?: DimensionPercentageFor_LengthValue | null;
+      /**
+       * A side keyword.
+       */
+      side: VerticalPositionKeyword;
+      type: "side";
+    };
+/**
+ * A `radial-gradient()` [ending shape](https://www.w3.org/TR/css-images-3/#valdef-radial-gradient-ending-shape).
+ *
+ * See [RadialGradient](RadialGradient).
+ */
+export type EndingShape =
+  | {
+      type: "ellipse";
+      value: Ellipse;
+    }
+  | {
+      type: "circle";
+      value: Circle;
+    };
+/**
+ * An ellipse ending shape for a `radial-gradient()`.
+ *
+ * See [RadialGradient](RadialGradient).
+ */
+export type Ellipse =
+  | {
+      type: "size";
+      /**
+       * The x-radius of the ellipse.
+       */
+      x: DimensionPercentageFor_LengthValue;
+      /**
+       * The y-radius of the ellipse.
+       */
+      y: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "extent";
+      value: ShapeExtent;
+    };
+/**
+ * A shape extent for a `radial-gradient()`.
+ *
+ * See [RadialGradient](RadialGradient).
+ */
+export type ShapeExtent = "closest-side" | "farthest-side" | "closest-corner" | "farthest-corner";
+/**
+ * A circle ending shape for a `radial-gradient()`.
+ *
+ * See [RadialGradient](RadialGradient).
+ */
+export type Circle =
+  | {
+      type: "radius";
+      value: Length;
+    }
+  | {
+      type: "extent";
+      value: ShapeExtent;
+    };
+/**
+ * Either a color stop or interpolation hint within a gradient.
+ *
+ * This type is generic, and items may be either a [LengthPercentage](super::length::LengthPercentage) or [Angle](super::angle::Angle) depending on what type of gradient it is within.
+ */
+export type GradientItemFor_DimensionPercentageFor_Angle =
+  | {
+      /**
+       * The color of the color stop.
+       */
+      color: CssColor;
+      /**
+       * The position of the color stop.
+       */
+      position?: DimensionPercentageFor_Angle | null;
+      type: "color-stop";
+    }
+  | {
+      type: "hint";
+      value: DimensionPercentageFor_Angle;
+    };
+/**
+ * A generic type that allows any kind of dimension and percentage to be used standalone or mixed within a `calc()` expression.
+ *
+ * <https://drafts.csswg.org/css-values-4/#mixed-percentages>
+ */
+export type DimensionPercentageFor_Angle =
+  | {
+      type: "dimension";
+      value: Angle;
+    }
+  | {
+      type: "percentage";
+      value: number;
+    }
+  | {
+      type: "calc";
+      value: CalcFor_DimensionPercentageFor_Angle;
+    };
+/**
+ * A mathematical expression used within the [`calc()`](https://www.w3.org/TR/css-values-4/#calc-func) function.
+ *
+ * This type supports generic value types. Values such as [Length](super::length::Length), [Percentage](super::percentage::Percentage), [Time](super::time::Time), and [Angle](super::angle::Angle) support `calc()` expressions.
+ */
+export type CalcFor_DimensionPercentageFor_Angle =
+  | {
+      type: "value";
+      value: DimensionPercentageFor_Angle;
+    }
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "sum";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_DimensionPercentageFor_Angle, CalcFor_DimensionPercentageFor_Angle];
+    }
+  | {
+      type: "product";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [number, CalcFor_DimensionPercentageFor_Angle];
+    }
+  | {
+      type: "function";
+      value: MathFunctionFor_DimensionPercentageFor_Angle;
+    };
+/**
+ * A CSS [math function](https://www.w3.org/TR/css-values-4/#math-function).
+ *
+ * Math functions may be used in most properties and values that accept numeric values, including lengths, percentages, angles, times, etc.
+ */
+export type MathFunctionFor_DimensionPercentageFor_Angle =
+  | {
+      type: "calc";
+      value: CalcFor_DimensionPercentageFor_Angle;
+    }
+  | {
+      type: "min";
+      value: CalcFor_DimensionPercentageFor_Angle[];
+    }
+  | {
+      type: "max";
+      value: CalcFor_DimensionPercentageFor_Angle[];
+    }
+  | {
+      type: "clamp";
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_Angle,
+        CalcFor_DimensionPercentageFor_Angle,
+        CalcFor_DimensionPercentageFor_Angle
+      ];
+    }
+  | {
+      type: "round";
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [RoundingStrategy, CalcFor_DimensionPercentageFor_Angle, CalcFor_DimensionPercentageFor_Angle];
+    }
+  | {
+      type: "rem";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_DimensionPercentageFor_Angle, CalcFor_DimensionPercentageFor_Angle];
+    }
+  | {
+      type: "mod";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_DimensionPercentageFor_Angle, CalcFor_DimensionPercentageFor_Angle];
+    }
+  | {
+      type: "abs";
+      value: CalcFor_DimensionPercentageFor_Angle;
+    }
+  | {
+      type: "sign";
+      value: CalcFor_DimensionPercentageFor_Angle;
+    }
+  | {
+      type: "hypot";
+      value: CalcFor_DimensionPercentageFor_Angle[];
+    };
+/**
+ * A keyword or number within a [WebKitGradientPoint](WebKitGradientPoint).
+ */
+export type WebKitGradientPointComponentFor_HorizontalPositionKeyword =
+  | {
+      type: "center";
+    }
+  | {
+      type: "number";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "side";
+      value: HorizontalPositionKeyword;
+    };
+/**
+ * Either a `<number>` or `<percentage>`.
+ */
+export type NumberOrPercentage =
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "percentage";
+      value: number;
+    };
+/**
+ * A keyword or number within a [WebKitGradientPoint](WebKitGradientPoint).
+ */
+export type WebKitGradientPointComponentFor_VerticalPositionKeyword =
+  | {
+      type: "center";
+    }
+  | {
+      type: "number";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "side";
+      value: VerticalPositionKeyword;
+    };
+/**
+ * A value for the [background-size](https://www.w3.org/TR/css-backgrounds-3/#background-size) property.
+ */
+export type BackgroundSize =
+  | {
+      /**
+       * The height of the background.
+       */
+      height: LengthPercentageOrAuto;
+      type: "explicit";
+      /**
+       * The width of the background.
+       */
+      width: LengthPercentageOrAuto;
+    }
+  | {
+      type: "cover";
+    }
+  | {
+      type: "contain";
+    };
+/**
+ * Either a [`<length-percentage>`](https://www.w3.org/TR/css-values-4/#typedef-length-percentage), or the `auto` keyword.
+ */
+export type LengthPercentageOrAuto =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "length-percentage";
+      value: DimensionPercentageFor_LengthValue;
+    };
+/**
+ * A [`<repeat-style>`](https://www.w3.org/TR/css-backgrounds-3/#typedef-repeat-style) value, used within the `background-repeat` property to represent how a background image is repeated in a single direction.
+ *
+ * See [BackgroundRepeat](BackgroundRepeat).
+ */
+export type BackgroundRepeatKeyword = "repeat" | "space" | "round" | "no-repeat";
+/**
+ * A value for the [background-attachment](https://www.w3.org/TR/css-backgrounds-3/#background-attachment) property.
+ */
+export type BackgroundAttachment = "scroll" | "fixed" | "local";
+/**
+ * A value for the [background-clip](https://drafts.csswg.org/css-backgrounds-4/#background-clip) property.
+ */
+export type BackgroundClip = "border-box" | "padding-box" | "content-box" | "border" | "text";
+/**
+ * A value for the [background-origin](https://www.w3.org/TR/css-backgrounds-3/#background-origin) property.
+ */
+export type BackgroundOrigin = "border-box" | "padding-box" | "content-box";
+/**
+ * A value for the [display](https://drafts.csswg.org/css-display-3/#the-display-properties) property.
+ */
+export type Display =
+  | {
+      type: "keyword";
+      value: DisplayKeyword;
+    }
+  | {
+      /**
+       * The inside display value.
+       */
+      inside: DisplayInside;
+      /**
+       * Whether this is a list item.
+       */
+      isListItem: boolean;
+      /**
+       * The outside display value.
+       */
+      outside: DisplayOutside;
+      type: "pair";
+    };
+/**
+ * A `display` keyword.
+ *
+ * See [Display](Display).
+ */
+export type DisplayKeyword =
+  | "none"
+  | "contents"
+  | "table-row-group"
+  | "table-header-group"
+  | "table-footer-group"
+  | "table-row"
+  | "table-cell"
+  | "table-column-group"
+  | "table-column"
+  | "table-caption"
+  | "ruby-base"
+  | "ruby-text"
+  | "ruby-base-container"
+  | "ruby-text-container";
+/**
+ * A [`<display-inside>`](https://drafts.csswg.org/css-display-3/#typedef-display-inside) value.
+ */
+export type DisplayInside =
+  | {
+      type: "flow";
+    }
+  | {
+      type: "flow-root";
+    }
+  | {
+      type: "table";
+    }
+  | {
+      type: "flex";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "box";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "grid";
+    }
+  | {
+      type: "ruby";
+    };
+/**
+ * A [`<display-outside>`](https://drafts.csswg.org/css-display-3/#typedef-display-outside) value.
+ */
+export type DisplayOutside = "block" | "inline" | "run-in";
+/**
+ * A value for the [visibility](https://drafts.csswg.org/css-display-3/#visibility) property.
+ */
+export type Visibility = "visible" | "hidden" | "collapse";
+/**
+ * A value for the [preferred size properties](https://drafts.csswg.org/css-sizing-3/#preferred-size-properties), i.e. `width` and `height.
+ */
+export type Size =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "length-percentage";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "min-content";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "max-content";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "fit-content";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "fit-content-function";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "stretch";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "contain";
+    };
+/**
+ * A value for the [minimum](https://drafts.csswg.org/css-sizing-3/#min-size-properties) and [maximum](https://drafts.csswg.org/css-sizing-3/#max-size-properties) size properties, e.g. `min-width` and `max-height`.
+ */
+export type MaxSize =
+  | {
+      type: "none";
+    }
+  | {
+      type: "length-percentage";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "min-content";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "max-content";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "fit-content";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "fit-content-function";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "stretch";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      type: "contain";
+    };
+/**
+ * A value for the [box-sizing](https://drafts.csswg.org/css-sizing-3/#box-sizing) property.
+ */
+export type BoxSizing = "content-box" | "border-box";
+/**
+ * An [overflow](https://www.w3.org/TR/css-overflow-3/#overflow-properties) keyword as used in the `overflow-x`, `overflow-y`, and `overflow` properties.
+ */
+export type OverflowKeyword = "visible" | "hidden" | "clip" | "scroll" | "auto";
+/**
+ * A value for the [text-overflow](https://www.w3.org/TR/css-overflow-3/#text-overflow) property.
+ */
+export type TextOverflow = "clip" | "ellipsis";
+/**
+ * A value for the [position](https://www.w3.org/TR/css-position-3/#position-property) property.
+ */
+export type Position2 =
+  | {
+      type: "static";
+    }
+  | {
+      type: "relative";
+    }
+  | {
+      type: "absolute";
+    }
+  | {
+      type: "sticky";
+      value: VendorPrefix;
+    }
+  | {
+      type: "fixed";
+    };
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ *
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_Length = [Length, Length];
+/**
+ * A [`<line-style>`](https://drafts.csswg.org/css-backgrounds/#typedef-line-style) value, used in the `border-style` property.
+ */
+export type LineStyle =
+  | "none"
+  | "hidden"
+  | "inset"
+  | "groove"
+  | "outset"
+  | "ridge"
+  | "dotted"
+  | "dashed"
+  | "solid"
+  | "double";
+/**
+ * A value for the [border-width](https://www.w3.org/TR/css-backgrounds-3/#border-width) property.
+ */
+export type BorderSideWidth =
+  | {
+      type: "thin";
+    }
+  | {
+      type: "medium";
+    }
+  | {
+      type: "thick";
+    }
+  | {
+      type: "length";
+      value: Length;
+    };
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ *
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_DimensionPercentageFor_LengthValue = [
+  DimensionPercentageFor_LengthValue,
+  DimensionPercentageFor_LengthValue
+];
+/**
+ * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc.
+ *
+ * When serialized, as few components as possible are written when there are duplicate values.
+ *
+ * @minItems 4
+ * @maxItems 4
+ */
+export type RectFor_LengthOrNumber = [LengthOrNumber, LengthOrNumber, LengthOrNumber, LengthOrNumber];
+/**
+ * Either a [`<length>`](https://www.w3.org/TR/css-values-4/#lengths) or a [`<number>`](https://www.w3.org/TR/css-values-4/#numbers).
+ */
+export type LengthOrNumber =
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "length";
+      value: Length;
+    };
+/**
+ * A single [border-image-repeat](https://www.w3.org/TR/css-backgrounds-3/#border-image-repeat) keyword.
+ */
+export type BorderImageRepeatKeyword = "stretch" | "repeat" | "round" | "space";
+/**
+ * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc.
+ *
+ * When serialized, as few components as possible are written when there are duplicate values.
+ *
+ * @minItems 4
+ * @maxItems 4
+ */
+export type RectFor_BorderImageSideWidth = [
+  BorderImageSideWidth,
+  BorderImageSideWidth,
+  BorderImageSideWidth,
+  BorderImageSideWidth
+];
+/**
+ * A value for the [border-image-width](https://www.w3.org/TR/css-backgrounds-3/#border-image-width) property.
+ */
+export type BorderImageSideWidth =
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "length-percentage";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "auto";
+    };
+/**
+ * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc.
+ *
+ * When serialized, as few components as possible are written when there are duplicate values.
+ *
+ * @minItems 4
+ * @maxItems 4
+ */
+export type RectFor_NumberOrPercentage = [
+  NumberOrPercentage,
+  NumberOrPercentage,
+  NumberOrPercentage,
+  NumberOrPercentage
+];
+/**
+ * A value for the [outline-style](https://drafts.csswg.org/css-ui/#outline-style) property.
+ */
+export type OutlineStyle =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "line-style";
+      value: LineStyle;
+    };
+/**
+ * A value for the [flex-direction](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#propdef-flex-direction) property.
+ */
+export type FlexDirection = "row" | "row-reverse" | "column" | "column-reverse";
+/**
+ * A value for the [flex-wrap](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-wrap-property) property.
+ */
+export type FlexWrap = "nowrap" | "wrap" | "wrap-reverse";
+/**
+ * A value for the [align-content](https://www.w3.org/TR/css-align-3/#propdef-align-content) property.
+ */
+export type AlignContent =
+  | {
+      type: "normal";
+    }
+  | {
+      type: "baseline-position";
+      value: BaselinePosition;
+    }
+  | {
+      type: "content-distribution";
+      value: ContentDistribution;
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "content-position";
+      /**
+       * A content position keyword.
+       */
+      value: ContentPosition;
+    };
+/**
+ * A [`<baseline-position>`](https://www.w3.org/TR/css-align-3/#typedef-baseline-position) value, as used in the alignment properties.
+ */
+export type BaselinePosition = "first" | "last";
+/**
+ * A [`<content-distribution>`](https://www.w3.org/TR/css-align-3/#typedef-content-distribution) value.
+ */
+export type ContentDistribution = "space-between" | "space-around" | "space-evenly" | "stretch";
+/**
+ * An [`<overflow-position>`](https://www.w3.org/TR/css-align-3/#typedef-overflow-position) value.
+ */
+export type OverflowPosition = "safe" | "unsafe";
+/**
+ * A [`<content-position>`](https://www.w3.org/TR/css-align-3/#typedef-content-position) value.
+ */
+export type ContentPosition = "center" | "start" | "end" | "flex-start" | "flex-end";
+/**
+ * A value for the [justify-content](https://www.w3.org/TR/css-align-3/#propdef-justify-content) property.
+ */
+export type JustifyContent =
+  | {
+      type: "normal";
+    }
+  | {
+      type: "content-distribution";
+      value: ContentDistribution;
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "content-position";
+      /**
+       * A content position keyword.
+       */
+      value: ContentPosition;
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "left";
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "right";
+    };
+/**
+ * A value for the [align-self](https://www.w3.org/TR/css-align-3/#align-self-property) property.
+ */
+export type AlignSelf =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "normal";
+    }
+  | {
+      type: "stretch";
+    }
+  | {
+      type: "baseline-position";
+      value: BaselinePosition;
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "self-position";
+      /**
+       * A self position keyword.
+       */
+      value: SelfPosition;
+    };
+/**
+ * A [`<self-position>`](https://www.w3.org/TR/css-align-3/#typedef-self-position) value.
+ */
+export type SelfPosition = "center" | "start" | "end" | "self-start" | "self-end" | "flex-start" | "flex-end";
+/**
+ * A value for the [justify-self](https://www.w3.org/TR/css-align-3/#justify-self-property) property.
+ */
+export type JustifySelf =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "normal";
+    }
+  | {
+      type: "stretch";
+    }
+  | {
+      type: "baseline-position";
+      value: BaselinePosition;
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "self-position";
+      /**
+       * A self position keyword.
+       */
+      value: SelfPosition;
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "left";
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "right";
+    };
+/**
+ * A value for the [align-items](https://www.w3.org/TR/css-align-3/#align-items-property) property.
+ */
+export type AlignItems =
+  | {
+      type: "normal";
+    }
+  | {
+      type: "stretch";
+    }
+  | {
+      type: "baseline-position";
+      value: BaselinePosition;
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "self-position";
+      /**
+       * A self position keyword.
+       */
+      value: SelfPosition;
+    };
+/**
+ * A value for the [justify-items](https://www.w3.org/TR/css-align-3/#justify-items-property) property.
+ */
+export type JustifyItems =
+  | {
+      type: "normal";
+    }
+  | {
+      type: "stretch";
+    }
+  | {
+      type: "baseline-position";
+      value: BaselinePosition;
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "self-position";
+      /**
+       * A self position keyword.
+       */
+      value: SelfPosition;
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "left";
+    }
+  | {
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null;
+      type: "right";
+    }
+  | {
+      type: "legacy";
+      value: LegacyJustify;
+    };
+/**
+ * A legacy justification keyword, as used in the `justify-items` property.
+ */
+export type LegacyJustify = "left" | "right" | "center";
+/**
+ * A [gap](https://www.w3.org/TR/css-align-3/#column-row-gap) value, as used in the `column-gap` and `row-gap` properties.
+ */
+export type GapValue =
+  | {
+      type: "normal";
+    }
+  | {
+      type: "length-percentage";
+      value: DimensionPercentageFor_LengthValue;
+    };
+/**
+ * A value for the legacy (prefixed) [box-orient](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#orientation) property. Partially equivalent to `flex-direction` in the standard syntax.
+ */
+export type BoxOrient = "horizontal" | "vertical" | "inline-axis" | "block-axis";
+/**
+ * A value for the legacy (prefixed) [box-direction](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#displayorder) property. Partially equivalent to the `flex-direction` property in the standard syntax.
+ */
+export type BoxDirection = "normal" | "reverse";
+/**
+ * A value for the legacy (prefixed) [box-align](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment) property. Equivalent to the `align-items` property in the standard syntax.
+ */
+export type BoxAlign = "start" | "end" | "center" | "baseline" | "stretch";
+/**
+ * A value for the legacy (prefixed) [box-pack](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#packing) property. Equivalent to the `justify-content` property in the standard syntax.
+ */
+export type BoxPack = "start" | "end" | "center" | "justify";
+/**
+ * A value for the legacy (prefixed) [box-lines](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#multiple) property. Equivalent to the `flex-wrap` property in the standard syntax.
+ */
+export type BoxLines = "single" | "multiple";
+/**
+ * A value for the legacy (prefixed) [flex-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack) property. Equivalent to the `justify-content` property in the standard syntax.
+ */
+export type FlexPack = "start" | "end" | "center" | "justify" | "distribute";
+/**
+ * A value for the legacy (prefixed) [flex-item-align](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align) property. Equivalent to the `align-self` property in the standard syntax.
+ */
+export type FlexItemAlign = "auto" | "start" | "end" | "center" | "baseline" | "stretch";
+/**
+ * A value for the legacy (prefixed) [flex-line-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack) property. Equivalent to the `align-content` property in the standard syntax.
+ */
+export type FlexLinePack = "start" | "end" | "center" | "justify" | "distribute" | "stretch";
+/**
+ * A [track sizing](https://drafts.csswg.org/css-grid-2/#track-sizing) value for the `grid-template-rows` and `grid-template-columns` properties.
+ */
+export type TrackSizing =
+  | {
+      type: "none";
+    }
+  | {
+      /**
+       * A list of grid track items.
+       */
+      items: TrackListItem[];
+      /**
+       * A list of line names.
+       */
+      lineNames: String[][];
+      type: "track-list";
+    };
+/**
+ * Either a track size or `repeat()` function.
+ *
+ * See [TrackList](TrackList).
+ */
+export type TrackListItem =
+  | {
+      type: "track-size";
+      value: TrackSize;
+    }
+  | {
+      type: "track-repeat";
+      value: TrackRepeat;
+    };
+/**
+ * A [`<track-size>`](https://drafts.csswg.org/css-grid-2/#typedef-track-size) value, as used in the `grid-template-rows` and `grid-template-columns` properties.
+ *
+ * See [TrackListItem](TrackListItem).
+ */
+export type TrackSize =
+  | {
+      type: "track-breadth";
+      value: TrackBreadth;
+    }
+  | {
+      /**
+       * The maximum value.
+       */
+      max: TrackBreadth;
+      /**
+       * The minimum value.
+       */
+      min: TrackBreadth;
+      type: "min-max";
+    }
+  | {
+      type: "fit-content";
+      value: DimensionPercentageFor_LengthValue;
+    };
+/**
+ * A [`<track-breadth>`](https://drafts.csswg.org/css-grid-2/#typedef-track-breadth) value.
+ *
+ * See [TrackSize](TrackSize).
+ */
+export type TrackBreadth =
+  | {
+      type: "length";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "flex";
+      value: number;
+    }
+  | {
+      type: "min-content";
+    }
+  | {
+      type: "max-content";
+    }
+  | {
+      type: "auto";
+    };
+/**
+ * A [`<repeat-count>`](https://drafts.csswg.org/css-grid-2/#typedef-track-repeat) value, used in the `repeat()` function.
+ *
+ * See [TrackRepeat](TrackRepeat).
+ */
+export type RepeatCount =
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "auto-fill";
+    }
+  | {
+      type: "auto-fit";
+    };
+export type AutoFlowDirection = "row" | "column";
+/**
+ * A value for the [grid-template-areas](https://drafts.csswg.org/css-grid-2/#grid-template-areas-property) property. none | <string>+
+ */
+export type GridTemplateAreas =
+  | {
+      type: "none";
+    }
+  | {
+      /**
+       * A flattened list of grid area names. Unnamed areas specified by the `.` token are represented as `None`.
+       */
+      areas: (string | null)[];
+      /**
+       * The number of columns in the grid.
+       */
+      columns: number;
+      type: "areas";
+    };
+/**
+ * A [`<grid-line>`](https://drafts.csswg.org/css-grid-2/#typedef-grid-row-start-grid-line) value, used in the `grid-row-start`, `grid-row-end`, `grid-column-start`, and `grid-column-end` properties.
+ */
+export type GridLine =
+  | {
+      type: "auto";
+    }
+  | {
+      /**
+       * A grid area name.
+       */
+      name: String;
+      type: "area";
+    }
+  | {
+      /**
+       * A line number.
+       */
+      index: number;
+      /**
+       * A line name to filter by.
+       */
+      name?: String | null;
+      type: "line";
+    }
+  | {
+      /**
+       * A line number.
+       */
+      index: number;
+      /**
+       * A line name to filter by.
+       */
+      name?: String | null;
+      type: "span";
+    };
+/**
+ * A value for the [font-weight](https://www.w3.org/TR/css-fonts-4/#font-weight-prop) property.
+ */
+export type FontWeight =
+  | {
+      type: "absolute";
+      value: AbsoluteFontWeight;
+    }
+  | {
+      type: "bolder";
+    }
+  | {
+      type: "lighter";
+    };
+/**
+ * An [absolute font weight](https://www.w3.org/TR/css-fonts-4/#font-weight-absolute-values), as used in the `font-weight` property.
+ *
+ * See [FontWeight](FontWeight).
+ */
+export type AbsoluteFontWeight =
+  | {
+      type: "weight";
+      value: number;
+    }
+  | {
+      type: "normal";
+    }
+  | {
+      type: "bold";
+    };
+/**
+ * A value for the [font-size](https://www.w3.org/TR/css-fonts-4/#font-size-prop) property.
+ */
+export type FontSize =
+  | {
+      type: "length";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "absolute";
+      value: AbsoluteFontSize;
+    }
+  | {
+      type: "relative";
+      value: RelativeFontSize;
+    };
+/**
+ * An [absolute font size](https://www.w3.org/TR/css-fonts-3/#absolute-size-value), as used in the `font-size` property.
+ *
+ * See [FontSize](FontSize).
+ */
+export type AbsoluteFontSize =
+  | "xx-small"
+  | "x-small"
+  | "small"
+  | "medium"
+  | "large"
+  | "x-large"
+  | "xx-large"
+  | "xxx-large";
+/**
+ * A [relative font size](https://www.w3.org/TR/css-fonts-3/#relative-size-value), as used in the `font-size` property.
+ *
+ * See [FontSize](FontSize).
+ */
+export type RelativeFontSize = "smaller" | "larger";
+/**
+ * A value for the [font-stretch](https://www.w3.org/TR/css-fonts-4/#font-stretch-prop) property.
+ */
+export type FontStretch =
+  | {
+      type: "keyword";
+      value: FontStretchKeyword;
+    }
+  | {
+      type: "percentage";
+      value: number;
+    };
+/**
+ * A [font stretch keyword](https://www.w3.org/TR/css-fonts-4/#font-stretch-prop), as used in the `font-stretch` property.
+ *
+ * See [FontStretch](FontStretch).
+ */
+export type FontStretchKeyword =
+  | "normal"
+  | "ultra-condensed"
+  | "extra-condensed"
+  | "condensed"
+  | "semi-condensed"
+  | "semi-expanded"
+  | "expanded"
+  | "extra-expanded"
+  | "ultra-expanded";
+/**
+ * A value for the [font-family](https://www.w3.org/TR/css-fonts-4/#font-family-prop) property.
+ */
+export type FontFamily = GenericFontFamily | String;
+/**
+ * A [generic font family](https://www.w3.org/TR/css-fonts-4/#generic-font-families) name, as used in the `font-family` property.
+ *
+ * See [FontFamily](FontFamily).
+ */
+export type GenericFontFamily =
+  | "serif"
+  | "sans-serif"
+  | "cursive"
+  | "fantasy"
+  | "monospace"
+  | "system-ui"
+  | "emoji"
+  | "math"
+  | "fangsong"
+  | "ui-serif"
+  | "ui-sans-serif"
+  | "ui-monospace"
+  | "ui-rounded"
+  | "initial"
+  | "inherit"
+  | "unset"
+  | "default"
+  | "revert"
+  | "revert-layer";
+/**
+ * A value for the [font-style](https://www.w3.org/TR/css-fonts-4/#font-style-prop) property.
+ */
+export type FontStyle =
+  | {
+      type: "normal";
+    }
+  | {
+      type: "italic";
+    }
+  | {
+      type: "oblique";
+      value: Angle;
+    };
+/**
+ * A value for the [font-variant-caps](https://www.w3.org/TR/css-fonts-4/#font-variant-caps-prop) property.
+ */
+export type FontVariantCaps =
+  | "normal"
+  | "small-caps"
+  | "all-small-caps"
+  | "petite-caps"
+  | "all-petite-caps"
+  | "unicase"
+  | "titling-caps";
+/**
+ * A value for the [line-height](https://www.w3.org/TR/2020/WD-css-inline-3-20200827/#propdef-line-height) property.
+ */
+export type LineHeight =
+  | {
+      type: "normal";
+    }
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "length";
+      value: DimensionPercentageFor_LengthValue;
+    };
+/**
+ * A value for the [vertical align](https://drafts.csswg.org/css2/#propdef-vertical-align) property.
+ */
+export type VerticalAlign =
+  | {
+      type: "keyword";
+      value: VerticalAlignKeyword;
+    }
+  | {
+      type: "length";
+      value: DimensionPercentageFor_LengthValue;
+    };
+/**
+ * A keyword for the [vertical align](https://drafts.csswg.org/css2/#propdef-vertical-align) property.
+ */
+export type VerticalAlignKeyword =
+  | "baseline"
+  | "sub"
+  | "super"
+  | "top"
+  | "text-top"
+  | "middle"
+  | "bottom"
+  | "text-bottom";
+/**
+ * A CSS [easing function](https://www.w3.org/TR/css-easing-1/#easing-functions).
+ */
+export type EasingFunction =
+  | {
+      type: "linear";
+    }
+  | {
+      type: "ease";
+    }
+  | {
+      type: "ease-in";
+    }
+  | {
+      type: "ease-out";
+    }
+  | {
+      type: "ease-in-out";
+    }
+  | {
+      type: "cubic-bezier";
+      /**
+       * The x-position of the first point in the curve.
+       */
+      x1: number;
+      /**
+       * The x-position of the second point in the curve.
+       */
+      x2: number;
+      /**
+       * The y-position of the first point in the curve.
+       */
+      y1: number;
+      /**
+       * The y-position of the second point in the curve.
+       */
+      y2: number;
+    }
+  | {
+      /**
+       * The number of intervals in the function.
+       */
+      count: number;
+      /**
+       * The step position.
+       */
+      position?: StepPosition;
+      type: "steps";
+    };
+/**
+ * A [step position](https://www.w3.org/TR/css-easing-1/#step-position), used within the `steps()` function.
+ */
+export type StepPosition =
+  | {
+      type: "start";
+    }
+  | {
+      type: "end";
+    }
+  | {
+      type: "jump-none";
+    }
+  | {
+      type: "jump-both";
+    };
+/**
+ * A value for the [animation-iteration-count](https://drafts.csswg.org/css-animations/#animation-iteration-count) property.
+ */
+export type AnimationIterationCount =
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "infinite";
+    };
+/**
+ * A value for the [animation-direction](https://drafts.csswg.org/css-animations/#animation-direction) property.
+ */
+export type AnimationDirection = "normal" | "reverse" | "alternate" | "alternate-reverse";
+/**
+ * A value for the [animation-play-state](https://drafts.csswg.org/css-animations/#animation-play-state) property.
+ */
+export type AnimationPlayState = "running" | "paused";
+/**
+ * A value for the [animation-fill-mode](https://drafts.csswg.org/css-animations/#animation-fill-mode) property.
+ */
+export type AnimationFillMode = "none" | "forwards" | "backwards" | "both";
+/**
+ * A value for the [animation-composition](https://drafts.csswg.org/css-animations-2/#animation-composition) property.
+ */
+export type AnimationComposition = "replace" | "add" | "accumulate";
+/**
+ * A value for the [animation-timeline](https://drafts.csswg.org/css-animations-2/#animation-timeline) property.
+ */
+export type AnimationTimeline =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "none";
+    }
+  | {
+      type: "dashed-ident";
+      value: String;
+    }
+  | {
+      type: "scroll";
+      value: ScrollTimeline;
+    }
+  | {
+      type: "view";
+      value: ViewTimeline;
+    };
+/**
+ * A scroll axis, used in the `scroll()` function.
+ */
+export type ScrollAxis = "block" | "inline" | "x" | "y";
+/**
+ * A scroller, used in the `scroll()` function.
+ */
+export type Scroller = "root" | "nearest" | "self";
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ *
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_LengthPercentageOrAuto = [LengthPercentageOrAuto, LengthPercentageOrAuto];
+/**
+ * A value for the [animation-range-start](https://drafts.csswg.org/scroll-animations/#animation-range-start) property.
+ */
+export type AnimationRangeStart = AnimationAttachmentRange;
+/**
+ * A value for the [animation-range-start](https://drafts.csswg.org/scroll-animations/#animation-range-start) or [animation-range-end](https://drafts.csswg.org/scroll-animations/#animation-range-end) property.
+ */
+export type AnimationAttachmentRange =
+  "normal" | DimensionPercentageFor_LengthValue | {
+    /**
+     * The name of the timeline range.
+     */
+    name: TimelineRangeName;
+    /**
+     * The offset from the start of the named timeline range.
+     */
+    offset: DimensionPercentageFor_LengthValue;
+  };
+/**
+ * A [view progress timeline range](https://drafts.csswg.org/scroll-animations/#view-timelines-ranges)
+ */
+export type TimelineRangeName = "cover" | "contain" | "entry" | "exit" | "entry-crossing" | "exit-crossing";
+/**
+ * A value for the [animation-range-end](https://drafts.csswg.org/scroll-animations/#animation-range-end) property.
+ */
+export type AnimationRangeEnd = AnimationAttachmentRange;
+/**
+ * An individual [transform function](https://www.w3.org/TR/2019/CR-css-transforms-1-20190214/#two-d-transform-functions).
+ */
+export type Transform =
+  | {
+      type: "translate";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [DimensionPercentageFor_LengthValue, DimensionPercentageFor_LengthValue];
+    }
+  | {
+      type: "translateX";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "translateY";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "translateZ";
+      value: Length;
+    }
+  | {
+      type: "translate3d";
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [DimensionPercentageFor_LengthValue, DimensionPercentageFor_LengthValue, Length];
+    }
+  | {
+      type: "scale";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [NumberOrPercentage, NumberOrPercentage];
+    }
+  | {
+      type: "scaleX";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "scaleY";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "scaleZ";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "scale3d";
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [NumberOrPercentage, NumberOrPercentage, NumberOrPercentage];
+    }
+  | {
+      type: "rotate";
+      value: Angle;
+    }
+  | {
+      type: "rotateX";
+      value: Angle;
+    }
+  | {
+      type: "rotateY";
+      value: Angle;
+    }
+  | {
+      type: "rotateZ";
+      value: Angle;
+    }
+  | {
+      type: "rotate3d";
+      /**
+       * @minItems 4
+       * @maxItems 4
+       */
+      value: [number, number, number, Angle];
+    }
+  | {
+      type: "skew";
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [Angle, Angle];
+    }
+  | {
+      type: "skewX";
+      value: Angle;
+    }
+  | {
+      type: "skewY";
+      value: Angle;
+    }
+  | {
+      type: "perspective";
+      value: Length;
+    }
+  | {
+      type: "matrix";
+      value: MatrixForFloat;
+    }
+  | {
+      type: "matrix3d";
+      value: Matrix3DForFloat;
+    };
+/**
+ * A value for the [transform-style](https://drafts.csswg.org/css-transforms-2/#transform-style-property) property.
+ */
+export type TransformStyle = "flat" | "preserve3d";
+/**
+ * A value for the [transform-box](https://drafts.csswg.org/css-transforms-1/#transform-box) property.
+ */
+export type TransformBox = "content-box" | "border-box" | "fill-box" | "stroke-box" | "view-box";
+/**
+ * A value for the [backface-visibility](https://drafts.csswg.org/css-transforms-2/#backface-visibility-property) property.
+ */
+export type BackfaceVisibility = "visible" | "hidden";
+/**
+ * A value for the [perspective](https://drafts.csswg.org/css-transforms-2/#perspective-property) property.
+ */
+export type Perspective =
+  | {
+      type: "none";
+    }
+  | {
+      type: "length";
+      value: Length;
+    };
+/**
+ * A value for the [translate](https://drafts.csswg.org/css-transforms-2/#propdef-translate) property.
+ */
+export type Translate =
+  | "none"
+  | {
+    /**
+     * The x translation.
+     */
+    x: DimensionPercentageFor_LengthValue;
+    /**
+     * The y translation.
+     */
+    y: DimensionPercentageFor_LengthValue;
+    /**
+     * The z translation.
+     */
+    z: Length;
+  };
+/**
+ * A value for the [scale](https://drafts.csswg.org/css-transforms-2/#propdef-scale) property.
+ */
+export type Scale =
+  | "none"
+  | {
+    /**
+     * Scale on the x axis.
+     */
+    x: NumberOrPercentage;
+    /**
+     * Scale on the y axis.
+     */
+    y: NumberOrPercentage;
+    /**
+     * Scale on the z axis.
+     */
+    z: NumberOrPercentage;
+  };
+/**
+ * Defines how text case should be transformed in the [text-transform](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-transform-property) property.
+ */
+export type TextTransformCase = "none" | "uppercase" | "lowercase" | "capitalize";
+/**
+ * A value for the [white-space](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#white-space-property) property.
+ */
+export type WhiteSpace = "normal" | "pre" | "nowrap" | "pre-wrap" | "break-spaces" | "pre-line";
+/**
+ * A value for the [word-break](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#word-break-property) property.
+ */
+export type WordBreak = "normal" | "keep-all" | "break-all" | "break-word";
+/**
+ * A value for the [line-break](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#line-break-property) property.
+ */
+export type LineBreak = "auto" | "loose" | "normal" | "strict" | "anywhere";
+/**
+ * A value for the [hyphens](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#hyphenation) property.
+ */
+export type Hyphens = "none" | "manual" | "auto";
+/**
+ * A value for the [overflow-wrap](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#overflow-wrap-property) property.
+ */
+export type OverflowWrap = "normal" | "anywhere" | "break-word";
+/**
+ * A value for the [text-align](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-align-property) property.
+ */
+export type TextAlign = "start" | "end" | "left" | "right" | "center" | "justify" | "match-parent" | "justify-all";
+/**
+ * A value for the [text-align-last](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-align-last-property) property.
+ */
+export type TextAlignLast = "auto" | "start" | "end" | "left" | "right" | "center" | "justify" | "match-parent";
+/**
+ * A value for the [text-justify](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-justify-property) property.
+ */
+export type TextJustify = "auto" | "none" | "inter-word" | "inter-character";
+/**
+ * A value for the [word-spacing](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#word-spacing-property) and [letter-spacing](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#letter-spacing-property) properties.
+ */
+export type Spacing =
+  | {
+      type: "normal";
+    }
+  | {
+      type: "length";
+      value: Length;
+    };
+export type TextDecorationLine = ExclusiveTextDecorationLine | OtherTextDecorationLine[];
+export type ExclusiveTextDecorationLine = "none" | "spelling-error" | "grammar-error";
+export type OtherTextDecorationLine = "underline" | "overline" | "line-through" | "blink";
+/**
+ * A value for the [text-decoration-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-style-property) property.
+ */
+export type TextDecorationStyle = "solid" | "double" | "dotted" | "dashed" | "wavy";
+/**
+ * A value for the [text-decoration-thickness](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-width-property) property.
+ */
+export type TextDecorationThickness =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "from-font";
+    }
+  | {
+      type: "length-percentage";
+      value: DimensionPercentageFor_LengthValue;
+    };
+/**
+ * A value for the [text-decoration-skip-ink](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-skip-ink-property) property.
+ */
+export type TextDecorationSkipInk = "auto" | "none" | "all";
+/**
+ * A value for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property.
+ */
+export type TextEmphasisStyle =
+  | {
+      type: "none";
+    }
+  | {
+      /**
+       * The fill mode for the marks.
+       */
+      fill: TextEmphasisFillMode;
+      /**
+       * The shape of the marks.
+       */
+      shape?: TextEmphasisShape | null;
+      type: "keyword";
+    }
+  | {
+      type: "string";
+      value: String;
+    };
+/**
+ * A keyword for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property.
+ *
+ * See [TextEmphasisStyle](TextEmphasisStyle).
+ */
+export type TextEmphasisFillMode = "filled" | "open";
+/**
+ * A text emphasis shape for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property.
+ *
+ * See [TextEmphasisStyle](TextEmphasisStyle).
+ */
+export type TextEmphasisShape = "dot" | "circle" | "double-circle" | "triangle" | "sesame";
+/**
+ * A horizontal position keyword for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property.
+ *
+ * See [TextEmphasisPosition](TextEmphasisPosition).
+ */
+export type TextEmphasisPositionHorizontal = "left" | "right";
+/**
+ * A vertical position keyword for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property.
+ *
+ * See [TextEmphasisPosition](TextEmphasisPosition).
+ */
+export type TextEmphasisPositionVertical = "over" | "under";
+/**
+ * A value for the [text-size-adjust](https://w3c.github.io/csswg-drafts/css-size-adjust/#adjustment-control) property.
+ */
+export type TextSizeAdjust =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "none";
+    }
+  | {
+      type: "percentage";
+      value: number;
+    };
+/**
+ * A value for the [direction](https://drafts.csswg.org/css-writing-modes-3/#direction) property.
+ */
+export type Direction2 = "ltr" | "rtl";
+/**
+ * A value for the [unicode-bidi](https://drafts.csswg.org/css-writing-modes-3/#unicode-bidi) property.
+ */
+export type UnicodeBidi = "normal" | "embed" | "isolate" | "bidi-override" | "isolate-override" | "plaintext";
+/**
+ * A value for the [box-decoration-break](https://www.w3.org/TR/css-break-3/#break-decoration) property.
+ */
+export type BoxDecorationBreak = "slice" | "clone";
+/**
+ * A value for the [resize](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#resize) property.
+ */
+export type Resize = "none" | "both" | "horizontal" | "vertical" | "block" | "inline";
+/**
+ * A pre-defined [cursor](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) value, used in the `cursor` property.
+ *
+ * See [Cursor](Cursor).
+ */
+export type CursorKeyword =
+  | "auto"
+  | "default"
+  | "none"
+  | "context-menu"
+  | "help"
+  | "pointer"
+  | "progress"
+  | "wait"
+  | "cell"
+  | "crosshair"
+  | "text"
+  | "vertical-text"
+  | "alias"
+  | "copy"
+  | "move"
+  | "no-drop"
+  | "not-allowed"
+  | "grab"
+  | "grabbing"
+  | "e-resize"
+  | "n-resize"
+  | "ne-resize"
+  | "nw-resize"
+  | "s-resize"
+  | "se-resize"
+  | "sw-resize"
+  | "w-resize"
+  | "ew-resize"
+  | "ns-resize"
+  | "nesw-resize"
+  | "nwse-resize"
+  | "col-resize"
+  | "row-resize"
+  | "all-scroll"
+  | "zoom-in"
+  | "zoom-out";
+/**
+ * A value for the [caret-color](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret-color) property.
+ */
+export type ColorOrAuto =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "color";
+      value: CssColor;
+    };
+/**
+ * A value for the [caret-shape](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret-shape) property.
+ */
+export type CaretShape = "auto" | "bar" | "block" | "underscore";
+/**
+ * A value for the [user-select](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#content-selection) property.
+ */
+export type UserSelect = "auto" | "text" | "none" | "contain" | "all";
+export type Appearance = string;
+/**
+ * A value for the [list-style-type](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#text-markers) property.
+ */
+export type ListStyleType =
+  | {
+      type: "none";
+    }
+  | {
+      type: "string";
+      value: String;
+    }
+  | {
+      type: "counter-style";
+      value: CounterStyle;
+    };
+/**
+ * A [counter-style](https://www.w3.org/TR/css-counter-styles-3/#typedef-counter-style) name.
+ */
+export type CounterStyle =
+  | {
+      type: "predefined";
+      value: PredefinedCounterStyle;
+    }
+  | {
+      type: "name";
+      value: String;
+    }
+  | {
+      /**
+       * The symbols.
+       */
+      symbols: Symbol[];
+      /**
+       * The counter system.
+       */
+      system?: SymbolsType & string;
+      type: "symbols";
+    };
+/**
+ * A [predefined counter](https://www.w3.org/TR/css-counter-styles-3/#predefined-counters) style.
+ */
+export type PredefinedCounterStyle =
+  | "decimal"
+  | "decimal-leading-zero"
+  | "arabic-indic"
+  | "armenian"
+  | "upper-armenian"
+  | "lower-armenian"
+  | "bengali"
+  | "cambodian"
+  | "khmer"
+  | "cjk-decimal"
+  | "devanagari"
+  | "georgian"
+  | "gujarati"
+  | "gurmukhi"
+  | "hebrew"
+  | "kannada"
+  | "lao"
+  | "malayalam"
+  | "mongolian"
+  | "myanmar"
+  | "oriya"
+  | "persian"
+  | "lower-roman"
+  | "upper-roman"
+  | "tamil"
+  | "telugu"
+  | "thai"
+  | "tibetan"
+  | "lower-alpha"
+  | "lower-latin"
+  | "upper-alpha"
+  | "upper-latin"
+  | "lower-greek"
+  | "hiragana"
+  | "hiragana-iroha"
+  | "katakana"
+  | "katakana-iroha"
+  | "disc"
+  | "circle"
+  | "square"
+  | "disclosure-open"
+  | "disclosure-closed"
+  | "cjk-earthly-branch"
+  | "cjk-heavenly-stem"
+  | "japanese-informal"
+  | "japanese-formal"
+  | "korean-hangul-formal"
+  | "korean-hanja-informal"
+  | "korean-hanja-formal"
+  | "simp-chinese-informal"
+  | "simp-chinese-formal"
+  | "trad-chinese-informal"
+  | "trad-chinese-formal"
+  | "ethiopic-numeric";
+/**
+ * A single [symbol](https://www.w3.org/TR/css-counter-styles-3/#funcdef-symbols) as used in the `symbols()` function.
+ *
+ * See [CounterStyle](CounterStyle).
+ */
+export type Symbol =
+  | {
+      type: "string";
+      value: String;
+    }
+  | {
+      type: "image";
+      value: Image;
+    };
+/**
+ * A [`<symbols-type>`](https://www.w3.org/TR/css-counter-styles-3/#typedef-symbols-type) value, as used in the `symbols()` function.
+ *
+ * See [CounterStyle](CounterStyle).
+ */
+export type SymbolsType = "cyclic" | "numeric" | "alphabetic" | "symbolic" | "fixed";
+/**
+ * A value for the [list-style-position](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#list-style-position-property) property.
+ */
+export type ListStylePosition = "inside" | "outside";
+/**
+ * A value for the [marker-side](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#marker-side) property.
+ */
+export type MarkerSide = "match-self" | "match-parent";
+/**
+ * An SVG [`<paint>`](https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint) value used in the `fill` and `stroke` properties.
+ */
+export type SVGPaint =
+  | {
+      /**
+       * A fallback to be used used in case the paint server cannot be resolved.
+       */
+      fallback?: SVGPaintFallback | null;
+      type: "url";
+      /**
+       * The url of the paint server.
+       */
+      url: Url;
+    }
+  | {
+      type: "color";
+      value: CssColor;
+    }
+  | {
+      type: "context-fill";
+    }
+  | {
+      type: "context-stroke";
+    }
+  | {
+      type: "none";
+    };
+/**
+ * A fallback for an SVG paint in case a paint server `url()` cannot be resolved.
+ *
+ * See [SVGPaint](SVGPaint).
+ */
+export type SVGPaintFallback =
+  | {
+      type: "none";
+    }
+  | {
+      type: "color";
+      value: CssColor;
+    };
+/**
+ * A [`<fill-rule>`](https://www.w3.org/TR/css-shapes-1/#typedef-fill-rule) used to determine the interior of a `polygon()` shape.
+ *
+ * See [Polygon](Polygon).
+ */
+export type FillRule = "nonzero" | "evenodd";
+/**
+ * A value for the [stroke-linecap](https://www.w3.org/TR/SVG2/painting.html#LineCaps) property.
+ */
+export type StrokeLinecap = "butt" | "round" | "square";
+/**
+ * A value for the [stroke-linejoin](https://www.w3.org/TR/SVG2/painting.html#LineJoin) property.
+ */
+export type StrokeLinejoin = "miter" | "miter-clip" | "round" | "bevel" | "arcs";
+/**
+ * A value for the [stroke-dasharray](https://www.w3.org/TR/SVG2/painting.html#StrokeDashing) property.
+ */
+export type StrokeDasharray =
+  | {
+      type: "none";
+    }
+  | {
+      type: "values";
+      value: DimensionPercentageFor_LengthValue[];
+    };
+/**
+ * A value for the [marker](https://www.w3.org/TR/SVG2/painting.html#VertexMarkerProperties) properties.
+ */
+export type Marker =
+  | {
+      type: "none";
+    }
+  | {
+      type: "url";
+      value: Url;
+    };
+/**
+ * A value for the [color-interpolation](https://www.w3.org/TR/SVG2/painting.html#ColorInterpolation) property.
+ */
+export type ColorInterpolation = "auto" | "srgb" | "linearrgb";
+/**
+ * A value for the [color-rendering](https://www.w3.org/TR/SVG2/painting.html#ColorRendering) property.
+ */
+export type ColorRendering = "auto" | "optimizespeed" | "optimizequality";
+/**
+ * A value for the [shape-rendering](https://www.w3.org/TR/SVG2/painting.html#ShapeRendering) property.
+ */
+export type ShapeRendering = "auto" | "optimizespeed" | "crispedges" | "geometricprecision";
+/**
+ * A value for the [text-rendering](https://www.w3.org/TR/SVG2/painting.html#TextRendering) property.
+ */
+export type TextRendering = "auto" | "optimizespeed" | "optimizelegibility" | "geometricprecision";
+/**
+ * A value for the [image-rendering](https://www.w3.org/TR/SVG2/painting.html#ImageRendering) property.
+ */
+export type ImageRendering = "auto" | "optimizespeed" | "optimizequality";
+/**
+ * A value for the [clip-path](https://www.w3.org/TR/css-masking-1/#the-clip-path) property.
+ */
+export type ClipPath =
+  | {
+      type: "none";
+    }
+  | {
+      type: "url";
+      value: Url;
+    }
+  | {
+      /**
+       * A reference box that the shape is positioned according to.
+       */
+      referenceBox: GeometryBox;
+      /**
+       * A basic shape.
+       */
+      shape: BasicShape;
+      type: "shape";
+    }
+  | {
+      type: "box";
+      value: GeometryBox;
+    };
+/**
+ * A [`<geometry-box>`](https://www.w3.org/TR/css-masking-1/#typedef-geometry-box) value as used in the `mask-clip` and `clip-path` properties.
+ */
+export type GeometryBox =
+  | "border-box"
+  | "padding-box"
+  | "content-box"
+  | "margin-box"
+  | "fill-box"
+  | "stroke-box"
+  | "view-box";
+/**
+ * A CSS [`<basic-shape>`](https://www.w3.org/TR/css-shapes-1/#basic-shape-functions) value.
+ */
+export type BasicShape =
+  | {
+      type: "inset";
+      value: InsetRect;
+    }
+  | {
+      type: "circle";
+      value: Circle2;
+    }
+  | {
+      type: "ellipse";
+      value: Ellipse2;
+    }
+  | {
+      type: "polygon";
+      value: Polygon;
+    };
+/**
+ * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc.
+ *
+ * When serialized, as few components as possible are written when there are duplicate values.
+ *
+ * @minItems 4
+ * @maxItems 4
+ */
+export type RectFor_DimensionPercentageFor_LengthValue = [
+  DimensionPercentageFor_LengthValue,
+  DimensionPercentageFor_LengthValue,
+  DimensionPercentageFor_LengthValue,
+  DimensionPercentageFor_LengthValue
+];
+/**
+ * A [`<shape-radius>`](https://www.w3.org/TR/css-shapes-1/#typedef-shape-radius) value that defines the radius of a `circle()` or `ellipse()` shape.
+ */
+export type ShapeRadius =
+  | {
+      type: "length-percentage";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "closest-side";
+    }
+  | {
+      type: "farthest-side";
+    };
+/**
+ * A value for the [mask-mode](https://www.w3.org/TR/css-masking-1/#the-mask-mode) property.
+ */
+export type MaskMode = "luminance" | "alpha" | "match-source";
+/**
+ * A value for the [mask-clip](https://www.w3.org/TR/css-masking-1/#the-mask-clip) property.
+ */
+export type MaskClip =
+  | {
+      type: "geometry-box";
+      value: GeometryBox;
+    }
+  | {
+      type: "no-clip";
+    };
+/**
+ * A value for the [mask-composite](https://www.w3.org/TR/css-masking-1/#the-mask-composite) property.
+ */
+export type MaskComposite = "add" | "subtract" | "intersect" | "exclude";
+/**
+ * A value for the [mask-type](https://www.w3.org/TR/css-masking-1/#the-mask-type) property.
+ */
+export type MaskType = "luminance" | "alpha";
+/**
+ * A value for the [mask-border-mode](https://www.w3.org/TR/css-masking-1/#the-mask-border-mode) property.
+ */
+export type MaskBorderMode = "luminance" | "alpha";
+/**
+ * A value for the [-webkit-mask-composite](https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-composite) property.
+ *
+ * See also [MaskComposite](MaskComposite).
+ */
+export type WebKitMaskComposite =
+  | ("clear" | "copy" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop")
+  | "source-over"
+  | "source-in"
+  | "source-out"
+  | "xor";
+/**
+ * A value for the [-webkit-mask-source-type](https://github.com/WebKit/WebKit/blob/6eece09a1c31e47489811edd003d1e36910e9fd3/Source/WebCore/css/CSSProperties.json#L6578-L6587) property.
+ *
+ * See also [MaskMode](MaskMode).
+ */
+export type WebKitMaskSourceType = "auto" | "luminance" | "alpha";
+/**
+ * A value for the [filter](https://drafts.fxtf.org/filter-effects-1/#FilterProperty) and [backdrop-filter](https://drafts.fxtf.org/filter-effects-2/#BackdropFilterProperty) properties.
+ */
+export type FilterList =
+  | {
+      type: "none";
+    }
+  | {
+      type: "filters";
+      value: Filter[];
+    };
+/**
+ * A [filter](https://drafts.fxtf.org/filter-effects-1/#filter-functions) function.
+ */
+export type Filter =
+  | {
+      type: "blur";
+      value: Length;
+    }
+  | {
+      type: "brightness";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "contrast";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "grayscale";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "hue-rotate";
+      value: Angle;
+    }
+  | {
+      type: "invert";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "opacity";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "saturate";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "sepia";
+      value: NumberOrPercentage;
+    }
+  | {
+      type: "drop-shadow";
+      value: DropShadow;
+    }
+  | {
+      type: "url";
+      value: Url;
+    };
+/**
+ * A value for the [z-index](https://drafts.csswg.org/css2/#z-index) property.
+ */
+export type ZIndex =
+  | {
+      type: "auto";
+    }
+  | {
+      type: "integer";
+      value: number;
+    };
+/**
+ * A value for the [container-type](https://drafts.csswg.org/css-contain-3/#container-type) property. Establishes the element as a query container for the purpose of container queries.
+ */
+export type ContainerType = "normal" | "inline-size" | "size" | "scroll-state";
+/**
+ * A value for the [container-name](https://drafts.csswg.org/css-contain-3/#container-name) property.
+ */
+export type ContainerNameList =
+  | {
+      type: "none";
+    }
+  | {
+      type: "names";
+      value: String[];
+    };
+/**
+ * A value for the [view-transition-name](https://drafts.csswg.org/css-view-transitions-1/#view-transition-name-prop) property.
+ */
+export type ViewTransitionName =
+  "none" | "auto" | String;
+/**
+ * The `none` keyword, or a space-separated list of custom idents.
+ */
+export type NoneOrCustomIdentList =
+  "none" | String[];
+/**
+ * A value for the [view-transition-group](https://drafts.csswg.org/css-view-transitions-2/#view-transition-group-prop) property.
+ */
+export type ViewTransitionGroup =
+  "normal" | "contain" | "nearest" | String;
+/**
+ * A value for the [print-color-adjust](https://drafts.csswg.org/css-color-adjust/#propdef-print-color-adjust) property.
+ */
+export type PrintColorAdjust = "economy" | "exact";
+/**
+ * A [CSS-wide keyword](https://drafts.csswg.org/css-cascade-5/#defaulting-keywords).
+ */
+export type CSSWideKeyword = "initial" | "inherit" | "unset" | "revert" | "revert-layer";
+/**
+ * A CSS custom property name.
+ */
+export type CustomPropertyName = String | String;
+export type SelectorComponent =
+  | {
+      type: "combinator";
+      value: Combinator;
+    }
+  | {
+      type: "universal";
+    }
+  | (
+      | {
+          type: "namespace";
+          kind: "none";
+        }
+      | {
+          type: "namespace";
+          kind: "any";
+        }
+      | {
+          type: "namespace";
+          kind: "named";
+          prefix: string;
+        }
+    )
+  | {
+      name: string;
+      type: "type";
+    }
+  | {
+      name: string;
+      type: "id";
+    }
+  | {
+      name: string;
+      type: "class";
+    }
+  | {
+      name: string;
+      namespace?: NamespaceConstraint | null;
+      operation?: AttrOperation | null;
+      type: "attribute";
+    }
+  | ({
+      type: "pseudo-class";
+    } & (TSPseudoClass | PseudoClass))
+  | ({
+      type: "pseudo-element";
+    } & (BuiltinPseudoElement | PseudoElement))
+  | {
+      type: "nesting";
+    };
+export type Combinator =
+  | ("child" | "descendant" | "next-sibling" | "later-sibling")
+  | "pseudo-element"
+  | "slot-assignment"
+  | "part"
+  | "deep-descendant"
+  | "deep";
+export type NamespaceConstraint =
+  | {
+      type: "any";
+    }
+  | {
+      prefix: string;
+      type: "specific";
+      url: string;
+    };
+export type ParsedCaseSensitivity =
+  | "explicit-case-sensitive"
+  | "ascii-case-insensitive"
+  | "case-sensitive"
+  | "ascii-case-insensitive-if-in-html-element-in-html-document";
+export type AttrSelectorOperator = "equal" | "includes" | "dash-match" | "prefix" | "substring" | "suffix";
+export type TSPseudoClass =
+  | {
+      kind: "not";
+      selectors: Selector[];
+    }
+  | {
+      kind: "first-child";
+    }
+  | {
+      kind: "last-child";
+    }
+  | {
+      kind: "only-child";
+    }
+  | {
+      kind: "root";
+    }
+  | {
+      kind: "empty";
+    }
+  | {
+      kind: "scope";
+    }
+  | {
+      a: number;
+      b: number;
+      kind: "nth-child";
+      of?: Selector[] | null;
+    }
+  | {
+      a: number;
+      b: number;
+      kind: "nth-last-child";
+      of?: Selector[] | null;
+    }
+  | {
+      a: number;
+      b: number;
+      kind: "nth-col";
+    }
+  | {
+      a: number;
+      b: number;
+      kind: "nth-last-col";
+    }
+  | {
+      a: number;
+      b: number;
+      kind: "nth-of-type";
+    }
+  | {
+      a: number;
+      b: number;
+      kind: "nth-last-of-type";
+    }
+  | {
+      kind: "first-of-type";
+    }
+  | {
+      kind: "last-of-type";
+    }
+  | {
+      kind: "only-of-type";
+    }
+  | {
+      kind: "host";
+      selectors?: Selector | null;
+    }
+  | {
+      kind: "where";
+      selectors: Selector[];
+    }
+  | {
+      kind: "is";
+      selectors: Selector[];
+    }
+  | {
+      kind: "any";
+      selectors: Selector[];
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "has";
+      selectors: Selector[];
+    };
+/**
+ * A pseudo class.
+ */
+export type PseudoClass =
+  | {
+      kind: "lang";
+      /**
+       * A list of language codes.
+       */
+      languages: String[];
+    }
+  | {
+      /**
+       * A direction.
+       */
+      direction: Direction;
+      kind: "dir";
+    }
+  | {
+      kind: "hover";
+    }
+  | {
+      kind: "active";
+    }
+  | {
+      kind: "focus";
+    }
+  | {
+      kind: "focus-visible";
+    }
+  | {
+      kind: "focus-within";
+    }
+  | {
+      kind: "current";
+    }
+  | {
+      kind: "past";
+    }
+  | {
+      kind: "future";
+    }
+  | {
+      kind: "playing";
+    }
+  | {
+      kind: "paused";
+    }
+  | {
+      kind: "seeking";
+    }
+  | {
+      kind: "buffering";
+    }
+  | {
+      kind: "stalled";
+    }
+  | {
+      kind: "muted";
+    }
+  | {
+      kind: "volume-locked";
+    }
+  | {
+      kind: "fullscreen";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "open";
+    }
+  | {
+      kind: "closed";
+    }
+  | {
+      kind: "modal";
+    }
+  | {
+      kind: "picture-in-picture";
+    }
+  | {
+      kind: "popover-open";
+    }
+  | {
+      kind: "defined";
+    }
+  | {
+      kind: "any-link";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "link";
+    }
+  | {
+      kind: "local-link";
+    }
+  | {
+      kind: "target";
+    }
+  | {
+      kind: "target-within";
+    }
+  | {
+      kind: "visited";
+    }
+  | {
+      kind: "enabled";
+    }
+  | {
+      kind: "disabled";
+    }
+  | {
+      kind: "read-only";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "read-write";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "placeholder-shown";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "default";
+    }
+  | {
+      kind: "checked";
+    }
+  | {
+      kind: "indeterminate";
+    }
+  | {
+      kind: "blank";
+    }
+  | {
+      kind: "valid";
+    }
+  | {
+      kind: "invalid";
+    }
+  | {
+      kind: "in-range";
+    }
+  | {
+      kind: "out-of-range";
+    }
+  | {
+      kind: "required";
+    }
+  | {
+      kind: "optional";
+    }
+  | {
+      kind: "user-valid";
+    }
+  | {
+      kind: "user-invalid";
+    }
+  | {
+      kind: "autofill";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "active-view-transition";
+    }
+  | {
+      kind: "active-view-transition-type";
+      /**
+       * A view transition type.
+       */
+      type: String[];
+    }
+  | {
+      kind: "state";
+      /**
+       * The custom state identifier.
+       */
+      state: String;
+    }
+  | {
+      kind: "local";
+      /**
+       * A local selector.
+       */
+      selector: Selector;
+    }
+  | {
+      kind: "global";
+      /**
+       * A global selector.
+       */
+      selector: Selector;
+    }
+  | {
+      kind: "webkit-scrollbar";
+      value: WebKitScrollbarPseudoClass;
+    }
+  | {
+      kind: "custom";
+      /**
+       * The pseudo class name.
+       */
+      name: String;
+    }
+  | {
+      /**
+       * The arguments of the pseudo class function.
+       */
+      arguments: TokenOrValue[];
+      kind: "custom-function";
+      /**
+       * The pseudo class name.
+       */
+      name: String;
+    };
+/**
+ * The [:dir()](https://drafts.csswg.org/selectors-4/#the-dir-pseudo) pseudo class.
+ */
+export type Direction = "ltr" | "rtl";
+/**
+ * A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo class.
+ */
+export type WebKitScrollbarPseudoClass =
+  | "horizontal"
+  | "vertical"
+  | "decrement"
+  | "increment"
+  | "start"
+  | "end"
+  | "double-button"
+  | "single-button"
+  | "no-button"
+  | "corner-present"
+  | "window-inactive";
+export type BuiltinPseudoElement =
+  | {
+      kind: "slotted";
+      selector: Selector;
+    }
+  | {
+      kind: "part";
+      names: string[];
+    };
+/**
+ * A pseudo element.
+ */
+export type PseudoElement =
+  | {
+      kind: "after";
+    }
+  | {
+      kind: "before";
+    }
+  | {
+      kind: "first-line";
+    }
+  | {
+      kind: "first-letter";
+    }
+  | {
+      kind: "details-content";
+    }
+  | {
+      kind: "target-text";
+    }
+  | {
+      kind: "selection";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "placeholder";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "marker";
+    }
+  | {
+      kind: "backdrop";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "file-selector-button";
+      vendorPrefix: VendorPrefix;
+    }
+  | {
+      kind: "webkit-scrollbar";
+      value: WebKitScrollbarPseudoElement;
+    }
+  | {
+      kind: "cue";
+    }
+  | {
+      kind: "cue-region";
+    }
+  | {
+      kind: "cue-function";
+      /**
+       * The selector argument.
+       */
+      selector: Selector;
+    }
+  | {
+      kind: "cue-region-function";
+      /**
+       * The selector argument.
+       */
+      selector: Selector;
+    }
+  | {
+      kind: "view-transition";
+    }
+  | {
+      kind: "view-transition-group";
+      /**
+       * A part name selector.
+       */
+      part: ViewTransitionPartSelector;
+    }
+  | {
+      kind: "view-transition-image-pair";
+      /**
+       * A part name selector.
+       */
+      part: ViewTransitionPartSelector;
+    }
+  | {
+      kind: "view-transition-old";
+      /**
+       * A part name selector.
+       */
+      part: ViewTransitionPartSelector;
+    }
+  | {
+      kind: "view-transition-new";
+      /**
+       * A part name selector.
+       */
+      part: ViewTransitionPartSelector;
+    }
+  | {
+      /**
+       * A form control identifier.
+       */
+      identifier: String;
+      kind: "picker-function";
+    }
+  | {
+      kind: "picker-icon";
+    }
+  | {
+      kind: "checkmark";
+    }
+  | {
+      kind: "grammar-error";
+    }
+  | {
+      kind: "spelling-error";
+    }
+  | {
+      kind: "custom";
+      /**
+       * The name of the pseudo element.
+       */
+      name: String;
+    }
+  | {
+      /**
+       * The arguments of the pseudo element function.
+       */
+      arguments: TokenOrValue[];
+      kind: "custom-function";
+      /**
+       * The name of the pseudo element.
+       */
+      name: String;
+    };
+/**
+ * A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo element.
+ */
+export type WebKitScrollbarPseudoElement =
+  | "scrollbar"
+  | "button"
+  | "track"
+  | "track-piece"
+  | "thumb"
+  | "corner"
+  | "resizer";
+export type ViewTransitionPartName = string;
+export type Selector = SelectorComponent[];
+export type SelectorList = Selector[];
+/**
+ * A [keyframe selector](https://drafts.csswg.org/css-animations/#typedef-keyframe-selector) within an `@keyframes` rule.
+ */
+export type KeyframeSelector =
+  | {
+      type: "percentage";
+      value: number;
+    }
+  | {
+      type: "from";
+    }
+  | {
+      type: "to";
+    }
+  | {
+      type: "timeline-range-percentage";
+      value: TimelineRangePercentage;
+    };
+/**
+ * KeyframesName
+ */
+export type KeyframesName =
+  | {
+      type: "ident";
+      value: String;
+    }
+  | {
+      type: "custom";
+      value: String;
+    };
+/**
+ * A property within an `@font-face` rule.
+ *
+ * See [FontFaceRule](FontFaceRule).
+ */
+export type FontFaceProperty =
+  | {
+      type: "source";
+      value: Source[];
+    }
+  | {
+      type: "font-family";
+      value: FontFamily;
+    }
+  | {
+      type: "font-style";
+      value: FontStyle2;
+    }
+  | {
+      type: "font-weight";
+      value: Size2DFor_FontWeight;
+    }
+  | {
+      type: "font-stretch";
+      value: Size2DFor_FontStretch;
+    }
+  | {
+      type: "unicode-range";
+      value: UnicodeRange[];
+    }
+  | {
+      type: "custom";
+      value: CustomProperty;
+    };
+/**
+ * A value for the [src](https://drafts.csswg.org/css-fonts/#src-desc) property in an `@font-face` rule.
+ */
+export type Source =
+  | {
+      type: "url";
+      value: UrlSource;
+    }
+  | {
+      type: "local";
+      value: FontFamily;
+    };
+/**
+ * A font format keyword in the `format()` function of the the [src](https://drafts.csswg.org/css-fonts/#src-desc) property of an `@font-face` rule.
+ */
+export type FontFormat =
+  | {
+      type: "woff";
+    }
+  | {
+      type: "woff2";
+    }
+  | {
+      type: "truetype";
+    }
+  | {
+      type: "opentype";
+    }
+  | {
+      type: "embedded-opentype";
+    }
+  | {
+      type: "collection";
+    }
+  | {
+      type: "svg";
+    }
+  | {
+      type: "string";
+      value: String;
+    };
+/**
+ * A font format keyword in the `format()` function of the the [src](https://drafts.csswg.org/css-fonts/#src-desc) property of an `@font-face` rule.
+ */
+export type FontTechnology =
+  | "features-opentype"
+  | "features-aat"
+  | "features-graphite"
+  | "color-colrv0"
+  | "color-colrv1"
+  | "color-svg"
+  | "color-sbix"
+  | "color-cbdt"
+  | "variations"
+  | "palettes"
+  | "incremental";
+/**
+ * A value for the [font-style](https://w3c.github.io/csswg-drafts/css-fonts/#descdef-font-face-font-style) descriptor in an `@font-face` rule.
+ */
+export type FontStyle2 =
+  | {
+      type: "normal";
+    }
+  | {
+      type: "italic";
+    }
+  | {
+      type: "oblique";
+      value: Size2DFor_Angle;
+    };
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ *
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_Angle = [Angle, Angle];
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ *
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_FontWeight = [FontWeight, FontWeight];
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ *
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_FontStretch = [FontStretch, FontStretch];
+/**
+ * A property within an `@font-palette-values` rule.
+ *
+ * See [FontPaletteValuesRule](FontPaletteValuesRule).
+ */
+export type FontPaletteValuesProperty =
+  | {
+      type: "font-family";
+      value: FontFamily;
+    }
+  | {
+      type: "base-palette";
+      value: BasePalette;
+    }
+  | {
+      type: "override-colors";
+      value: OverrideColors[];
+    }
+  | {
+      type: "custom";
+      value: CustomProperty;
+    };
+/**
+ * A value for the [base-palette](https://drafts.csswg.org/css-fonts-4/#base-palette-desc) property in an `@font-palette-values` rule.
+ */
+export type BasePalette =
+  | {
+      type: "light";
+    }
+  | {
+      type: "dark";
+    }
+  | {
+      type: "integer";
+      value: number;
+    };
+/**
+ * The name of the `@font-feature-values` sub-rule. font-feature-value-type = <@stylistic> | <@historical-forms> | <@styleset> | <@character-variant> | <@swash> | <@ornaments> | <@annotation>
+ */
+export type FontFeatureSubruleType =
+  | "stylistic"
+  | "historical-forms"
+  | "styleset"
+  | "character-variant"
+  | "swash"
+  | "ornaments"
+  | "annotation";
+/**
+ * A [page margin box](https://www.w3.org/TR/css-page-3/#margin-boxes).
+ */
+export type PageMarginBox =
+  | "top-left-corner"
+  | "top-left"
+  | "top-center"
+  | "top-right"
+  | "top-right-corner"
+  | "left-top"
+  | "left-middle"
+  | "left-bottom"
+  | "right-top"
+  | "right-middle"
+  | "right-bottom"
+  | "bottom-left-corner"
+  | "bottom-left"
+  | "bottom-center"
+  | "bottom-right"
+  | "bottom-right-corner";
+/**
+ * A page pseudo class within an `@page` selector.
+ *
+ * See [PageSelector](PageSelector).
+ */
+export type PagePseudoClass = "left" | "right" | "first" | "last" | "blank";
+/**
+ * A parsed value for a [SyntaxComponent](SyntaxComponent).
+ */
+export type ParsedComponent =
+  | {
+      type: "length";
+      value: Length;
+    }
+  | {
+      type: "number";
+      value: number;
+    }
+  | {
+      type: "percentage";
+      value: number;
+    }
+  | {
+      type: "length-percentage";
+      value: DimensionPercentageFor_LengthValue;
+    }
+  | {
+      type: "string";
+      value: String;
+    }
+  | {
+      type: "color";
+      value: CssColor;
+    }
+  | {
+      type: "image";
+      value: Image;
+    }
+  | {
+      type: "url";
+      value: Url;
+    }
+  | {
+      type: "integer";
+      value: number;
+    }
+  | {
+      type: "angle";
+      value: Angle;
+    }
+  | {
+      type: "time";
+      value: Time;
+    }
+  | {
+      type: "resolution";
+      value: Resolution;
+    }
+  | {
+      type: "transform-function";
+      value: Transform;
+    }
+  | {
+      type: "transform-list";
+      value: Transform[];
+    }
+  | {
+      type: "custom-ident";
+      value: String;
+    }
+  | {
+      type: "literal";
+      value: String;
+    }
+  | {
+      type: "repeated";
+      value: {
+        /**
+         * The components to repeat.
+         */
+        components: ParsedComponent[];
+        /**
+         * A multiplier describing how the components repeat.
+         */
+        multiplier: Multiplier;
+      };
+    }
+  | {
+      type: "token-list";
+      value: TokenOrValue[];
+    };
+/**
+ * A [multiplier](https://drafts.css-houdini.org/css-properties-values-api/#multipliers) for a [SyntaxComponent](SyntaxComponent). Indicates whether and how the component may be repeated.
+ */
+export type Multiplier =
+  | {
+      type: "none";
+    }
+  | {
+      type: "space";
+    }
+  | {
+      type: "comma";
+    };
+/**
+ * A CSS [syntax string](https://drafts.css-houdini.org/css-properties-values-api/#syntax-strings) used to define the grammar for a registered custom property.
+ */
+export type SyntaxString =
+  | {
+      type: "components";
+      value: SyntaxComponent[];
+    }
+  | {
+      type: "universal";
+    };
+/**
+ * A [syntax component component name](https://drafts.css-houdini.org/css-properties-values-api/#supported-names).
+ */
+export type SyntaxComponentKind =
+  | {
+      type: "length";
+    }
+  | {
+      type: "number";
+    }
+  | {
+      type: "percentage";
+    }
+  | {
+      type: "length-percentage";
+    }
+  | {
+      type: "string";
+    }
+  | {
+      type: "color";
+    }
+  | {
+      type: "image";
+    }
+  | {
+      type: "url";
+    }
+  | {
+      type: "integer";
+    }
+  | {
+      type: "angle";
+    }
+  | {
+      type: "time";
+    }
+  | {
+      type: "resolution";
+    }
+  | {
+      type: "transform-function";
+    }
+  | {
+      type: "transform-list";
+    }
+  | {
+      type: "custom-ident";
+    }
+  | {
+      type: "literal";
+      value: string;
+    };
+/**
+ * Represents a container condition.
+ */
+export type ContainerCondition<D = Declaration> = | {
+    type: "feature";
+    value: QueryFeatureFor_ContainerSizeFeatureId;
+  }
+| {
+    type: "not";
+    value: ContainerCondition<D>;
+  }
+| {
+    /**
+     * The conditions for the operator.
+     */
+    conditions: ContainerCondition<D>[];
+    /**
+     * The operator for the conditions.
+     */
+    operator: Operator;
+    type: "operation";
+  }
+| {
+    type: "style";
+    value: StyleQuery<D>;
+  }
+| {
+    type: "scroll-state";
+    value: ScrollStateQuery;
+  }
+| {
+    type: "unknown";
+    value: TokenOrValue[];
+  };
+/**
+ * A generic media feature or container feature.
+ */
+export type QueryFeatureFor_ContainerSizeFeatureId =
+  | {
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ContainerSizeFeatureId;
+      type: "plain";
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue;
+    }
+  | {
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ContainerSizeFeatureId;
+      type: "boolean";
+    }
+  | {
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ContainerSizeFeatureId;
+      /**
+       * A comparator.
+       */
+      operator: MediaFeatureComparison;
+      type: "range";
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue;
+    }
+  | {
+      /**
+       * The end value.
+       */
+      end: MediaFeatureValue;
+      /**
+       * A comparator for the end value.
+       */
+      endOperator: MediaFeatureComparison;
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ContainerSizeFeatureId;
+      /**
+       * A start value.
+       */
+      start: MediaFeatureValue;
+      /**
+       * A comparator for the start value.
+       */
+      startOperator: MediaFeatureComparison;
+      type: "interval";
+    };
+/**
+ * A media feature name.
+ */
+export type MediaFeatureNameFor_ContainerSizeFeatureId = ContainerSizeFeatureId | String | String;
+/**
+ * A container query size feature identifier.
+ */
+export type ContainerSizeFeatureId = "width" | "height" | "inline-size" | "block-size" | "aspect-ratio" | "orientation";
+/**
+ * Represents a style query within a container condition.
+ */
+export type StyleQuery<D = Declaration> = | {
+    type: "declaration";
+    value: D;
+  }
+| {
+    type: "property";
+    value: PropertyId;
+  }
+| {
+    type: "not";
+    value: StyleQuery<D>;
+  }
+| {
+    /**
+     * The conditions for the operator.
+     */
+    conditions: StyleQuery<D>[];
+    /**
+     * The operator for the conditions.
+     */
+    operator: Operator;
+    type: "operation";
+  };
+/**
+ * Represents a scroll state query within a container condition.
+ */
+export type ScrollStateQuery =
+  | {
+      type: "feature";
+      value: QueryFeatureFor_ScrollStateFeatureId;
+    }
+  | {
+      type: "not";
+      value: ScrollStateQuery;
+    }
+  | {
+      /**
+       * The conditions for the operator.
+       */
+      conditions: ScrollStateQuery[];
+      /**
+       * The operator for the conditions.
+       */
+      operator: Operator;
+      type: "operation";
+    };
+/**
+ * A generic media feature or container feature.
+ */
+export type QueryFeatureFor_ScrollStateFeatureId =
+  | {
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ScrollStateFeatureId;
+      type: "plain";
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue;
+    }
+  | {
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ScrollStateFeatureId;
+      type: "boolean";
+    }
+  | {
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ScrollStateFeatureId;
+      /**
+       * A comparator.
+       */
+      operator: MediaFeatureComparison;
+      type: "range";
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue;
+    }
+  | {
+      /**
+       * The end value.
+       */
+      end: MediaFeatureValue;
+      /**
+       * A comparator for the end value.
+       */
+      endOperator: MediaFeatureComparison;
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ScrollStateFeatureId;
+      /**
+       * A start value.
+       */
+      start: MediaFeatureValue;
+      /**
+       * A comparator for the start value.
+       */
+      startOperator: MediaFeatureComparison;
+      type: "interval";
+    };
+/**
+ * A media feature name.
+ */
+export type MediaFeatureNameFor_ScrollStateFeatureId = ScrollStateFeatureId | String | String;
+/**
+ * A container query scroll state feature identifier.
+ */
+export type ScrollStateFeatureId = "stuck" | "snapped" | "scrollable" | "scrolled";
+/**
+ * A property within a `@view-transition` rule.
+ *
+ * See [ViewTransitionRule](ViewTransitionRule).
+ */
+export type ViewTransitionProperty =
+  | {
+      property: "navigation";
+      value: Navigation;
+    }
+  | {
+      property: "types";
+      value: NoneOrCustomIdentList;
+    }
+  | {
+      property: "custom";
+      value: CustomProperty;
+    };
+/**
+ * A value for the [navigation](https://drafts.csswg.org/css-view-transitions-2/#view-transition-navigation-descriptor) property in a `@view-transition` rule.
+ */
+export type Navigation = "none" | "auto";
+export type DefaultAtRule = null;
+
+/**
+ * A CSS style sheet, representing a `.css` file or inline `<style>` element.
+ *
+ * Style sheets can be parsed from a string, constructed from scratch, or created using a [Bundler](super::bundler::Bundler). Then, they can be minified and transformed for a set of target browsers, and serialied to a string.
+ *
+ * # Example
+ *
+ * ``` use lightningcss::stylesheet::{ StyleSheet, ParserOptions, MinifyOptions, PrinterOptions };
+ *
+ * // Parse a style sheet from a string. let mut stylesheet = StyleSheet::parse( r#" .foo { color: red; }
+ *
+ * .bar { color: red; } "#, ParserOptions::default() ).unwrap();
+ *
+ * // Minify the stylesheet. stylesheet.minify(MinifyOptions::default()).unwrap();
+ *
+ * // Serialize it to a string. let res = stylesheet.to_css(PrinterOptions::default()).unwrap(); assert_eq!(res.code, ".foo, .bar {\n  color: red;\n}\n"); ```
+ */
+export interface StyleSheet<D = Declaration, M = MediaQuery> {
+  /**
+   * The license comments that appeared at the start of the file.
+   */
+  licenseComments: String[];
+  /**
+   * A list of top-level rules within the style sheet.
+   */
+  rules: Rule<D, M>[];
+  /**
+   * The source map URL extracted from the original style sheet.
+   */
+  sourceMapUrls: (string | null)[];
+  /**
+   * A list of file names for all source files included within the style sheet. Sources are referenced by index in the `loc` property of each rule.
+   */
+  sources: string[];
+}
+/**
+ * A [@media](https://drafts.csswg.org/css-conditional-3/#at-media) rule.
+ */
+export interface MediaRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The media query list.
+   */
+  query: MediaList<M>;
+  /**
+   * The rules within the `@media` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A source location.
+ */
+export interface Location2 {
+  /**
+   * The column number within a line, starting at 1 for first the character of the line. Column numbers are counted in UTF-16 code units.
+   */
+  column: number;
+  /**
+   * The line number, starting at 0.
+   */
+  line: number;
+  /**
+   * The index of the source file within the source map.
+   */
+  source_index: number;
+}
+/**
+ * A [media query list](https://drafts.csswg.org/mediaqueries/#mq-list).
+ */
+export interface MediaList<M = MediaQuery> {
+  /**
+   * The list of media queries.
+   */
+  mediaQueries: M[];
+}
+/**
+ * A [media query](https://drafts.csswg.org/mediaqueries/#media).
+ */
+export interface MediaQuery {
+  /**
+   * The condition that this media query contains. This cannot have `or` in the first level.
+   */
+  condition?: MediaCondition | null;
+  /**
+   * The media type for this query, that can be known, unknown, or "all".
+   */
+  mediaType: MediaType;
+  /**
+   * The qualifier for this query.
+   */
+  qualifier?: Qualifier | null;
+}
+export interface LengthValue {
+  /**
+   * The length unit.
+   */
+  unit: LengthUnit;
+  /**
+   * The length value.
+   */
+  value: number;
+}
+/**
+ * A CSS environment variable reference.
+ */
+export interface EnvironmentVariable {
+  /**
+   * A fallback value in case the variable is not defined.
+   */
+  fallback?: TokenOrValue[] | null;
+  /**
+   * Optional indices into the dimensions of the environment variable.
+   */
+  indices?: number[];
+  /**
+   * The environment variable name.
+   */
+  name: EnvironmentVariableName;
+}
+/**
+ * A CSS [url()](https://www.w3.org/TR/css-values-4/#urls) value and its source location.
+ */
+export interface Url {
+  /**
+   * The location where the `url()` was seen in the CSS source file.
+   */
+  loc: Location;
+  /**
+   * The url string.
+   */
+  url: String;
+}
+/**
+ * A line and column position within a source file.
+ */
+export interface Location {
+  /**
+   * The column number, starting from 1.
+   */
+  column: number;
+  /**
+   * The line number, starting from 1.
+   */
+  line: number;
+}
+/**
+ * A CSS variable reference.
+ */
+export interface Variable {
+  /**
+   * A fallback value in case the variable is not defined.
+   */
+  fallback?: TokenOrValue[] | null;
+  /**
+   * The variable name.
+   */
+  name: DashedIdentReference;
+}
+/**
+ * A CSS [`<dashed-ident>`](https://www.w3.org/TR/css-values-4/#dashed-idents) reference.
+ *
+ * Dashed idents are used in cases where an identifier can be either author defined _or_ CSS-defined. Author defined idents must start with two dash characters ("--") or parsing will fail.
+ *
+ * In CSS modules, when the `dashed_idents` option is enabled, the identifier may be followed by the `from` keyword and an argument indicating where the referenced identifier is declared (e.g. a filename).
+ */
+export interface DashedIdentReference {
+  /**
+   * CSS modules extension: the filename where the variable is defined. Only enabled when the CSS modules `dashed_idents` option is turned on.
+   */
+  from?: Specifier | null;
+  /**
+   * The referenced identifier.
+   */
+  ident: String;
+}
+/**
+ * A custom CSS function.
+ */
+export interface Function {
+  /**
+   * The function arguments.
+   */
+  arguments: TokenOrValue[];
+  /**
+   * The function name.
+   */
+  name: String;
+}
+/**
+ * A [@import](https://drafts.csswg.org/css-cascade/#at-import) rule.
+ */
+export interface ImportRule<M = MediaQuery> {
+  /**
+   * An optional cascade layer name, or `None` for an anonymous layer.
+   */
+  layer?: String[] | null;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * A media query.
+   */
+  media?: MediaList<M>;
+  /**
+   * An optional `supports()` condition.
+   */
+  supports?: SupportsCondition | null;
+  /**
+   * The url to import.
+   */
+  url: String;
+}
+/**
+ * A CSS [style rule](https://drafts.csswg.org/css-syntax/#style-rules).
+ */
+export interface StyleRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The declarations within the style rule.
+   */
+  declarations?: DeclarationBlock<D>;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * Nested rules within the style rule.
+   */
+  rules?: Rule<D, M>[];
+  /**
+   * The selectors for the style rule.
+   */
+  selectors: SelectorList;
+}
+/**
+ * A CSS declaration block.
+ *
+ * Properties are separated into a list of `!important` declararations, and a list of normal declarations. This reduces memory usage compared with storing a boolean along with each property.
+ */
+export interface DeclarationBlock<D = Declaration> {
+  /**
+   * A list of normal declarations in the block.
+   */
+  declarations?: D[];
+  /**
+   * A list of `!important` declarations in the block.
+   */
+  importantDeclarations?: D[];
+}
+/**
+ * A CSS [`<position>`](https://www.w3.org/TR/css3-values/#position) value, as used in the `background-position` property, gradients, masks, etc.
+ */
+export interface Position {
+  /**
+   * The x-position.
+   */
+  x: PositionComponentFor_HorizontalPositionKeyword;
+  /**
+   * The y-position.
+   */
+  y: PositionComponentFor_VerticalPositionKeyword;
+}
+/**
+ * An x/y position within a legacy `-webkit-gradient()`.
+ */
+export interface WebKitGradientPoint {
+  /**
+   * The x-position.
+   */
+  x: WebKitGradientPointComponentFor_HorizontalPositionKeyword;
+  /**
+   * The y-position.
+   */
+  y: WebKitGradientPointComponentFor_VerticalPositionKeyword;
+}
+/**
+ * A color stop within a legacy `-webkit-gradient()`.
+ */
+export interface WebKitColorStop {
+  /**
+   * The color of the color stop.
+   */
+  color: CssColor;
+  /**
+   * The position of the color stop.
+   */
+  position: number;
+}
+/**
+ * A CSS [`image-set()`](https://drafts.csswg.org/css-images-4/#image-set-notation) value.
+ *
+ * `image-set()` allows the user agent to choose between multiple versions of an image to display the most appropriate resolution or file type that it supports.
+ */
+export interface ImageSet {
+  /**
+   * The image options to choose from.
+   */
+  options: ImageSetOption[];
+  /**
+   * The vendor prefix for the `image-set()` function.
+   */
+  vendorPrefix: VendorPrefix;
+}
+/**
+ * An image option within the `image-set()` function. See [ImageSet](ImageSet).
+ */
+export interface ImageSetOption {
+  /**
+   * The mime type of the image.
+   */
+  fileType?: String | null;
+  /**
+   * The image for this option.
+   */
+  image: Image;
+  /**
+   * The resolution of the image.
+   */
+  resolution: Resolution;
+}
+/**
+ * A value for the [background-position](https://drafts.csswg.org/css-backgrounds/#background-position) shorthand property.
+ */
+export interface BackgroundPosition {
+  /**
+   * The x-position.
+   */
+  x: PositionComponentFor_HorizontalPositionKeyword;
+  /**
+   * The y-position.
+   */
+  y: PositionComponentFor_VerticalPositionKeyword;
+}
+/**
+ * A value for the [background-repeat](https://www.w3.org/TR/css-backgrounds-3/#background-repeat) property.
+ */
+export interface BackgroundRepeat {
+  /**
+   * A repeat style for the x direction.
+   */
+  x: BackgroundRepeatKeyword;
+  /**
+   * A repeat style for the y direction.
+   */
+  y: BackgroundRepeatKeyword;
+}
+/**
+ * A value for the [background](https://www.w3.org/TR/css-backgrounds-3/#background) shorthand property.
+ */
+export interface Background {
+  /**
+   * The background attachment.
+   */
+  attachment: BackgroundAttachment;
+  /**
+   * How the background should be clipped.
+   */
+  clip: BackgroundClip;
+  /**
+   * The background color.
+   */
+  color: CssColor;
+  /**
+   * The background image.
+   */
+  image: Image;
+  /**
+   * The background origin.
+   */
+  origin: BackgroundOrigin;
+  /**
+   * The background position.
+   */
+  position: BackgroundPosition;
+  /**
+   * How the background image should repeat.
+   */
+  repeat: BackgroundRepeat;
+  /**
+   * The size of the background image.
+   */
+  size: BackgroundSize;
+}
+/**
+ * A value for the [box-shadow](https://drafts.csswg.org/css-backgrounds/#box-shadow) property.
+ */
+export interface BoxShadow {
+  /**
+   * The blur radius of the shadow.
+   */
+  blur: Length;
+  /**
+   * The color of the box shadow.
+   */
+  color: CssColor;
+  /**
+   * Whether the shadow is inset within the box.
+   */
+  inset: boolean;
+  /**
+   * The spread distance of the shadow.
+   */
+  spread: Length;
+  /**
+   * The x offset of the shadow.
+   */
+  xOffset: Length;
+  /**
+   * The y offset of the shadow.
+   */
+  yOffset: Length;
+}
+/**
+ * A value for the [aspect-ratio](https://drafts.csswg.org/css-sizing-4/#aspect-ratio) property.
+ */
+export interface AspectRatio {
+  /**
+   * The `auto` keyword.
+   */
+  auto: boolean;
+  /**
+   * A preferred aspect ratio for the box, specified as width / height.
+   */
+  ratio?: Ratio | null;
+}
+/**
+ * A value for the [overflow](https://www.w3.org/TR/css-overflow-3/#overflow-properties) shorthand property.
+ */
+export interface Overflow {
+  /**
+   * The overflow mode for the x direction.
+   */
+  x: OverflowKeyword;
+  /**
+   * The overflow mode for the y direction.
+   */
+  y: OverflowKeyword;
+}
+/**
+ * A value for the [inset-block](https://drafts.csswg.org/css-logical/#propdef-inset-block) shorthand property.
+ */
+export interface InsetBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [inset-inline](https://drafts.csswg.org/css-logical/#propdef-inset-inline) shorthand property.
+ */
+export interface InsetInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [inset](https://drafts.csswg.org/css-logical/#propdef-inset) shorthand property.
+ */
+export interface Inset {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [border-radius](https://www.w3.org/TR/css-backgrounds-3/#border-radius) property.
+ */
+export interface BorderRadius {
+  /**
+   * The x and y radius values for the bottom left corner.
+   */
+  bottomLeft: Size2DFor_DimensionPercentageFor_LengthValue;
+  /**
+   * The x and y radius values for the bottom right corner.
+   */
+  bottomRight: Size2DFor_DimensionPercentageFor_LengthValue;
+  /**
+   * The x and y radius values for the top left corner.
+   */
+  topLeft: Size2DFor_DimensionPercentageFor_LengthValue;
+  /**
+   * The x and y radius values for the top right corner.
+   */
+  topRight: Size2DFor_DimensionPercentageFor_LengthValue;
+}
+/**
+ * A value for the [border-image-repeat](https://www.w3.org/TR/css-backgrounds-3/#border-image-repeat) property.
+ */
+export interface BorderImageRepeat {
+  /**
+   * The horizontal repeat value.
+   */
+  horizontal: BorderImageRepeatKeyword;
+  /**
+   * The vertical repeat value.
+   */
+  vertical: BorderImageRepeatKeyword;
+}
+/**
+ * A value for the [border-image-slice](https://www.w3.org/TR/css-backgrounds-3/#border-image-slice) property.
+ */
+export interface BorderImageSlice {
+  /**
+   * Whether the middle of the border image should be preserved.
+   */
+  fill: boolean;
+  /**
+   * The offsets from the edges of the image.
+   */
+  offsets: RectFor_NumberOrPercentage;
+}
+/**
+ * A value for the [border-image](https://www.w3.org/TR/css-backgrounds-3/#border-image) shorthand property.
+ */
+export interface BorderImage {
+  /**
+   * The amount that the image extends beyond the border box.
+   */
+  outset: RectFor_LengthOrNumber;
+  /**
+   * How the border image is scaled and tiled.
+   */
+  repeat: BorderImageRepeat;
+  /**
+   * The offsets that define where the image is sliced.
+   */
+  slice: BorderImageSlice;
+  /**
+   * The border image.
+   */
+  source: Image;
+  /**
+   * The width of the border image.
+   */
+  width: RectFor_BorderImageSideWidth;
+}
+/**
+ * A value for the [border-color](https://drafts.csswg.org/css-backgrounds/#propdef-border-color) shorthand property.
+ */
+export interface BorderColor {
+  /**
+   * The bottom value.
+   */
+  bottom: CssColor;
+  /**
+   * The left value.
+   */
+  left: CssColor;
+  /**
+   * The right value.
+   */
+  right: CssColor;
+  /**
+   * The top value.
+   */
+  top: CssColor;
+}
+/**
+ * A value for the [border-style](https://drafts.csswg.org/css-backgrounds/#propdef-border-style) shorthand property.
+ */
+export interface BorderStyle {
+  /**
+   * The bottom value.
+   */
+  bottom: LineStyle;
+  /**
+   * The left value.
+   */
+  left: LineStyle;
+  /**
+   * The right value.
+   */
+  right: LineStyle;
+  /**
+   * The top value.
+   */
+  top: LineStyle;
+}
+/**
+ * A value for the [border-width](https://drafts.csswg.org/css-backgrounds/#propdef-border-width) shorthand property.
+ */
+export interface BorderWidth {
+  /**
+   * The bottom value.
+   */
+  bottom: BorderSideWidth;
+  /**
+   * The left value.
+   */
+  left: BorderSideWidth;
+  /**
+   * The right value.
+   */
+  right: BorderSideWidth;
+  /**
+   * The top value.
+   */
+  top: BorderSideWidth;
+}
+/**
+ * A value for the [border-block-color](https://drafts.csswg.org/css-logical/#propdef-border-block-color) shorthand property.
+ */
+export interface BorderBlockColor {
+  /**
+   * The block end value.
+   */
+  end: CssColor;
+  /**
+   * The block start value.
+   */
+  start: CssColor;
+}
+/**
+ * A value for the [border-block-style](https://drafts.csswg.org/css-logical/#propdef-border-block-style) shorthand property.
+ */
+export interface BorderBlockStyle {
+  /**
+   * The block end value.
+   */
+  end: LineStyle;
+  /**
+   * The block start value.
+   */
+  start: LineStyle;
+}
+/**
+ * A value for the [border-block-width](https://drafts.csswg.org/css-logical/#propdef-border-block-width) shorthand property.
+ */
+export interface BorderBlockWidth {
+  /**
+   * The block end value.
+   */
+  end: BorderSideWidth;
+  /**
+   * The block start value.
+   */
+  start: BorderSideWidth;
+}
+/**
+ * A value for the [border-inline-color](https://drafts.csswg.org/css-logical/#propdef-border-inline-color) shorthand property.
+ */
+export interface BorderInlineColor {
+  /**
+   * The inline end value.
+   */
+  end: CssColor;
+  /**
+   * The inline start value.
+   */
+  start: CssColor;
+}
+/**
+ * A value for the [border-inline-style](https://drafts.csswg.org/css-logical/#propdef-border-inline-style) shorthand property.
+ */
+export interface BorderInlineStyle {
+  /**
+   * The inline end value.
+   */
+  end: LineStyle;
+  /**
+   * The inline start value.
+   */
+  start: LineStyle;
+}
+/**
+ * A value for the [border-inline-width](https://drafts.csswg.org/css-logical/#propdef-border-inline-width) shorthand property.
+ */
+export interface BorderInlineWidth {
+  /**
+   * The inline end value.
+   */
+  end: BorderSideWidth;
+  /**
+   * The inline start value.
+   */
+  start: BorderSideWidth;
+}
+/**
+ * A generic type that represents the `border` and `outline` shorthand properties.
+ */
+export interface GenericBorderFor_LineStyle {
+  /**
+   * The border color.
+   */
+  color: CssColor;
+  /**
+   * The border style.
+   */
+  style: LineStyle;
+  /**
+   * The width of the border.
+   */
+  width: BorderSideWidth;
+}
+/**
+ * A generic type that represents the `border` and `outline` shorthand properties.
+ */
+export interface GenericBorderFor_OutlineStyleAnd_11 {
+  /**
+   * The border color.
+   */
+  color: CssColor;
+  /**
+   * The border style.
+   */
+  style: OutlineStyle;
+  /**
+   * The width of the border.
+   */
+  width: BorderSideWidth;
+}
+/**
+ * A value for the [flex-flow](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-flow-property) shorthand property.
+ */
+export interface FlexFlow {
+  /**
+   * The direction that flex items flow.
+   */
+  direction: FlexDirection;
+  /**
+   * How the flex items wrap.
+   */
+  wrap: FlexWrap;
+}
+/**
+ * A value for the [flex](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-property) shorthand property.
+ */
+export interface Flex {
+  /**
+   * The flex basis.
+   */
+  basis: LengthPercentageOrAuto;
+  /**
+   * The flex grow factor.
+   */
+  grow: number;
+  /**
+   * The flex shrink factor.
+   */
+  shrink: number;
+}
+/**
+ * A value for the [place-content](https://www.w3.org/TR/css-align-3/#place-content) shorthand property.
+ */
+export interface PlaceContent {
+  /**
+   * The content alignment.
+   */
+  align: AlignContent;
+  /**
+   * The content justification.
+   */
+  justify: JustifyContent;
+}
+/**
+ * A value for the [place-self](https://www.w3.org/TR/css-align-3/#place-self-property) shorthand property.
+ */
+export interface PlaceSelf {
+  /**
+   * The item alignment.
+   */
+  align: AlignSelf;
+  /**
+   * The item justification.
+   */
+  justify: JustifySelf;
+}
+/**
+ * A value for the [place-items](https://www.w3.org/TR/css-align-3/#place-items-property) shorthand property.
+ */
+export interface PlaceItems {
+  /**
+   * The item alignment.
+   */
+  align: AlignItems;
+  /**
+   * The item justification.
+   */
+  justify: JustifyItems;
+}
+/**
+ * A value for the [gap](https://www.w3.org/TR/css-align-3/#gap-shorthand) shorthand property.
+ */
+export interface Gap {
+  /**
+   * The column gap.
+   */
+  column: GapValue;
+  /**
+   * The row gap.
+   */
+  row: GapValue;
+}
+/**
+ * A [`<track-repeat>`](https://drafts.csswg.org/css-grid-2/#typedef-track-repeat) value, representing the `repeat()` function in a track list.
+ *
+ * See [TrackListItem](TrackListItem).
+ */
+export interface TrackRepeat {
+  /**
+   * The repeat count.
+   */
+  count: RepeatCount;
+  /**
+   * The line names to repeat.
+   */
+  lineNames: String[][];
+  /**
+   * The track sizes to repeat.
+   */
+  trackSizes: TrackSize[];
+}
+export interface GridAutoFlow {
+  /**
+   * If specified, a dense packing algorithm is used, which fills in holes in the grid.
+   */
+  dense: boolean;
+  /**
+   * The direction of the auto flow.
+   */
+  direction: AutoFlowDirection;
+}
+/**
+ * A value for the [grid-template](https://drafts.csswg.org/css-grid-2/#explicit-grid-shorthand) shorthand property.
+ *
+ * none | [ <'grid-template-rows'> / <'grid-template-columns'> ] | [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <explicit-track-list> ]?
+ *
+ * If `areas` is not `None`, then `rows` must also not be `None`.
+ */
+export interface GridTemplate {
+  /**
+   * The named grid areas.
+   */
+  areas: GridTemplateAreas;
+  /**
+   * The grid template columns.
+   */
+  columns: TrackSizing;
+  /**
+   * The grid template rows.
+   */
+  rows: TrackSizing;
+}
+/**
+ * A value for the [grid](https://drafts.csswg.org/css-grid-2/#grid-shorthand) shorthand property.
+ *
+ * <'grid-template'> | <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>? | [ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>
+ *
+ * Explicit and implicit values may not be combined.
+ */
+export interface Grid {
+  /**
+   * Explicit grid template areas.
+   */
+  areas: GridTemplateAreas;
+  /**
+   * The grid auto columns.
+   */
+  autoColumns: TrackSize[];
+  /**
+   * The grid auto flow.
+   */
+  autoFlow: GridAutoFlow;
+  /**
+   * The grid auto rows.
+   */
+  autoRows: TrackSize[];
+  /**
+   * Explicit grid template columns.
+   */
+  columns: TrackSizing;
+  /**
+   * Explicit grid template rows.
+   */
+  rows: TrackSizing;
+}
+/**
+ * A value for the [grid-row](https://drafts.csswg.org/css-grid-2/#propdef-grid-row) shorthand property. <grid-line> [ / <grid-line> ]?
+ */
+export interface GridRow {
+  /**
+   * The ending line.
+   */
+  end: GridLine;
+  /**
+   * The starting line.
+   */
+  start: GridLine;
+}
+/**
+ * A value for the [grid-column](https://drafts.csswg.org/css-grid-2/#propdef-grid-column) shorthand property. <grid-line> [ / <grid-line> ]?
+ */
+export interface GridColumn {
+  /**
+   * The ending line.
+   */
+  end: GridLine;
+  /**
+   * The starting line.
+   */
+  start: GridLine;
+}
+/**
+ * A value for the [grid-area](https://drafts.csswg.org/css-grid-2/#propdef-grid-area) shorthand property. <grid-line> [ / <grid-line> ]{0,3}
+ */
+export interface GridArea {
+  /**
+   * The grid column end placement.
+   */
+  columnEnd: GridLine;
+  /**
+   * The grid column start placement.
+   */
+  columnStart: GridLine;
+  /**
+   * The grid row end placement.
+   */
+  rowEnd: GridLine;
+  /**
+   * The grid row start placement.
+   */
+  rowStart: GridLine;
+}
+/**
+ * A value for the [margin-block](https://drafts.csswg.org/css-logical/#propdef-margin-block) shorthand property.
+ */
+export interface MarginBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [margin-inline](https://drafts.csswg.org/css-logical/#propdef-margin-inline) shorthand property.
+ */
+export interface MarginInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [margin](https://drafts.csswg.org/css-box-4/#propdef-margin) shorthand property.
+ */
+export interface Margin {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [padding-block](https://drafts.csswg.org/css-logical/#propdef-padding-block) shorthand property.
+ */
+export interface PaddingBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [padding-inline](https://drafts.csswg.org/css-logical/#propdef-padding-inline) shorthand property.
+ */
+export interface PaddingInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [padding](https://drafts.csswg.org/css-box-4/#propdef-padding) shorthand property.
+ */
+export interface Padding {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-margin-block](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-margin-block) shorthand property.
+ */
+export interface ScrollMarginBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-margin-inline](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-margin-inline) shorthand property.
+ */
+export interface ScrollMarginInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-margin](https://drafts.csswg.org/css-scroll-snap/#scroll-margin) shorthand property.
+ */
+export interface ScrollMargin {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-padding-block](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-padding-block) shorthand property.
+ */
+export interface ScrollPaddingBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-padding-inline](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-padding-inline) shorthand property.
+ */
+export interface ScrollPaddingInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-padding](https://drafts.csswg.org/css-scroll-snap/#scroll-padding) shorthand property.
+ */
+export interface ScrollPadding {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [font](https://www.w3.org/TR/css-fonts-4/#font-prop) shorthand property.
+ */
+export interface Font {
+  /**
+   * The font family.
+   */
+  family: FontFamily[];
+  /**
+   * The line height.
+   */
+  lineHeight: LineHeight;
+  /**
+   * The font size.
+   */
+  size: FontSize;
+  /**
+   * The font stretch.
+   */
+  stretch: FontStretch;
+  /**
+   * The font style.
+   */
+  style: FontStyle;
+  /**
+   * How the text should be capitalized. Only CSS 2.1 values are supported.
+   */
+  variantCaps: FontVariantCaps;
+  /**
+   * The font weight.
+   */
+  weight: FontWeight;
+}
+/**
+ * A value for the [transition](https://www.w3.org/TR/2018/WD-css-transitions-1-20181011/#transition-shorthand-property) property.
+ */
+export interface Transition {
+  /**
+   * The delay before the transition starts.
+   */
+  delay: Time;
+  /**
+   * The duration of the transition.
+   */
+  duration: Time;
+  /**
+   * The property to transition.
+   */
+  property: PropertyId;
+  /**
+   * The easing function for the transition.
+   */
+  timingFunction: EasingFunction;
+}
+/**
+ * The [scroll()](https://drafts.csswg.org/scroll-animations-1/#scroll-notation) function.
+ */
+export interface ScrollTimeline {
+  /**
+   * Specifies which axis of the scroll container to use as the progress for the timeline.
+   */
+  axis: ScrollAxis;
+  /**
+   * Specifies which element to use as the scroll container.
+   */
+  scroller: Scroller;
+}
+/**
+ * The [view()](https://drafts.csswg.org/scroll-animations-1/#view-notation) function.
+ */
+export interface ViewTimeline {
+  /**
+   * Specifies which axis of the scroll container to use as the progress for the timeline.
+   */
+  axis: ScrollAxis;
+  /**
+   * Provides an adjustment of the view progress visibility range.
+   */
+  inset: Size2DFor_LengthPercentageOrAuto;
+}
+/**
+ * A value for the [animation-range](https://drafts.csswg.org/scroll-animations/#animation-range) shorthand property.
+ */
+export interface AnimationRange {
+  /**
+   * The end of the animation's attachment range.
+   */
+  end: AnimationRangeEnd;
+  /**
+   * The start of the animation's attachment range.
+   */
+  start: AnimationRangeStart;
+}
+/**
+ * A value for the [animation](https://drafts.csswg.org/css-animations/#animation) shorthand property.
+ */
+export interface Animation {
+  /**
+   * The animation delay.
+   */
+  delay: Time;
+  /**
+   * The direction of the animation.
+   */
+  direction: AnimationDirection;
+  /**
+   * The animation duration.
+   */
+  duration: Time;
+  /**
+   * The animation fill mode.
+   */
+  fillMode: AnimationFillMode;
+  /**
+   * The number of times the animation will run.
+   */
+  iterationCount: AnimationIterationCount;
+  /**
+   * The animation name.
+   */
+  name: AnimationName;
+  /**
+   * The current play state of the animation.
+   */
+  playState: AnimationPlayState;
+  /**
+   * The animation timeline.
+   */
+  timeline: AnimationTimeline;
+  /**
+   * The easing function for the animation.
+   */
+  timingFunction: EasingFunction;
+}
+/**
+ * A 2D matrix.
+ */
+export interface MatrixForFloat {
+  a: number;
+  b: number;
+  c: number;
+  d: number;
+  e: number;
+  f: number;
+}
+/**
+ * A 3D matrix.
+ */
+export interface Matrix3DForFloat {
+  m11: number;
+  m12: number;
+  m13: number;
+  m14: number;
+  m21: number;
+  m22: number;
+  m23: number;
+  m24: number;
+  m31: number;
+  m32: number;
+  m33: number;
+  m34: number;
+  m41: number;
+  m42: number;
+  m43: number;
+  m44: number;
+}
+/**
+ * A value for the [rotate](https://drafts.csswg.org/css-transforms-2/#propdef-rotate) property.
+ */
+export interface Rotate {
+  /**
+   * The angle of rotation.
+   */
+  angle: Angle;
+  /**
+   * Rotation around the x axis.
+   */
+  x: number;
+  /**
+   * Rotation around the y axis.
+   */
+  y: number;
+  /**
+   * Rotation around the z axis.
+   */
+  z: number;
+}
+/**
+ * A value for the [text-transform](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-transform-property) property.
+ */
+export interface TextTransform {
+  /**
+   * How case should be transformed.
+   */
+  case: TextTransformCase;
+  /**
+   * Converts all small Kana characters to the equivalent full-size Kana.
+   */
+  fullSizeKana: boolean;
+  /**
+   * Puts all typographic character units in full-width form.
+   */
+  fullWidth: boolean;
+}
+/**
+ * A value for the [text-indent](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-indent-property) property.
+ */
+export interface TextIndent {
+  /**
+   * Affects the first line after each hard break.
+   */
+  eachLine: boolean;
+  /**
+   * Inverts which lines are affected.
+   */
+  hanging: boolean;
+  /**
+   * The amount to indent.
+   */
+  value: DimensionPercentageFor_LengthValue;
+}
+/**
+ * A value for the [text-decoration](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-property) shorthand property.
+ */
+export interface TextDecoration {
+  /**
+   * The color of the lines.
+   */
+  color: CssColor;
+  /**
+   * The lines to display.
+   */
+  line: TextDecorationLine;
+  /**
+   * The style of the lines.
+   */
+  style: TextDecorationStyle;
+  /**
+   * The thickness of the lines.
+   */
+  thickness: TextDecorationThickness;
+}
+/**
+ * A value for the [text-emphasis](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-property) shorthand property.
+ */
+export interface TextEmphasis {
+  /**
+   * The text emphasis color.
+   */
+  color: CssColor;
+  /**
+   * The text emphasis style.
+   */
+  style: TextEmphasisStyle;
+}
+/**
+ * A value for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property.
+ */
+export interface TextEmphasisPosition {
+  /**
+   * The horizontal position.
+   */
+  horizontal: TextEmphasisPositionHorizontal;
+  /**
+   * The vertical position.
+   */
+  vertical: TextEmphasisPositionVertical;
+}
+/**
+ * A value for the [text-shadow](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-shadow-property) property.
+ */
+export interface TextShadow {
+  /**
+   * The blur radius of the text shadow.
+   */
+  blur: Length;
+  /**
+   * The color of the text shadow.
+   */
+  color: CssColor;
+  /**
+   * The spread distance of the text shadow.
+   */
+  spread: Length;
+  /**
+   * The x offset of the text shadow.
+   */
+  xOffset: Length;
+  /**
+   * The y offset of the text shadow.
+   */
+  yOffset: Length;
+}
+/**
+ * A value for the [cursor](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) property.
+ */
+export interface Cursor {
+  /**
+   * A list of cursor images.
+   */
+  images: CursorImage[];
+  /**
+   * A pre-defined cursor.
+   */
+  keyword: CursorKeyword;
+}
+/**
+ * A [cursor image](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) value, used in the `cursor` property.
+ *
+ * See [Cursor](Cursor).
+ */
+export interface CursorImage {
+  /**
+   * The location in the image where the mouse pointer appears.
+   *
+   * @minItems 2
+   * @maxItems 2
+   */
+  hotspot?: [number, number] | null;
+  /**
+   * A url to the cursor image.
+   */
+  url: Url;
+}
+/**
+ * A value for the [caret](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret) shorthand property.
+ */
+export interface Caret {
+  /**
+   * The caret color.
+   */
+  color: ColorOrAuto;
+  /**
+   * The caret shape.
+   */
+  shape: CaretShape;
+}
+/**
+ * A value for the [list-style](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#list-style-property) shorthand property.
+ */
+export interface ListStyle {
+  /**
+   * The list marker image.
+   */
+  image: Image;
+  /**
+   * The list style type.
+   */
+  listStyleType: ListStyleType;
+  /**
+   * The position of the list marker.
+   */
+  position: ListStylePosition;
+}
+/**
+ * A value for the [composes](https://github.com/css-modules/css-modules/#dependencies) property from CSS modules.
+ */
+export interface Composes {
+  /**
+   * Where the class names are composed from.
+   */
+  from?: Specifier | null;
+  /**
+   * The source location of the `composes` property.
+   */
+  loc: Location;
+  /**
+   * A list of class names to compose.
+   */
+  names: String[];
+}
+/**
+ * An [`inset()`](https://www.w3.org/TR/css-shapes-1/#funcdef-inset) rectangle shape.
+ */
+export interface InsetRect {
+  /**
+   * A corner radius for the rectangle.
+   */
+  radius: BorderRadius;
+  /**
+   * The rectangle.
+   */
+  rect: RectFor_DimensionPercentageFor_LengthValue;
+}
+/**
+ * A [`circle()`](https://www.w3.org/TR/css-shapes-1/#funcdef-circle) shape.
+ */
+export interface Circle2 {
+  /**
+   * The position of the center of the circle.
+   */
+  position: Position;
+  /**
+   * The radius of the circle.
+   */
+  radius: ShapeRadius;
+}
+/**
+ * An [`ellipse()`](https://www.w3.org/TR/css-shapes-1/#funcdef-ellipse) shape.
+ */
+export interface Ellipse2 {
+  /**
+   * The position of the center of the ellipse.
+   */
+  position: Position;
+  /**
+   * The x-radius of the ellipse.
+   */
+  radiusX: ShapeRadius;
+  /**
+   * The y-radius of the ellipse.
+   */
+  radiusY: ShapeRadius;
+}
+/**
+ * A [`polygon()`](https://www.w3.org/TR/css-shapes-1/#funcdef-polygon) shape.
+ */
+export interface Polygon {
+  /**
+   * The fill rule used to determine the interior of the polygon.
+   */
+  fillRule: FillRule;
+  /**
+   * The points of each vertex of the polygon.
+   */
+  points: Point[];
+}
+/**
+ * A point within a `polygon()` shape.
+ *
+ * See [Polygon](Polygon).
+ */
+export interface Point {
+  /**
+   * The x position of the point.
+   */
+  x: DimensionPercentageFor_LengthValue;
+  /**
+   * the y position of the point.
+   */
+  y: DimensionPercentageFor_LengthValue;
+}
+/**
+ * A value for the [mask](https://www.w3.org/TR/css-masking-1/#the-mask) shorthand property.
+ */
+export interface Mask {
+  /**
+   * The box in which the mask is clipped.
+   */
+  clip: MaskClip;
+  /**
+   * How the mask is composited with the element.
+   */
+  composite: MaskComposite;
+  /**
+   * The mask image.
+   */
+  image: Image;
+  /**
+   * How the mask image is interpreted.
+   */
+  mode: MaskMode;
+  /**
+   * The origin of the mask.
+   */
+  origin: GeometryBox;
+  /**
+   * The position of the mask.
+   */
+  position: Position;
+  /**
+   * How the mask repeats.
+   */
+  repeat: BackgroundRepeat;
+  /**
+   * The size of the mask image.
+   */
+  size: BackgroundSize;
+}
+/**
+ * A value for the [mask-border](https://www.w3.org/TR/css-masking-1/#the-mask-border) shorthand property.
+ */
+export interface MaskBorder {
+  /**
+   * How the mask image is interpreted.
+   */
+  mode: MaskBorderMode;
+  /**
+   * The amount that the image extends beyond the border box.
+   */
+  outset: RectFor_LengthOrNumber;
+  /**
+   * How the mask image is scaled and tiled.
+   */
+  repeat: BorderImageRepeat;
+  /**
+   * The offsets that define where the image is sliced.
+   */
+  slice: BorderImageSlice;
+  /**
+   * The mask image.
+   */
+  source: Image;
+  /**
+   * The width of the mask image.
+   */
+  width: RectFor_BorderImageSideWidth;
+}
+/**
+ * A [`drop-shadow()`](https://drafts.fxtf.org/filter-effects-1/#funcdef-filter-drop-shadow) filter function.
+ */
+export interface DropShadow {
+  /**
+   * The blur radius of the drop shadow.
+   */
+  blur: Length;
+  /**
+   * The color of the drop shadow.
+   */
+  color: CssColor;
+  /**
+   * The x offset of the drop shadow.
+   */
+  xOffset: Length;
+  /**
+   * The y offset of the drop shadow.
+   */
+  yOffset: Length;
+}
+/**
+ * A value for the [container](https://drafts.csswg.org/css-contain-3/#container-shorthand) shorthand property.
+ */
+export interface Container {
+  /**
+   * The container type.
+   */
+  containerType: ContainerType;
+  /**
+   * The container name.
+   */
+  name: ContainerNameList;
+}
+export interface ColorScheme {
+  dark: boolean;
+  light: boolean;
+  only: boolean;
+}
+/**
+ * A known property with an unparsed value.
+ *
+ * This type is used when the value of a known property could not be parsed, e.g. in the case css `var()` references are encountered. In this case, the raw tokens are stored instead.
+ */
+export interface UnparsedProperty {
+  /**
+   * The id of the property.
+   */
+  propertyId: PropertyId;
+  /**
+   * The property value, stored as a raw token list.
+   */
+  value: TokenOrValue[];
+}
+/**
+ * A CSS custom property, representing any unknown property.
+ */
+export interface CustomProperty {
+  /**
+   * The name of the property.
+   */
+  name: CustomPropertyName;
+  /**
+   * The property value, stored as a raw token list.
+   */
+  value: TokenOrValue[];
+}
+export interface AttrOperation {
+  caseSensitivity?: ParsedCaseSensitivity & string;
+  operator: AttrSelectorOperator;
+  value: string;
+}
+/**
+ * A [view transition part selector](https://w3c.github.io/csswg-drafts/css-view-transitions-1/#typedef-pt-name-selector).
+ */
+export interface ViewTransitionPartSelector {
+  /**
+   * A list of view transition classes.
+   */
+  classes: String[];
+  /**
+   * The view transition part name.
+   */
+  name?: ViewTransitionPartName | null;
+}
+/**
+ * A [@keyframes](https://drafts.csswg.org/css-animations/#keyframes) rule.
+ */
+export interface KeyframesRule<D = Declaration> {
+  /**
+   * A list of keyframes in the animation.
+   */
+  keyframes: Keyframe<D>[];
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The animation name. <keyframes-name> = <custom-ident> | <string>
+   */
+  name: KeyframesName;
+  /**
+   * A vendor prefix for the rule, e.g. `@-webkit-keyframes`.
+   */
+  vendorPrefix: VendorPrefix;
+}
+/**
+ * An individual keyframe within an `@keyframes` rule.
+ *
+ * See [KeyframesRule](KeyframesRule).
+ */
+export interface Keyframe<D = Declaration> {
+  /**
+   * The declarations for this keyframe.
+   */
+  declarations: DeclarationBlock<D>;
+  /**
+   * A list of keyframe selectors to associate with the declarations in this keyframe.
+   */
+  selectors: KeyframeSelector[];
+}
+/**
+ * A percentage of a given timeline range
+ */
+export interface TimelineRangePercentage {
+  /**
+   * The name of the timeline range.
+   */
+  name: TimelineRangeName;
+  /**
+   * The percentage progress between the start and end of the range.
+   */
+  percentage: number;
+}
+/**
+ * A [@font-face](https://drafts.csswg.org/css-fonts/#font-face-rule) rule.
+ */
+export interface FontFaceRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * Declarations in the `@font-face` rule.
+   */
+  properties: FontFaceProperty[];
+}
+/**
+ * A `url()` value for the [src](https://drafts.csswg.org/css-fonts/#src-desc) property in an `@font-face` rule.
+ */
+export interface UrlSource {
+  /**
+   * Optional `format()` function.
+   */
+  format?: FontFormat | null;
+  /**
+   * Optional `tech()` function.
+   */
+  tech: FontTechnology[];
+  /**
+   * The URL.
+   */
+  url: Url;
+}
+/**
+ * A contiguous range of Unicode code points.
+ *
+ * Cannot be empty. Can represent a single code point when start == end.
+ */
+export interface UnicodeRange {
+  /**
+   * Inclusive end of the range. In [0, 0x10FFFF].
+   */
+  end: number;
+  /**
+   * Inclusive start of the range. In [0, end].
+   */
+  start: number;
+}
+/**
+ * A [@font-palette-values](https://drafts.csswg.org/css-fonts-4/#font-palette-values) rule.
+ */
+export interface FontPaletteValuesRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The name of the font palette.
+   */
+  name: String;
+  /**
+   * Declarations in the `@font-palette-values` rule.
+   */
+  properties: FontPaletteValuesProperty[];
+}
+/**
+ * A value for the [override-colors](https://drafts.csswg.org/css-fonts-4/#override-color) property in an `@font-palette-values` rule.
+ */
+export interface OverrideColors {
+  /**
+   * The replacement color.
+   */
+  color: CssColor;
+  /**
+   * The index of the color within the palette to override.
+   */
+  index: number;
+}
+/**
+ * A [@font-feature-values](https://drafts.csswg.org/css-fonts/#font-feature-values) rule.
+ */
+export interface FontFeatureValuesRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The name of the font feature values.
+   */
+  name: String[];
+  /**
+   * The rules within the `@font-feature-values` rule.
+   */
+  rules: {
+    [k: string]: FontFeatureSubrule;
+  };
+}
+/**
+ * A sub-rule of `@font-feature-values` https://drafts.csswg.org/css-fonts/#font-feature-values-syntax
+ */
+export interface FontFeatureSubrule {
+  /**
+   * The declarations within the `@font-feature-values` sub-rules.
+   */
+  declarations: {
+    [k: string]: number[];
+  };
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The name of the `@font-feature-values` sub-rule.
+   */
+  name: FontFeatureSubruleType;
+}
+/**
+ * A [@page](https://www.w3.org/TR/css-page-3/#at-page-rule) rule.
+ */
+export interface PageRule<D = Declaration> {
+  /**
+   * The declarations within the `@page` rule.
+   */
+  declarations: DeclarationBlock<D>;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The nested margin rules.
+   */
+  rules: PageMarginRule<D>[];
+  /**
+   * A list of page selectors.
+   */
+  selectors: PageSelector[];
+}
+/**
+ * A [page margin rule](https://www.w3.org/TR/css-page-3/#margin-at-rules) rule.
+ */
+export interface PageMarginRule<D = Declaration> {
+  /**
+   * The declarations within the rule.
+   */
+  declarations: DeclarationBlock<D>;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The margin box identifier for this rule.
+   */
+  marginBox: PageMarginBox;
+}
+/**
+ * A [page selector](https://www.w3.org/TR/css-page-3/#typedef-page-selector) within a `@page` rule.
+ *
+ * Either a name or at least one pseudo class is required.
+ */
+export interface PageSelector {
+  /**
+   * An optional named page type.
+   */
+  name?: String | null;
+  /**
+   * A list of page pseudo classes.
+   */
+  pseudoClasses: PagePseudoClass[];
+}
+/**
+ * A [@supports](https://drafts.csswg.org/css-conditional-3/#at-supports) rule.
+ */
+export interface SupportsRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The supports condition.
+   */
+  condition: SupportsCondition;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The rules within the `@supports` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@counter-style](https://drafts.csswg.org/css-counter-styles/#the-counter-style-rule) rule.
+ */
+export interface CounterStyleRule<D = Declaration> {
+  /**
+   * Declarations in the `@counter-style` rule.
+   */
+  declarations: DeclarationBlock<D>;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The name of the counter style to declare.
+   */
+  name: String;
+}
+/**
+ * A [@namespace](https://drafts.csswg.org/css-namespaces/#declaration) rule.
+ */
+export interface NamespaceRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * An optional namespace prefix to declare, or `None` to declare the default namespace.
+   */
+  prefix?: String | null;
+  /**
+   * The url of the namespace.
+   */
+  url: String;
+}
+/**
+ * A [@-moz-document](https://www.w3.org/TR/2012/WD-css3-conditional-20120911/#at-document) rule.
+ *
+ * Note that only the `url-prefix()` function with no arguments is supported, and only the `-moz` prefix is allowed since Firefox was the only browser that ever implemented this rule.
+ */
+export interface MozDocumentRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * Nested rules within the `@-moz-document` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@nest](https://www.w3.org/TR/css-nesting-1/#at-nest) rule.
+ */
+export interface NestingRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The style rule that defines the selector and declarations for the `@nest` rule.
+   */
+  style: StyleRule<D, M>;
+}
+/**
+ * A [nested declarations](https://drafts.csswg.org/css-nesting/#nested-declarations-rule) rule.
+ */
+export interface NestedDeclarationsRule<D = Declaration> {
+  /**
+   * The style rule that defines the selector and declarations for the `@nest` rule.
+   */
+  declarations: DeclarationBlock<D>;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+}
+/**
+ * A [@viewport](https://drafts.csswg.org/css-device-adapt/#atviewport-rule) rule.
+ */
+export interface ViewportRule<D = Declaration> {
+  /**
+   * The declarations within the `@viewport` rule.
+   */
+  declarations: DeclarationBlock<D>;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The vendor prefix for this rule, e.g. `@-ms-viewport`.
+   */
+  vendorPrefix: VendorPrefix;
+}
+/**
+ * A [@custom-media](https://drafts.csswg.org/mediaqueries-5/#custom-mq) rule.
+ */
+export interface CustomMediaRule<M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The name of the declared media query.
+   */
+  name: String;
+  /**
+   * The media query to declare.
+   */
+  query: MediaList<M>;
+}
+/**
+ * A [@layer statement](https://drafts.csswg.org/css-cascade-5/#layer-empty) rule.
+ *
+ * See also [LayerBlockRule](LayerBlockRule).
+ */
+export interface LayerStatementRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The layer names to declare.
+   */
+  names: String[][];
+}
+/**
+ * A [@layer block](https://drafts.csswg.org/css-cascade-5/#layer-block) rule.
+ */
+export interface LayerBlockRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The name of the layer to declare, or `None` to declare an anonymous layer.
+   */
+  name?: String[] | null;
+  /**
+   * The rules within the `@layer` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@property](https://drafts.css-houdini.org/css-properties-values-api/#at-property-rule) rule.
+ */
+export interface PropertyRule {
+  /**
+   * Whether the custom property is inherited.
+   */
+  inherits: boolean;
+  /**
+   * An optional initial value for the custom property.
+   */
+  initialValue?: ParsedComponent | null;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The name of the custom property to declare.
+   */
+  name: String;
+  /**
+   * A syntax string to specify the grammar for the custom property.
+   */
+  syntax: SyntaxString;
+}
+/**
+ * A [syntax component](https://drafts.css-houdini.org/css-properties-values-api/#syntax-component) within a [SyntaxString](SyntaxString).
+ *
+ * A syntax component consists of a component kind an a multiplier, which indicates how the component may repeat during parsing.
+ */
+export interface SyntaxComponent {
+  /**
+   * The kind of component.
+   */
+  kind: SyntaxComponentKind;
+  /**
+   * A multiplier for the component.
+   */
+  multiplier: Multiplier;
+}
+/**
+ * A [@container](https://drafts.csswg.org/css-contain-3/#container-rule) rule.
+ */
+export interface ContainerRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The container condition.
+   */
+  condition?: ContainerCondition<D> | null;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The name of the container.
+   */
+  name?: String | null;
+  /**
+   * The rules within the `@container` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@scope](https://drafts.csswg.org/css-cascade-6/#scope-atrule) rule.
+ *
+ * @scope (<scope-start>) [to (<scope-end>)]? { <stylesheet> }
+ */
+export interface ScopeRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * Nested rules within the `@scope` rule.
+   */
+  rules: Rule<D, M>[];
+  /**
+   * A selector list used to identify any scoping limits.
+   */
+  scopeEnd?: SelectorList | null;
+  /**
+   * A selector list used to identify the scoping root(s).
+   */
+  scopeStart?: SelectorList | null;
+}
+/**
+ * A [@starting-style](https://drafts.csswg.org/css-transitions-2/#defining-before-change-style-the-starting-style-rule) rule.
+ */
+export interface StartingStyleRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * Nested rules within the `@starting-style` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@view-transition](https://drafts.csswg.org/css-view-transitions-2/#view-transition-rule) rule.
+ */
+export interface ViewTransitionRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * Declarations in the `@view-transition` rule.
+   */
+  properties: ViewTransitionProperty[];
+}
+/**
+ * An unknown at-rule, stored as raw tokens.
+ */
+export interface UnknownAtRule {
+  /**
+   * The contents of the block, if any.
+   */
+  block?: TokenOrValue[] | null;
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+  /**
+   * The name of the at-rule (without the @).
+   */
+  name: String;
+  /**
+   * The prelude of the rule.
+   */
+  prelude: TokenOrValue[];
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/ast.js.flow b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/ast.js.flow
new file mode 100644
index 0000000..e09a1ec
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/ast.js.flow
@@ -0,0 +1,10539 @@
+// @flow
+
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+export type String = string;
+/**
+ * A CSS rule.
+ */
+export type Rule<D = Declaration, M = MediaQuery> =
+  | {|
+      type: "media",
+      value: MediaRule<D, M>,
+    |}
+  | {|
+      type: "import",
+      value: ImportRule<M>,
+    |}
+  | {|
+      type: "style",
+      value: StyleRule<D, M>,
+    |}
+  | {|
+      type: "keyframes",
+      value: KeyframesRule<D>,
+    |}
+  | {|
+      type: "font-face",
+      value: FontFaceRule,
+    |}
+  | {|
+      type: "font-palette-values",
+      value: FontPaletteValuesRule,
+    |}
+  | {|
+      type: "font-feature-values",
+      value: FontFeatureValuesRule,
+    |}
+  | {|
+      type: "page",
+      value: PageRule<D>,
+    |}
+  | {|
+      type: "supports",
+      value: SupportsRule<D, M>,
+    |}
+  | {|
+      type: "counter-style",
+      value: CounterStyleRule<D>,
+    |}
+  | {|
+      type: "namespace",
+      value: NamespaceRule,
+    |}
+  | {|
+      type: "moz-document",
+      value: MozDocumentRule<D, M>,
+    |}
+  | {|
+      type: "nesting",
+      value: NestingRule<D, M>,
+    |}
+  | {|
+      type: "nested-declarations",
+      value: NestedDeclarationsRule<D>,
+    |}
+  | {|
+      type: "viewport",
+      value: ViewportRule<D>,
+    |}
+  | {|
+      type: "custom-media",
+      value: CustomMediaRule<M>,
+    |}
+  | {|
+      type: "layer-statement",
+      value: LayerStatementRule,
+    |}
+  | {|
+      type: "layer-block",
+      value: LayerBlockRule<D, M>,
+    |}
+  | {|
+      type: "property",
+      value: PropertyRule,
+    |}
+  | {|
+      type: "container",
+      value: ContainerRule<D, M>,
+    |}
+  | {|
+      type: "scope",
+      value: ScopeRule<D, M>,
+    |}
+  | {|
+      type: "starting-style",
+      value: StartingStyleRule<D, M>,
+    |}
+  | {|
+      type: "view-transition",
+      value: ViewTransitionRule,
+    |}
+  | {|
+      type: "ignored",
+    |}
+  | {|
+      type: "unknown",
+      value: UnknownAtRule,
+    |}
+  | {|
+      type: "custom",
+      value: DefaultAtRule,
+    |};
+/**
+ * Represents a media condition.
+ */
+export type MediaCondition =
+  | {|
+      type: "feature",
+      value: QueryFeatureFor_MediaFeatureId,
+    |}
+  | {|
+      type: "not",
+      value: MediaCondition,
+    |}
+  | {|
+      /**
+       * The conditions for the operator.
+       */
+      conditions: MediaCondition[],
+
+      /**
+       * The operator for the conditions.
+       */
+      operator: Operator,
+      type: "operation",
+    |}
+  | {|
+      type: "unknown",
+      value: TokenOrValue[],
+    |};
+/**
+ * A generic media feature or container feature.
+ */
+export type QueryFeatureFor_MediaFeatureId =
+  | {|
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_MediaFeatureId,
+      type: "plain",
+
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue,
+    |}
+  | {|
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_MediaFeatureId,
+      type: "boolean",
+    |}
+  | {|
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_MediaFeatureId,
+
+      /**
+       * A comparator.
+       */
+      operator: MediaFeatureComparison,
+      type: "range",
+
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue,
+    |}
+  | {|
+      /**
+       * The end value.
+       */
+      end: MediaFeatureValue,
+
+      /**
+       * A comparator for the end value.
+       */
+      endOperator: MediaFeatureComparison,
+
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_MediaFeatureId,
+
+      /**
+       * A start value.
+       */
+      start: MediaFeatureValue,
+
+      /**
+       * A comparator for the start value.
+       */
+      startOperator: MediaFeatureComparison,
+      type: "interval",
+    |};
+/**
+ * A media feature name.
+ */
+export type MediaFeatureNameFor_MediaFeatureId =
+  | MediaFeatureId
+  | String
+  | String;
+/**
+ * A media query feature identifier.
+ */
+export type MediaFeatureId =
+  | "width"
+  | "height"
+  | "aspect-ratio"
+  | "orientation"
+  | "overflow-block"
+  | "overflow-inline"
+  | "horizontal-viewport-segments"
+  | "vertical-viewport-segments"
+  | "display-mode"
+  | "resolution"
+  | "scan"
+  | "grid"
+  | "update"
+  | "environment-blending"
+  | "color"
+  | "color-index"
+  | "monochrome"
+  | "color-gamut"
+  | "dynamic-range"
+  | "inverted-colors"
+  | "pointer"
+  | "hover"
+  | "any-pointer"
+  | "any-hover"
+  | "nav-controls"
+  | "video-color-gamut"
+  | "video-dynamic-range"
+  | "scripting"
+  | "prefers-reduced-motion"
+  | "prefers-reduced-transparency"
+  | "prefers-contrast"
+  | "forced-colors"
+  | "prefers-color-scheme"
+  | "prefers-reduced-data"
+  | "device-width"
+  | "device-height"
+  | "device-aspect-ratio"
+  | "-webkit-device-pixel-ratio"
+  | "-moz-device-pixel-ratio";
+/**
+ * [media feature value](https://drafts.csswg.org/mediaqueries/#typedef-mf-value) within a media query.
+ *
+ * See [MediaFeature](MediaFeature).
+ */
+export type MediaFeatureValue =
+  | {|
+      type: "length",
+      value: Length,
+    |}
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "integer",
+      value: number,
+    |}
+  | {|
+      type: "boolean",
+      value: boolean,
+    |}
+  | {|
+      type: "resolution",
+      value: Resolution,
+    |}
+  | {|
+      type: "ratio",
+      value: Ratio,
+    |}
+  | {|
+      type: "ident",
+      value: String,
+    |}
+  | {|
+      type: "env",
+      value: EnvironmentVariable,
+    |};
+/**
+ * A CSS [`<length>`](https://www.w3.org/TR/css-values-4/#lengths) value, with support for `calc()`.
+ */
+export type Length =
+  | {|
+      type: "value",
+      value: LengthValue,
+    |}
+  | {|
+      type: "calc",
+      value: CalcFor_Length,
+    |};
+export type LengthUnit =
+  | "px"
+  | "in"
+  | "cm"
+  | "mm"
+  | "q"
+  | "pt"
+  | "pc"
+  | "em"
+  | "rem"
+  | "ex"
+  | "rex"
+  | "ch"
+  | "rch"
+  | "cap"
+  | "rcap"
+  | "ic"
+  | "ric"
+  | "lh"
+  | "rlh"
+  | "vw"
+  | "lvw"
+  | "svw"
+  | "dvw"
+  | "cqw"
+  | "vh"
+  | "lvh"
+  | "svh"
+  | "dvh"
+  | "cqh"
+  | "vi"
+  | "svi"
+  | "lvi"
+  | "dvi"
+  | "cqi"
+  | "vb"
+  | "svb"
+  | "lvb"
+  | "dvb"
+  | "cqb"
+  | "vmin"
+  | "svmin"
+  | "lvmin"
+  | "dvmin"
+  | "cqmin"
+  | "vmax"
+  | "svmax"
+  | "lvmax"
+  | "dvmax"
+  | "cqmax";
+/**
+ * A mathematical expression used within the [`calc()`](https://www.w3.org/TR/css-values-4/#calc-func) function.
+ *
+ * This type supports generic value types. Values such as [Length](super::length::Length), [Percentage](super::percentage::Percentage), [Time](super::time::Time), and [Angle](super::angle::Angle) support `calc()` expressions.
+ */
+export type CalcFor_Length =
+  | {|
+      type: "value",
+      value: Length,
+    |}
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "sum",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_Length, CalcFor_Length],
+    |}
+  | {|
+      type: "product",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [number, CalcFor_Length],
+    |}
+  | {|
+      type: "function",
+      value: MathFunctionFor_Length,
+    |};
+/**
+ * A CSS [math function](https://www.w3.org/TR/css-values-4/#math-function).
+ *
+ * Math functions may be used in most properties and values that accept numeric values, including lengths, percentages, angles, times, etc.
+ */
+export type MathFunctionFor_Length =
+  | {|
+      type: "calc",
+      value: CalcFor_Length,
+    |}
+  | {|
+      type: "min",
+      value: CalcFor_Length[],
+    |}
+  | {|
+      type: "max",
+      value: CalcFor_Length[],
+    |}
+  | {|
+      type: "clamp",
+
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [CalcFor_Length, CalcFor_Length, CalcFor_Length],
+    |}
+  | {|
+      type: "round",
+
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [RoundingStrategy, CalcFor_Length, CalcFor_Length],
+    |}
+  | {|
+      type: "rem",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_Length, CalcFor_Length],
+    |}
+  | {|
+      type: "mod",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [CalcFor_Length, CalcFor_Length],
+    |}
+  | {|
+      type: "abs",
+      value: CalcFor_Length,
+    |}
+  | {|
+      type: "sign",
+      value: CalcFor_Length,
+    |}
+  | {|
+      type: "hypot",
+      value: CalcFor_Length[],
+    |};
+/**
+ * A [rounding strategy](https://www.w3.org/TR/css-values-4/#typedef-rounding-strategy), as used in the `round()` function.
+ */
+export type RoundingStrategy = "nearest" | "up" | "down" | "to-zero";
+/**
+ * A CSS [`<resolution>`](https://www.w3.org/TR/css-values-4/#resolution) value.
+ */
+export type Resolution =
+  | {|
+      type: "dpi",
+      value: number,
+    |}
+  | {|
+      type: "dpcm",
+      value: number,
+    |}
+  | {|
+      type: "dppx",
+      value: number,
+    |};
+/**
+ * A CSS [`<ratio>`](https://www.w3.org/TR/css-values-4/#ratios) value, representing the ratio of two numeric values.
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Ratio = [number, number];
+/**
+ * A raw CSS token, or a parsed value.
+ */
+export type TokenOrValue =
+  | {|
+      type: "token",
+      value: Token,
+    |}
+  | {|
+      type: "color",
+      value: CssColor,
+    |}
+  | {|
+      type: "unresolved-color",
+      value: UnresolvedColor,
+    |}
+  | {|
+      type: "url",
+      value: Url,
+    |}
+  | {|
+      type: "var",
+      value: Variable,
+    |}
+  | {|
+      type: "env",
+      value: EnvironmentVariable,
+    |}
+  | {|
+      type: "function",
+      value: Function,
+    |}
+  | {|
+      type: "length",
+      value: LengthValue,
+    |}
+  | {|
+      type: "angle",
+      value: Angle,
+    |}
+  | {|
+      type: "time",
+      value: Time,
+    |}
+  | {|
+      type: "resolution",
+      value: Resolution,
+    |}
+  | {|
+      type: "dashed-ident",
+      value: String,
+    |}
+  | {|
+      type: "animation-name",
+      value: AnimationName,
+    |};
+/**
+ * A raw CSS token.
+ */
+export type Token =
+  | {|
+      type: "ident",
+      value: String,
+    |}
+  | {|
+      type: "at-keyword",
+      value: String,
+    |}
+  | {|
+      type: "hash",
+      value: String,
+    |}
+  | {|
+      type: "id-hash",
+      value: String,
+    |}
+  | {|
+      type: "string",
+      value: String,
+    |}
+  | {|
+      type: "unquoted-url",
+      value: String,
+    |}
+  | {|
+      type: "delim",
+      value: string,
+    |}
+  | {|
+      type: "number",
+
+      /**
+       * The value as a float
+       */
+      value: number,
+    |}
+  | {|
+      type: "percentage",
+
+      /**
+       * The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0.
+       */
+      value: number,
+    |}
+  | {|
+      type: "dimension",
+
+      /**
+       * The unit, e.g. "px" in `12px`
+       */
+      unit: String,
+
+      /**
+       * The value as a float
+       */
+      value: number,
+    |}
+  | {|
+      type: "white-space",
+      value: String,
+    |}
+  | {|
+      type: "comment",
+      value: String,
+    |}
+  | {|
+      type: "colon",
+    |}
+  | {|
+      type: "semicolon",
+    |}
+  | {|
+      type: "comma",
+    |}
+  | {|
+      type: "include-match",
+    |}
+  | {|
+      type: "dash-match",
+    |}
+  | {|
+      type: "prefix-match",
+    |}
+  | {|
+      type: "suffix-match",
+    |}
+  | {|
+      type: "substring-match",
+    |}
+  | {|
+      type: "cdo",
+    |}
+  | {|
+      type: "cdc",
+    |}
+  | {|
+      type: "function",
+      value: String,
+    |}
+  | {|
+      type: "parenthesis-block",
+    |}
+  | {|
+      type: "square-bracket-block",
+    |}
+  | {|
+      type: "curly-bracket-block",
+    |}
+  | {|
+      type: "bad-url",
+      value: String,
+    |}
+  | {|
+      type: "bad-string",
+      value: String,
+    |}
+  | {|
+      type: "close-parenthesis",
+    |}
+  | {|
+      type: "close-square-bracket",
+    |}
+  | {|
+      type: "close-curly-bracket",
+    |};
+/**
+ * A CSS [`<color>`](https://www.w3.org/TR/css-color-4/#color-type) value.
+ *
+ * CSS supports many different color spaces to represent colors. The most common values are stored as RGBA using a single byte per component. Less common values are stored using a `Box` to reduce the amount of memory used per color.
+ *
+ * Each color space is represented as a struct that implements the `From` and `Into` traits for all other color spaces, so it is possible to convert between color spaces easily. In addition, colors support [interpolation](#method.interpolate) as in the `color-mix()` function.
+ */
+export type CssColor =
+  | CurrentColor
+  | RGBColor
+  | LABColor
+  | PredefinedColor
+  | FloatColor
+  | LightDark
+  | SystemColor;
+export type CurrentColor = {|
+  type: "currentcolor",
+|};
+export type RGBColor = {|
+  /**
+   * The alpha component.
+   */
+  alpha: number,
+
+  /**
+   * The blue component.
+   */
+  b: number,
+
+  /**
+   * The green component.
+   */
+  g: number,
+
+  /**
+   * The red component.
+   */
+  r: number,
+  type: "rgb",
+|};
+/**
+ * A color in a LAB color space, including the `lab()`, `lch()`, `oklab()`, and `oklch()` functions.
+ */
+export type LABColor =
+  | {|
+      /**
+       * The a component.
+       */
+      a: number,
+
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The b component.
+       */
+      b: number,
+
+      /**
+       * The lightness component.
+       */
+      l: number,
+      type: "lab",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The chroma component.
+       */
+      c: number,
+
+      /**
+       * The hue component.
+       */
+      h: number,
+
+      /**
+       * The lightness component.
+       */
+      l: number,
+      type: "lch",
+    |}
+  | {|
+      /**
+       * The a component.
+       */
+      a: number,
+
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The b component.
+       */
+      b: number,
+
+      /**
+       * The lightness component.
+       */
+      l: number,
+      type: "oklab",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The chroma component.
+       */
+      c: number,
+
+      /**
+       * The hue component.
+       */
+      h: number,
+
+      /**
+       * The lightness component.
+       */
+      l: number,
+      type: "oklch",
+    |};
+/**
+ * A color in a predefined color space, e.g. `display-p3`.
+ */
+export type PredefinedColor =
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The blue component.
+       */
+      b: number,
+
+      /**
+       * The green component.
+       */
+      g: number,
+
+      /**
+       * The red component.
+       */
+      r: number,
+      type: "srgb",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The blue component.
+       */
+      b: number,
+
+      /**
+       * The green component.
+       */
+      g: number,
+
+      /**
+       * The red component.
+       */
+      r: number,
+      type: "srgb-linear",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The blue component.
+       */
+      b: number,
+
+      /**
+       * The green component.
+       */
+      g: number,
+
+      /**
+       * The red component.
+       */
+      r: number,
+      type: "display-p3",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The blue component.
+       */
+      b: number,
+
+      /**
+       * The green component.
+       */
+      g: number,
+
+      /**
+       * The red component.
+       */
+      r: number,
+      type: "a98-rgb",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The blue component.
+       */
+      b: number,
+
+      /**
+       * The green component.
+       */
+      g: number,
+
+      /**
+       * The red component.
+       */
+      r: number,
+      type: "prophoto-rgb",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The blue component.
+       */
+      b: number,
+
+      /**
+       * The green component.
+       */
+      g: number,
+
+      /**
+       * The red component.
+       */
+      r: number,
+      type: "rec2020",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+      type: "xyz-d50",
+
+      /**
+       * The x component.
+       */
+      x: number,
+
+      /**
+       * The y component.
+       */
+      y: number,
+
+      /**
+       * The z component.
+       */
+      z: number,
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+      type: "xyz-d65",
+
+      /**
+       * The x component.
+       */
+      x: number,
+
+      /**
+       * The y component.
+       */
+      y: number,
+
+      /**
+       * The z component.
+       */
+      z: number,
+    |};
+/**
+ * A floating point representation of color types that are usually stored as RGBA. These are used when there are any `none` components, which are represented as NaN.
+ */
+export type FloatColor =
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The blue component.
+       */
+      b: number,
+
+      /**
+       * The green component.
+       */
+      g: number,
+
+      /**
+       * The red component.
+       */
+      r: number,
+      type: "rgb",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The hue component.
+       */
+      h: number,
+
+      /**
+       * The lightness component.
+       */
+      l: number,
+
+      /**
+       * The saturation component.
+       */
+      s: number,
+      type: "hsl",
+    |}
+  | {|
+      /**
+       * The alpha component.
+       */
+      alpha: number,
+
+      /**
+       * The blackness component.
+       */
+      b: number,
+
+      /**
+       * The hue component.
+       */
+      h: number,
+      type: "hwb",
+
+      /**
+       * The whiteness component.
+       */
+      w: number,
+    |};
+export type LightDark = {|
+  dark: CssColor,
+  light: CssColor,
+  type: "light-dark",
+|};
+/**
+ * A CSS [system color](https://drafts.csswg.org/css-color/#css-system-colors) keyword.
+ */
+export type SystemColor =
+  | "accentcolor"
+  | "accentcolortext"
+  | "activetext"
+  | "buttonborder"
+  | "buttonface"
+  | "buttontext"
+  | "canvas"
+  | "canvastext"
+  | "field"
+  | "fieldtext"
+  | "graytext"
+  | "highlight"
+  | "highlighttext"
+  | "linktext"
+  | "mark"
+  | "marktext"
+  | "selecteditem"
+  | "selecteditemtext"
+  | "visitedtext"
+  | "activeborder"
+  | "activecaption"
+  | "appworkspace"
+  | "background"
+  | "buttonhighlight"
+  | "buttonshadow"
+  | "captiontext"
+  | "inactiveborder"
+  | "inactivecaption"
+  | "inactivecaptiontext"
+  | "infobackground"
+  | "infotext"
+  | "menu"
+  | "menutext"
+  | "scrollbar"
+  | "threeddarkshadow"
+  | "threedface"
+  | "threedhighlight"
+  | "threedlightshadow"
+  | "threedshadow"
+  | "window"
+  | "windowframe"
+  | "windowtext";
+/**
+ * A color value with an unresolved alpha value (e.g. a variable). These can be converted from the modern slash syntax to older comma syntax. This can only be done when the only unresolved component is the alpha since variables can resolve to multiple tokens.
+ */
+export type UnresolvedColor =
+  | {|
+      /**
+       * The unresolved alpha component.
+       */
+      alpha: TokenOrValue[],
+
+      /**
+       * The blue component.
+       */
+      b: number,
+
+      /**
+       * The green component.
+       */
+      g: number,
+
+      /**
+       * The red component.
+       */
+      r: number,
+      type: "rgb",
+    |}
+  | {|
+      /**
+       * The unresolved alpha component.
+       */
+      alpha: TokenOrValue[],
+
+      /**
+       * The hue component.
+       */
+      h: number,
+
+      /**
+       * The lightness component.
+       */
+      l: number,
+
+      /**
+       * The saturation component.
+       */
+      s: number,
+      type: "hsl",
+    |}
+  | {|
+      /**
+       * The dark value.
+       */
+      dark: TokenOrValue[],
+
+      /**
+       * The light value.
+       */
+      light: TokenOrValue[],
+      type: "light-dark",
+    |};
+/**
+ * Defines where the class names referenced in the `composes` property are located.
+ *
+ * See [Composes](Composes).
+ */
+export type Specifier =
+  | {|
+      type: "global",
+    |}
+  | {|
+      type: "file",
+      value: String,
+    |}
+  | {|
+      type: "source-index",
+      value: number,
+    |};
+/**
+ * A CSS [`<angle>`](https://www.w3.org/TR/css-values-4/#angles) value.
+ *
+ * Angles may be explicit or computed by `calc()`, but are always stored and serialized as their computed value.
+ */
+export type Angle =
+  | {|
+      type: "deg",
+      value: number,
+    |}
+  | {|
+      type: "rad",
+      value: number,
+    |}
+  | {|
+      type: "grad",
+      value: number,
+    |}
+  | {|
+      type: "turn",
+      value: number,
+    |};
+/**
+ * A CSS [`<time>`](https://www.w3.org/TR/css-values-4/#time) value, in either seconds or milliseconds.
+ *
+ * Time values may be explicit or computed by `calc()`, but are always stored and serialized as their computed value.
+ */
+export type Time =
+  | {|
+      type: "seconds",
+      value: number,
+    |}
+  | {|
+      type: "milliseconds",
+      value: number,
+    |};
+/**
+ * A value for the [animation-name](https://drafts.csswg.org/css-animations/#animation-name) property.
+ */
+export type AnimationName =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "ident",
+      value: String,
+    |}
+  | {|
+      type: "string",
+      value: String,
+    |};
+/**
+ * A CSS environment variable name.
+ */
+export type EnvironmentVariableName =
+  | {|
+      type: "ua",
+      value: UAEnvironmentVariable,
+    |}
+  | {|
+      /**
+       * CSS modules extension: the filename where the variable is defined. Only enabled when the CSS modules `dashed_idents` option is turned on.
+       */
+      from?: Specifier | null,
+
+      /**
+       * The referenced identifier.
+       */
+      ident: String,
+      type: "custom",
+    |}
+  | {|
+      type: "unknown",
+      value: String,
+    |};
+/**
+ * A UA-defined environment variable name.
+ */
+export type UAEnvironmentVariable =
+  | "safe-area-inset-top"
+  | "safe-area-inset-right"
+  | "safe-area-inset-bottom"
+  | "safe-area-inset-left"
+  | "viewport-segment-width"
+  | "viewport-segment-height"
+  | "viewport-segment-top"
+  | "viewport-segment-left"
+  | "viewport-segment-bottom"
+  | "viewport-segment-right";
+/**
+ * A [comparator](https://drafts.csswg.org/mediaqueries/#typedef-mf-comparison) within a media query.
+ */
+export type MediaFeatureComparison =
+  | "equal"
+  | "greater-than"
+  | "greater-than-equal"
+  | "less-than"
+  | "less-than-equal";
+/**
+ * A binary `and` or `or` operator.
+ */
+export type Operator = "and" | "or";
+export type MediaType = string;
+/**
+ * A [media query qualifier](https://drafts.csswg.org/mediaqueries/#mq-prefix).
+ */
+export type Qualifier = "only" | "not";
+/**
+ * A [`<supports-condition>`](https://drafts.csswg.org/css-conditional-3/#typedef-supports-condition), as used in the `@supports` and `@import` rules.
+ */
+export type SupportsCondition =
+  | {|
+      type: "not",
+      value: SupportsCondition,
+    |}
+  | {|
+      type: "and",
+      value: SupportsCondition[],
+    |}
+  | {|
+      type: "or",
+      value: SupportsCondition[],
+    |}
+  | {|
+      /**
+       * The property id for the declaration.
+       */
+      propertyId: PropertyId,
+      type: "declaration",
+
+      /**
+       * The raw value of the declaration.
+       */
+      value: String,
+    |}
+  | {|
+      type: "selector",
+      value: String,
+    |}
+  | {|
+      type: "unknown",
+      value: String,
+    |};
+export type PropertyId =
+  | {|
+      property: "background-color",
+    |}
+  | {|
+      property: "background-image",
+    |}
+  | {|
+      property: "background-position-x",
+    |}
+  | {|
+      property: "background-position-y",
+    |}
+  | {|
+      property: "background-position",
+    |}
+  | {|
+      property: "background-size",
+    |}
+  | {|
+      property: "background-repeat",
+    |}
+  | {|
+      property: "background-attachment",
+    |}
+  | {|
+      property: "background-clip",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "background-origin",
+    |}
+  | {|
+      property: "background",
+    |}
+  | {|
+      property: "box-shadow",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "opacity",
+    |}
+  | {|
+      property: "color",
+    |}
+  | {|
+      property: "display",
+    |}
+  | {|
+      property: "visibility",
+    |}
+  | {|
+      property: "width",
+    |}
+  | {|
+      property: "height",
+    |}
+  | {|
+      property: "min-width",
+    |}
+  | {|
+      property: "min-height",
+    |}
+  | {|
+      property: "max-width",
+    |}
+  | {|
+      property: "max-height",
+    |}
+  | {|
+      property: "block-size",
+    |}
+  | {|
+      property: "inline-size",
+    |}
+  | {|
+      property: "min-block-size",
+    |}
+  | {|
+      property: "min-inline-size",
+    |}
+  | {|
+      property: "max-block-size",
+    |}
+  | {|
+      property: "max-inline-size",
+    |}
+  | {|
+      property: "box-sizing",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "aspect-ratio",
+    |}
+  | {|
+      property: "overflow",
+    |}
+  | {|
+      property: "overflow-x",
+    |}
+  | {|
+      property: "overflow-y",
+    |}
+  | {|
+      property: "text-overflow",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "position",
+    |}
+  | {|
+      property: "top",
+    |}
+  | {|
+      property: "bottom",
+    |}
+  | {|
+      property: "left",
+    |}
+  | {|
+      property: "right",
+    |}
+  | {|
+      property: "inset-block-start",
+    |}
+  | {|
+      property: "inset-block-end",
+    |}
+  | {|
+      property: "inset-inline-start",
+    |}
+  | {|
+      property: "inset-inline-end",
+    |}
+  | {|
+      property: "inset-block",
+    |}
+  | {|
+      property: "inset-inline",
+    |}
+  | {|
+      property: "inset",
+    |}
+  | {|
+      property: "border-spacing",
+    |}
+  | {|
+      property: "border-top-color",
+    |}
+  | {|
+      property: "border-bottom-color",
+    |}
+  | {|
+      property: "border-left-color",
+    |}
+  | {|
+      property: "border-right-color",
+    |}
+  | {|
+      property: "border-block-start-color",
+    |}
+  | {|
+      property: "border-block-end-color",
+    |}
+  | {|
+      property: "border-inline-start-color",
+    |}
+  | {|
+      property: "border-inline-end-color",
+    |}
+  | {|
+      property: "border-top-style",
+    |}
+  | {|
+      property: "border-bottom-style",
+    |}
+  | {|
+      property: "border-left-style",
+    |}
+  | {|
+      property: "border-right-style",
+    |}
+  | {|
+      property: "border-block-start-style",
+    |}
+  | {|
+      property: "border-block-end-style",
+    |}
+  | {|
+      property: "border-inline-start-style",
+    |}
+  | {|
+      property: "border-inline-end-style",
+    |}
+  | {|
+      property: "border-top-width",
+    |}
+  | {|
+      property: "border-bottom-width",
+    |}
+  | {|
+      property: "border-left-width",
+    |}
+  | {|
+      property: "border-right-width",
+    |}
+  | {|
+      property: "border-block-start-width",
+    |}
+  | {|
+      property: "border-block-end-width",
+    |}
+  | {|
+      property: "border-inline-start-width",
+    |}
+  | {|
+      property: "border-inline-end-width",
+    |}
+  | {|
+      property: "border-top-left-radius",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-top-right-radius",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-bottom-left-radius",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-bottom-right-radius",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-start-start-radius",
+    |}
+  | {|
+      property: "border-start-end-radius",
+    |}
+  | {|
+      property: "border-end-start-radius",
+    |}
+  | {|
+      property: "border-end-end-radius",
+    |}
+  | {|
+      property: "border-radius",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-image-source",
+    |}
+  | {|
+      property: "border-image-outset",
+    |}
+  | {|
+      property: "border-image-repeat",
+    |}
+  | {|
+      property: "border-image-width",
+    |}
+  | {|
+      property: "border-image-slice",
+    |}
+  | {|
+      property: "border-image",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-color",
+    |}
+  | {|
+      property: "border-style",
+    |}
+  | {|
+      property: "border-width",
+    |}
+  | {|
+      property: "border-block-color",
+    |}
+  | {|
+      property: "border-block-style",
+    |}
+  | {|
+      property: "border-block-width",
+    |}
+  | {|
+      property: "border-inline-color",
+    |}
+  | {|
+      property: "border-inline-style",
+    |}
+  | {|
+      property: "border-inline-width",
+    |}
+  | {|
+      property: "border",
+    |}
+  | {|
+      property: "border-top",
+    |}
+  | {|
+      property: "border-bottom",
+    |}
+  | {|
+      property: "border-left",
+    |}
+  | {|
+      property: "border-right",
+    |}
+  | {|
+      property: "border-block",
+    |}
+  | {|
+      property: "border-block-start",
+    |}
+  | {|
+      property: "border-block-end",
+    |}
+  | {|
+      property: "border-inline",
+    |}
+  | {|
+      property: "border-inline-start",
+    |}
+  | {|
+      property: "border-inline-end",
+    |}
+  | {|
+      property: "outline",
+    |}
+  | {|
+      property: "outline-color",
+    |}
+  | {|
+      property: "outline-style",
+    |}
+  | {|
+      property: "outline-width",
+    |}
+  | {|
+      property: "flex-direction",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-wrap",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-flow",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-grow",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-shrink",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-basis",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "order",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "align-content",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "justify-content",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "place-content",
+    |}
+  | {|
+      property: "align-self",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "justify-self",
+    |}
+  | {|
+      property: "place-self",
+    |}
+  | {|
+      property: "align-items",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "justify-items",
+    |}
+  | {|
+      property: "place-items",
+    |}
+  | {|
+      property: "row-gap",
+    |}
+  | {|
+      property: "column-gap",
+    |}
+  | {|
+      property: "gap",
+    |}
+  | {|
+      property: "box-orient",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-direction",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-ordinal-group",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-align",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-flex",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-flex-group",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-pack",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-lines",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-pack",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-order",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-align",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-item-align",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-line-pack",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-positive",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-negative",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-preferred-size",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "grid-template-columns",
+    |}
+  | {|
+      property: "grid-template-rows",
+    |}
+  | {|
+      property: "grid-auto-columns",
+    |}
+  | {|
+      property: "grid-auto-rows",
+    |}
+  | {|
+      property: "grid-auto-flow",
+    |}
+  | {|
+      property: "grid-template-areas",
+    |}
+  | {|
+      property: "grid-template",
+    |}
+  | {|
+      property: "grid",
+    |}
+  | {|
+      property: "grid-row-start",
+    |}
+  | {|
+      property: "grid-row-end",
+    |}
+  | {|
+      property: "grid-column-start",
+    |}
+  | {|
+      property: "grid-column-end",
+    |}
+  | {|
+      property: "grid-row",
+    |}
+  | {|
+      property: "grid-column",
+    |}
+  | {|
+      property: "grid-area",
+    |}
+  | {|
+      property: "margin-top",
+    |}
+  | {|
+      property: "margin-bottom",
+    |}
+  | {|
+      property: "margin-left",
+    |}
+  | {|
+      property: "margin-right",
+    |}
+  | {|
+      property: "margin-block-start",
+    |}
+  | {|
+      property: "margin-block-end",
+    |}
+  | {|
+      property: "margin-inline-start",
+    |}
+  | {|
+      property: "margin-inline-end",
+    |}
+  | {|
+      property: "margin-block",
+    |}
+  | {|
+      property: "margin-inline",
+    |}
+  | {|
+      property: "margin",
+    |}
+  | {|
+      property: "padding-top",
+    |}
+  | {|
+      property: "padding-bottom",
+    |}
+  | {|
+      property: "padding-left",
+    |}
+  | {|
+      property: "padding-right",
+    |}
+  | {|
+      property: "padding-block-start",
+    |}
+  | {|
+      property: "padding-block-end",
+    |}
+  | {|
+      property: "padding-inline-start",
+    |}
+  | {|
+      property: "padding-inline-end",
+    |}
+  | {|
+      property: "padding-block",
+    |}
+  | {|
+      property: "padding-inline",
+    |}
+  | {|
+      property: "padding",
+    |}
+  | {|
+      property: "scroll-margin-top",
+    |}
+  | {|
+      property: "scroll-margin-bottom",
+    |}
+  | {|
+      property: "scroll-margin-left",
+    |}
+  | {|
+      property: "scroll-margin-right",
+    |}
+  | {|
+      property: "scroll-margin-block-start",
+    |}
+  | {|
+      property: "scroll-margin-block-end",
+    |}
+  | {|
+      property: "scroll-margin-inline-start",
+    |}
+  | {|
+      property: "scroll-margin-inline-end",
+    |}
+  | {|
+      property: "scroll-margin-block",
+    |}
+  | {|
+      property: "scroll-margin-inline",
+    |}
+  | {|
+      property: "scroll-margin",
+    |}
+  | {|
+      property: "scroll-padding-top",
+    |}
+  | {|
+      property: "scroll-padding-bottom",
+    |}
+  | {|
+      property: "scroll-padding-left",
+    |}
+  | {|
+      property: "scroll-padding-right",
+    |}
+  | {|
+      property: "scroll-padding-block-start",
+    |}
+  | {|
+      property: "scroll-padding-block-end",
+    |}
+  | {|
+      property: "scroll-padding-inline-start",
+    |}
+  | {|
+      property: "scroll-padding-inline-end",
+    |}
+  | {|
+      property: "scroll-padding-block",
+    |}
+  | {|
+      property: "scroll-padding-inline",
+    |}
+  | {|
+      property: "scroll-padding",
+    |}
+  | {|
+      property: "font-weight",
+    |}
+  | {|
+      property: "font-size",
+    |}
+  | {|
+      property: "font-stretch",
+    |}
+  | {|
+      property: "font-family",
+    |}
+  | {|
+      property: "font-style",
+    |}
+  | {|
+      property: "font-variant-caps",
+    |}
+  | {|
+      property: "line-height",
+    |}
+  | {|
+      property: "font",
+    |}
+  | {|
+      property: "vertical-align",
+    |}
+  | {|
+      property: "font-palette",
+    |}
+  | {|
+      property: "transition-property",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transition-duration",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transition-delay",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transition-timing-function",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transition",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-name",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-duration",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-timing-function",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-iteration-count",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-direction",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-play-state",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-delay",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-fill-mode",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-composition",
+    |}
+  | {|
+      property: "animation-timeline",
+    |}
+  | {|
+      property: "animation-range-start",
+    |}
+  | {|
+      property: "animation-range-end",
+    |}
+  | {|
+      property: "animation-range",
+    |}
+  | {|
+      property: "animation",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transform",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transform-origin",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transform-style",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transform-box",
+    |}
+  | {|
+      property: "backface-visibility",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "perspective",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "perspective-origin",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "translate",
+    |}
+  | {|
+      property: "rotate",
+    |}
+  | {|
+      property: "scale",
+    |}
+  | {|
+      property: "text-transform",
+    |}
+  | {|
+      property: "white-space",
+    |}
+  | {|
+      property: "tab-size",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "word-break",
+    |}
+  | {|
+      property: "line-break",
+    |}
+  | {|
+      property: "hyphens",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "overflow-wrap",
+    |}
+  | {|
+      property: "word-wrap",
+    |}
+  | {|
+      property: "text-align",
+    |}
+  | {|
+      property: "text-align-last",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-justify",
+    |}
+  | {|
+      property: "word-spacing",
+    |}
+  | {|
+      property: "letter-spacing",
+    |}
+  | {|
+      property: "text-indent",
+    |}
+  | {|
+      property: "text-decoration-line",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-decoration-style",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-decoration-color",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-decoration-thickness",
+    |}
+  | {|
+      property: "text-decoration",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-decoration-skip-ink",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-emphasis-style",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-emphasis-color",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-emphasis",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-emphasis-position",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-shadow",
+    |}
+  | {|
+      property: "text-size-adjust",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "direction",
+    |}
+  | {|
+      property: "unicode-bidi",
+    |}
+  | {|
+      property: "box-decoration-break",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "resize",
+    |}
+  | {|
+      property: "cursor",
+    |}
+  | {|
+      property: "caret-color",
+    |}
+  | {|
+      property: "caret-shape",
+    |}
+  | {|
+      property: "caret",
+    |}
+  | {|
+      property: "user-select",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "accent-color",
+    |}
+  | {|
+      property: "appearance",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "list-style-type",
+    |}
+  | {|
+      property: "list-style-image",
+    |}
+  | {|
+      property: "list-style-position",
+    |}
+  | {|
+      property: "list-style",
+    |}
+  | {|
+      property: "marker-side",
+    |}
+  | {|
+      property: "composes",
+    |}
+  | {|
+      property: "fill",
+    |}
+  | {|
+      property: "fill-rule",
+    |}
+  | {|
+      property: "fill-opacity",
+    |}
+  | {|
+      property: "stroke",
+    |}
+  | {|
+      property: "stroke-opacity",
+    |}
+  | {|
+      property: "stroke-width",
+    |}
+  | {|
+      property: "stroke-linecap",
+    |}
+  | {|
+      property: "stroke-linejoin",
+    |}
+  | {|
+      property: "stroke-miterlimit",
+    |}
+  | {|
+      property: "stroke-dasharray",
+    |}
+  | {|
+      property: "stroke-dashoffset",
+    |}
+  | {|
+      property: "marker-start",
+    |}
+  | {|
+      property: "marker-mid",
+    |}
+  | {|
+      property: "marker-end",
+    |}
+  | {|
+      property: "marker",
+    |}
+  | {|
+      property: "color-interpolation",
+    |}
+  | {|
+      property: "color-interpolation-filters",
+    |}
+  | {|
+      property: "color-rendering",
+    |}
+  | {|
+      property: "shape-rendering",
+    |}
+  | {|
+      property: "text-rendering",
+    |}
+  | {|
+      property: "image-rendering",
+    |}
+  | {|
+      property: "clip-path",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "clip-rule",
+    |}
+  | {|
+      property: "mask-image",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-mode",
+    |}
+  | {|
+      property: "mask-repeat",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-position-x",
+    |}
+  | {|
+      property: "mask-position-y",
+    |}
+  | {|
+      property: "mask-position",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-clip",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-origin",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-size",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-composite",
+    |}
+  | {|
+      property: "mask-type",
+    |}
+  | {|
+      property: "mask",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-border-source",
+    |}
+  | {|
+      property: "mask-border-mode",
+    |}
+  | {|
+      property: "mask-border-slice",
+    |}
+  | {|
+      property: "mask-border-width",
+    |}
+  | {|
+      property: "mask-border-outset",
+    |}
+  | {|
+      property: "mask-border-repeat",
+    |}
+  | {|
+      property: "mask-border",
+    |}
+  | {|
+      property: "-webkit-mask-composite",
+    |}
+  | {|
+      property: "mask-source-type",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-source",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-slice",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-width",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-outset",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-repeat",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "filter",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "backdrop-filter",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "z-index",
+    |}
+  | {|
+      property: "container-type",
+    |}
+  | {|
+      property: "container-name",
+    |}
+  | {|
+      property: "container",
+    |}
+  | {|
+      property: "view-transition-name",
+    |}
+  | {|
+      property: "view-transition-class",
+    |}
+  | {|
+      property: "view-transition-group",
+    |}
+  | {|
+      property: "color-scheme",
+    |}
+  | {|
+      property: "print-color-adjust",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "all",
+    |}
+  | {|
+      property: string,
+    |};
+export type Prefix = "none" | "webkit" | "moz" | "ms" | "o";
+export type VendorPrefix = Prefix[];
+export type Declaration =
+  | {|
+      property: "background-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "background-image",
+      value: Image[],
+    |}
+  | {|
+      property: "background-position-x",
+      value: PositionComponentFor_HorizontalPositionKeyword[],
+    |}
+  | {|
+      property: "background-position-y",
+      value: PositionComponentFor_VerticalPositionKeyword[],
+    |}
+  | {|
+      property: "background-position",
+      value: BackgroundPosition[],
+    |}
+  | {|
+      property: "background-size",
+      value: BackgroundSize[],
+    |}
+  | {|
+      property: "background-repeat",
+      value: BackgroundRepeat[],
+    |}
+  | {|
+      property: "background-attachment",
+      value: BackgroundAttachment[],
+    |}
+  | {|
+      property: "background-clip",
+      value: BackgroundClip[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "background-origin",
+      value: BackgroundOrigin[],
+    |}
+  | {|
+      property: "background",
+      value: Background[],
+    |}
+  | {|
+      property: "box-shadow",
+      value: BoxShadow[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "opacity",
+      value: number,
+    |}
+  | {|
+      property: "color",
+      value: CssColor,
+    |}
+  | {|
+      property: "display",
+      value: Display,
+    |}
+  | {|
+      property: "visibility",
+      value: Visibility,
+    |}
+  | {|
+      property: "width",
+      value: Size,
+    |}
+  | {|
+      property: "height",
+      value: Size,
+    |}
+  | {|
+      property: "min-width",
+      value: Size,
+    |}
+  | {|
+      property: "min-height",
+      value: Size,
+    |}
+  | {|
+      property: "max-width",
+      value: MaxSize,
+    |}
+  | {|
+      property: "max-height",
+      value: MaxSize,
+    |}
+  | {|
+      property: "block-size",
+      value: Size,
+    |}
+  | {|
+      property: "inline-size",
+      value: Size,
+    |}
+  | {|
+      property: "min-block-size",
+      value: Size,
+    |}
+  | {|
+      property: "min-inline-size",
+      value: Size,
+    |}
+  | {|
+      property: "max-block-size",
+      value: MaxSize,
+    |}
+  | {|
+      property: "max-inline-size",
+      value: MaxSize,
+    |}
+  | {|
+      property: "box-sizing",
+      value: BoxSizing,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "aspect-ratio",
+      value: AspectRatio,
+    |}
+  | {|
+      property: "overflow",
+      value: Overflow,
+    |}
+  | {|
+      property: "overflow-x",
+      value: OverflowKeyword,
+    |}
+  | {|
+      property: "overflow-y",
+      value: OverflowKeyword,
+    |}
+  | {|
+      property: "text-overflow",
+      value: TextOverflow,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "position",
+      value: Position2,
+    |}
+  | {|
+      property: "top",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "bottom",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "left",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "right",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "inset-block-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "inset-block-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "inset-inline-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "inset-inline-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "inset-block",
+      value: InsetBlock,
+    |}
+  | {|
+      property: "inset-inline",
+      value: InsetInline,
+    |}
+  | {|
+      property: "inset",
+      value: Inset,
+    |}
+  | {|
+      property: "border-spacing",
+      value: Size2DFor_Length,
+    |}
+  | {|
+      property: "border-top-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "border-bottom-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "border-left-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "border-right-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "border-block-start-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "border-block-end-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "border-inline-start-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "border-inline-end-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "border-top-style",
+      value: LineStyle,
+    |}
+  | {|
+      property: "border-bottom-style",
+      value: LineStyle,
+    |}
+  | {|
+      property: "border-left-style",
+      value: LineStyle,
+    |}
+  | {|
+      property: "border-right-style",
+      value: LineStyle,
+    |}
+  | {|
+      property: "border-block-start-style",
+      value: LineStyle,
+    |}
+  | {|
+      property: "border-block-end-style",
+      value: LineStyle,
+    |}
+  | {|
+      property: "border-inline-start-style",
+      value: LineStyle,
+    |}
+  | {|
+      property: "border-inline-end-style",
+      value: LineStyle,
+    |}
+  | {|
+      property: "border-top-width",
+      value: BorderSideWidth,
+    |}
+  | {|
+      property: "border-bottom-width",
+      value: BorderSideWidth,
+    |}
+  | {|
+      property: "border-left-width",
+      value: BorderSideWidth,
+    |}
+  | {|
+      property: "border-right-width",
+      value: BorderSideWidth,
+    |}
+  | {|
+      property: "border-block-start-width",
+      value: BorderSideWidth,
+    |}
+  | {|
+      property: "border-block-end-width",
+      value: BorderSideWidth,
+    |}
+  | {|
+      property: "border-inline-start-width",
+      value: BorderSideWidth,
+    |}
+  | {|
+      property: "border-inline-end-width",
+      value: BorderSideWidth,
+    |}
+  | {|
+      property: "border-top-left-radius",
+      value: Size2DFor_DimensionPercentageFor_LengthValue,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-top-right-radius",
+      value: Size2DFor_DimensionPercentageFor_LengthValue,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-bottom-left-radius",
+      value: Size2DFor_DimensionPercentageFor_LengthValue,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-bottom-right-radius",
+      value: Size2DFor_DimensionPercentageFor_LengthValue,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-start-start-radius",
+      value: Size2DFor_DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      property: "border-start-end-radius",
+      value: Size2DFor_DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      property: "border-end-start-radius",
+      value: Size2DFor_DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      property: "border-end-end-radius",
+      value: Size2DFor_DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      property: "border-radius",
+      value: BorderRadius,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-image-source",
+      value: Image,
+    |}
+  | {|
+      property: "border-image-outset",
+      value: RectFor_LengthOrNumber,
+    |}
+  | {|
+      property: "border-image-repeat",
+      value: BorderImageRepeat,
+    |}
+  | {|
+      property: "border-image-width",
+      value: RectFor_BorderImageSideWidth,
+    |}
+  | {|
+      property: "border-image-slice",
+      value: BorderImageSlice,
+    |}
+  | {|
+      property: "border-image",
+      value: BorderImage,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "border-color",
+      value: BorderColor,
+    |}
+  | {|
+      property: "border-style",
+      value: BorderStyle,
+    |}
+  | {|
+      property: "border-width",
+      value: BorderWidth,
+    |}
+  | {|
+      property: "border-block-color",
+      value: BorderBlockColor,
+    |}
+  | {|
+      property: "border-block-style",
+      value: BorderBlockStyle,
+    |}
+  | {|
+      property: "border-block-width",
+      value: BorderBlockWidth,
+    |}
+  | {|
+      property: "border-inline-color",
+      value: BorderInlineColor,
+    |}
+  | {|
+      property: "border-inline-style",
+      value: BorderInlineStyle,
+    |}
+  | {|
+      property: "border-inline-width",
+      value: BorderInlineWidth,
+    |}
+  | {|
+      property: "border",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-top",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-bottom",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-left",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-right",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-block",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-block-start",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-block-end",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-inline",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-inline-start",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "border-inline-end",
+      value: GenericBorderFor_LineStyle,
+    |}
+  | {|
+      property: "outline",
+      value: GenericBorderFor_OutlineStyleAnd_11,
+    |}
+  | {|
+      property: "outline-color",
+      value: CssColor,
+    |}
+  | {|
+      property: "outline-style",
+      value: OutlineStyle,
+    |}
+  | {|
+      property: "outline-width",
+      value: BorderSideWidth,
+    |}
+  | {|
+      property: "flex-direction",
+      value: FlexDirection,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-wrap",
+      value: FlexWrap,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-flow",
+      value: FlexFlow,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-grow",
+      value: number,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-shrink",
+      value: number,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-basis",
+      value: LengthPercentageOrAuto,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex",
+      value: Flex,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "order",
+      value: number,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "align-content",
+      value: AlignContent,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "justify-content",
+      value: JustifyContent,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "place-content",
+      value: PlaceContent,
+    |}
+  | {|
+      property: "align-self",
+      value: AlignSelf,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "justify-self",
+      value: JustifySelf,
+    |}
+  | {|
+      property: "place-self",
+      value: PlaceSelf,
+    |}
+  | {|
+      property: "align-items",
+      value: AlignItems,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "justify-items",
+      value: JustifyItems,
+    |}
+  | {|
+      property: "place-items",
+      value: PlaceItems,
+    |}
+  | {|
+      property: "row-gap",
+      value: GapValue,
+    |}
+  | {|
+      property: "column-gap",
+      value: GapValue,
+    |}
+  | {|
+      property: "gap",
+      value: Gap,
+    |}
+  | {|
+      property: "box-orient",
+      value: BoxOrient,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-direction",
+      value: BoxDirection,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-ordinal-group",
+      value: number,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-align",
+      value: BoxAlign,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-flex",
+      value: number,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-flex-group",
+      value: number,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-pack",
+      value: BoxPack,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "box-lines",
+      value: BoxLines,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-pack",
+      value: FlexPack,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-order",
+      value: number,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-align",
+      value: BoxAlign,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-item-align",
+      value: FlexItemAlign,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-line-pack",
+      value: FlexLinePack,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-positive",
+      value: number,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-negative",
+      value: number,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "flex-preferred-size",
+      value: LengthPercentageOrAuto,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "grid-template-columns",
+      value: TrackSizing,
+    |}
+  | {|
+      property: "grid-template-rows",
+      value: TrackSizing,
+    |}
+  | {|
+      property: "grid-auto-columns",
+      value: TrackSize[],
+    |}
+  | {|
+      property: "grid-auto-rows",
+      value: TrackSize[],
+    |}
+  | {|
+      property: "grid-auto-flow",
+      value: GridAutoFlow,
+    |}
+  | {|
+      property: "grid-template-areas",
+      value: GridTemplateAreas,
+    |}
+  | {|
+      property: "grid-template",
+      value: GridTemplate,
+    |}
+  | {|
+      property: "grid",
+      value: Grid,
+    |}
+  | {|
+      property: "grid-row-start",
+      value: GridLine,
+    |}
+  | {|
+      property: "grid-row-end",
+      value: GridLine,
+    |}
+  | {|
+      property: "grid-column-start",
+      value: GridLine,
+    |}
+  | {|
+      property: "grid-column-end",
+      value: GridLine,
+    |}
+  | {|
+      property: "grid-row",
+      value: GridRow,
+    |}
+  | {|
+      property: "grid-column",
+      value: GridColumn,
+    |}
+  | {|
+      property: "grid-area",
+      value: GridArea,
+    |}
+  | {|
+      property: "margin-top",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "margin-bottom",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "margin-left",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "margin-right",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "margin-block-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "margin-block-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "margin-inline-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "margin-inline-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "margin-block",
+      value: MarginBlock,
+    |}
+  | {|
+      property: "margin-inline",
+      value: MarginInline,
+    |}
+  | {|
+      property: "margin",
+      value: Margin,
+    |}
+  | {|
+      property: "padding-top",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "padding-bottom",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "padding-left",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "padding-right",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "padding-block-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "padding-block-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "padding-inline-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "padding-inline-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "padding-block",
+      value: PaddingBlock,
+    |}
+  | {|
+      property: "padding-inline",
+      value: PaddingInline,
+    |}
+  | {|
+      property: "padding",
+      value: Padding,
+    |}
+  | {|
+      property: "scroll-margin-top",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-margin-bottom",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-margin-left",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-margin-right",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-margin-block-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-margin-block-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-margin-inline-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-margin-inline-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-margin-block",
+      value: ScrollMarginBlock,
+    |}
+  | {|
+      property: "scroll-margin-inline",
+      value: ScrollMarginInline,
+    |}
+  | {|
+      property: "scroll-margin",
+      value: ScrollMargin,
+    |}
+  | {|
+      property: "scroll-padding-top",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-padding-bottom",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-padding-left",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-padding-right",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-padding-block-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-padding-block-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-padding-inline-start",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-padding-inline-end",
+      value: LengthPercentageOrAuto,
+    |}
+  | {|
+      property: "scroll-padding-block",
+      value: ScrollPaddingBlock,
+    |}
+  | {|
+      property: "scroll-padding-inline",
+      value: ScrollPaddingInline,
+    |}
+  | {|
+      property: "scroll-padding",
+      value: ScrollPadding,
+    |}
+  | {|
+      property: "font-weight",
+      value: FontWeight,
+    |}
+  | {|
+      property: "font-size",
+      value: FontSize,
+    |}
+  | {|
+      property: "font-stretch",
+      value: FontStretch,
+    |}
+  | {|
+      property: "font-family",
+      value: FontFamily[],
+    |}
+  | {|
+      property: "font-style",
+      value: FontStyle,
+    |}
+  | {|
+      property: "font-variant-caps",
+      value: FontVariantCaps,
+    |}
+  | {|
+      property: "line-height",
+      value: LineHeight,
+    |}
+  | {|
+      property: "font",
+      value: Font,
+    |}
+  | {|
+      property: "vertical-align",
+      value: VerticalAlign,
+    |}
+  | {|
+      property: "font-palette",
+      value: DashedIdentReference,
+    |}
+  | {|
+      property: "transition-property",
+      value: PropertyId[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transition-duration",
+      value: Time[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transition-delay",
+      value: Time[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transition-timing-function",
+      value: EasingFunction[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transition",
+      value: Transition[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-name",
+      value: AnimationName[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-duration",
+      value: Time[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-timing-function",
+      value: EasingFunction[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-iteration-count",
+      value: AnimationIterationCount[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-direction",
+      value: AnimationDirection[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-play-state",
+      value: AnimationPlayState[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-delay",
+      value: Time[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-fill-mode",
+      value: AnimationFillMode[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "animation-composition",
+      value: AnimationComposition[],
+    |}
+  | {|
+      property: "animation-timeline",
+      value: AnimationTimeline[],
+    |}
+  | {|
+      property: "animation-range-start",
+      value: AnimationRangeStart[],
+    |}
+  | {|
+      property: "animation-range-end",
+      value: AnimationRangeEnd[],
+    |}
+  | {|
+      property: "animation-range",
+      value: AnimationRange[],
+    |}
+  | {|
+      property: "animation",
+      value: Animation[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transform",
+      value: Transform[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transform-origin",
+      value: Position,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transform-style",
+      value: TransformStyle,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "transform-box",
+      value: TransformBox,
+    |}
+  | {|
+      property: "backface-visibility",
+      value: BackfaceVisibility,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "perspective",
+      value: Perspective,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "perspective-origin",
+      value: Position,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "translate",
+      value: Translate,
+    |}
+  | {|
+      property: "rotate",
+      value: Rotate,
+    |}
+  | {|
+      property: "scale",
+      value: Scale,
+    |}
+  | {|
+      property: "text-transform",
+      value: TextTransform,
+    |}
+  | {|
+      property: "white-space",
+      value: WhiteSpace,
+    |}
+  | {|
+      property: "tab-size",
+      value: LengthOrNumber,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "word-break",
+      value: WordBreak,
+    |}
+  | {|
+      property: "line-break",
+      value: LineBreak,
+    |}
+  | {|
+      property: "hyphens",
+      value: Hyphens,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "overflow-wrap",
+      value: OverflowWrap,
+    |}
+  | {|
+      property: "word-wrap",
+      value: OverflowWrap,
+    |}
+  | {|
+      property: "text-align",
+      value: TextAlign,
+    |}
+  | {|
+      property: "text-align-last",
+      value: TextAlignLast,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-justify",
+      value: TextJustify,
+    |}
+  | {|
+      property: "word-spacing",
+      value: Spacing,
+    |}
+  | {|
+      property: "letter-spacing",
+      value: Spacing,
+    |}
+  | {|
+      property: "text-indent",
+      value: TextIndent,
+    |}
+  | {|
+      property: "text-decoration-line",
+      value: TextDecorationLine,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-decoration-style",
+      value: TextDecorationStyle,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-decoration-color",
+      value: CssColor,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-decoration-thickness",
+      value: TextDecorationThickness,
+    |}
+  | {|
+      property: "text-decoration",
+      value: TextDecoration,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-decoration-skip-ink",
+      value: TextDecorationSkipInk,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-emphasis-style",
+      value: TextEmphasisStyle,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-emphasis-color",
+      value: CssColor,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-emphasis",
+      value: TextEmphasis,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-emphasis-position",
+      value: TextEmphasisPosition,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "text-shadow",
+      value: TextShadow[],
+    |}
+  | {|
+      property: "text-size-adjust",
+      value: TextSizeAdjust,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "direction",
+      value: Direction2,
+    |}
+  | {|
+      property: "unicode-bidi",
+      value: UnicodeBidi,
+    |}
+  | {|
+      property: "box-decoration-break",
+      value: BoxDecorationBreak,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "resize",
+      value: Resize,
+    |}
+  | {|
+      property: "cursor",
+      value: Cursor,
+    |}
+  | {|
+      property: "caret-color",
+      value: ColorOrAuto,
+    |}
+  | {|
+      property: "caret-shape",
+      value: CaretShape,
+    |}
+  | {|
+      property: "caret",
+      value: Caret,
+    |}
+  | {|
+      property: "user-select",
+      value: UserSelect,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "accent-color",
+      value: ColorOrAuto,
+    |}
+  | {|
+      property: "appearance",
+      value: Appearance,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "list-style-type",
+      value: ListStyleType,
+    |}
+  | {|
+      property: "list-style-image",
+      value: Image,
+    |}
+  | {|
+      property: "list-style-position",
+      value: ListStylePosition,
+    |}
+  | {|
+      property: "list-style",
+      value: ListStyle,
+    |}
+  | {|
+      property: "marker-side",
+      value: MarkerSide,
+    |}
+  | {|
+      property: "composes",
+      value: Composes,
+    |}
+  | {|
+      property: "fill",
+      value: SVGPaint,
+    |}
+  | {|
+      property: "fill-rule",
+      value: FillRule,
+    |}
+  | {|
+      property: "fill-opacity",
+      value: number,
+    |}
+  | {|
+      property: "stroke",
+      value: SVGPaint,
+    |}
+  | {|
+      property: "stroke-opacity",
+      value: number,
+    |}
+  | {|
+      property: "stroke-width",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      property: "stroke-linecap",
+      value: StrokeLinecap,
+    |}
+  | {|
+      property: "stroke-linejoin",
+      value: StrokeLinejoin,
+    |}
+  | {|
+      property: "stroke-miterlimit",
+      value: number,
+    |}
+  | {|
+      property: "stroke-dasharray",
+      value: StrokeDasharray,
+    |}
+  | {|
+      property: "stroke-dashoffset",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      property: "marker-start",
+      value: Marker,
+    |}
+  | {|
+      property: "marker-mid",
+      value: Marker,
+    |}
+  | {|
+      property: "marker-end",
+      value: Marker,
+    |}
+  | {|
+      property: "marker",
+      value: Marker,
+    |}
+  | {|
+      property: "color-interpolation",
+      value: ColorInterpolation,
+    |}
+  | {|
+      property: "color-interpolation-filters",
+      value: ColorInterpolation,
+    |}
+  | {|
+      property: "color-rendering",
+      value: ColorRendering,
+    |}
+  | {|
+      property: "shape-rendering",
+      value: ShapeRendering,
+    |}
+  | {|
+      property: "text-rendering",
+      value: TextRendering,
+    |}
+  | {|
+      property: "image-rendering",
+      value: ImageRendering,
+    |}
+  | {|
+      property: "clip-path",
+      value: ClipPath,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "clip-rule",
+      value: FillRule,
+    |}
+  | {|
+      property: "mask-image",
+      value: Image[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-mode",
+      value: MaskMode[],
+    |}
+  | {|
+      property: "mask-repeat",
+      value: BackgroundRepeat[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-position-x",
+      value: PositionComponentFor_HorizontalPositionKeyword[],
+    |}
+  | {|
+      property: "mask-position-y",
+      value: PositionComponentFor_VerticalPositionKeyword[],
+    |}
+  | {|
+      property: "mask-position",
+      value: Position[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-clip",
+      value: MaskClip[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-origin",
+      value: GeometryBox[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-size",
+      value: BackgroundSize[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-composite",
+      value: MaskComposite[],
+    |}
+  | {|
+      property: "mask-type",
+      value: MaskType,
+    |}
+  | {|
+      property: "mask",
+      value: Mask[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-border-source",
+      value: Image,
+    |}
+  | {|
+      property: "mask-border-mode",
+      value: MaskBorderMode,
+    |}
+  | {|
+      property: "mask-border-slice",
+      value: BorderImageSlice,
+    |}
+  | {|
+      property: "mask-border-width",
+      value: RectFor_BorderImageSideWidth,
+    |}
+  | {|
+      property: "mask-border-outset",
+      value: RectFor_LengthOrNumber,
+    |}
+  | {|
+      property: "mask-border-repeat",
+      value: BorderImageRepeat,
+    |}
+  | {|
+      property: "mask-border",
+      value: MaskBorder,
+    |}
+  | {|
+      property: "-webkit-mask-composite",
+      value: WebKitMaskComposite[],
+    |}
+  | {|
+      property: "mask-source-type",
+      value: WebKitMaskSourceType[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image",
+      value: BorderImage,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-source",
+      value: Image,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-slice",
+      value: BorderImageSlice,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-width",
+      value: RectFor_BorderImageSideWidth,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-outset",
+      value: RectFor_LengthOrNumber,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "mask-box-image-repeat",
+      value: BorderImageRepeat,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "filter",
+      value: FilterList,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "backdrop-filter",
+      value: FilterList,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "z-index",
+      value: ZIndex,
+    |}
+  | {|
+      property: "container-type",
+      value: ContainerType,
+    |}
+  | {|
+      property: "container-name",
+      value: ContainerNameList,
+    |}
+  | {|
+      property: "container",
+      value: Container,
+    |}
+  | {|
+      property: "view-transition-name",
+      value: ViewTransitionName,
+    |}
+  | {|
+      property: "view-transition-class",
+      value: NoneOrCustomIdentList,
+    |}
+  | {|
+      property: "view-transition-group",
+      value: ViewTransitionGroup,
+    |}
+  | {|
+      property: "color-scheme",
+      value: ColorScheme,
+    |}
+  | {|
+      property: "print-color-adjust",
+      value: PrintColorAdjust,
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      property: "all",
+      value: CSSWideKeyword,
+    |}
+  | {|
+      property: "unparsed",
+      value: UnparsedProperty,
+    |}
+  | {|
+      property: "custom",
+      value: CustomProperty,
+    |};
+/**
+ * A CSS [`<image>`](https://www.w3.org/TR/css-images-3/#image-values) value.
+ */
+export type Image =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "url",
+      value: Url,
+    |}
+  | {|
+      type: "gradient",
+      value: Gradient,
+    |}
+  | {|
+      type: "image-set",
+      value: ImageSet,
+    |};
+/**
+ * A CSS [`<gradient>`](https://www.w3.org/TR/css-images-3/#gradients) value.
+ */
+export type Gradient =
+  | {|
+      /**
+       * The direction of the gradient.
+       */
+      direction: LineDirection,
+
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_LengthValue[],
+      type: "linear",
+
+      /**
+       * The vendor prefixes for the gradient.
+       */
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      /**
+       * The direction of the gradient.
+       */
+      direction: LineDirection,
+
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_LengthValue[],
+      type: "repeating-linear",
+
+      /**
+       * The vendor prefixes for the gradient.
+       */
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_LengthValue[],
+
+      /**
+       * The position of the gradient.
+       */
+      position: Position,
+
+      /**
+       * The shape of the gradient.
+       */
+      shape: EndingShape,
+      type: "radial",
+
+      /**
+       * The vendor prefixes for the gradient.
+       */
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_LengthValue[],
+
+      /**
+       * The position of the gradient.
+       */
+      position: Position,
+
+      /**
+       * The shape of the gradient.
+       */
+      shape: EndingShape,
+      type: "repeating-radial",
+
+      /**
+       * The vendor prefixes for the gradient.
+       */
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      /**
+       * The angle of the gradient.
+       */
+      angle: Angle,
+
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_Angle[],
+
+      /**
+       * The position of the gradient.
+       */
+      position: Position,
+      type: "conic",
+    |}
+  | {|
+      /**
+       * The angle of the gradient.
+       */
+      angle: Angle,
+
+      /**
+       * The color stops and transition hints for the gradient.
+       */
+      items: GradientItemFor_DimensionPercentageFor_Angle[],
+
+      /**
+       * The position of the gradient.
+       */
+      position: Position,
+      type: "repeating-conic",
+    |}
+  | (
+      | {|
+          type: "webkit-gradient",
+
+          /**
+           * The starting point of the gradient.
+           */
+          from: WebKitGradientPoint,
+          kind: "linear",
+
+          /**
+           * The color stops in the gradient.
+           */
+          stops: WebKitColorStop[],
+
+          /**
+           * The ending point of the gradient.
+           */
+          to: WebKitGradientPoint,
+        |}
+      | {|
+          type: "webkit-gradient",
+
+          /**
+           * The starting point of the gradient.
+           */
+          from: WebKitGradientPoint,
+          kind: "radial",
+
+          /**
+           * The starting radius of the gradient.
+           */
+          r0: number,
+
+          /**
+           * The ending radius of the gradient.
+           */
+          r1: number,
+
+          /**
+           * The color stops in the gradient.
+           */
+          stops: WebKitColorStop[],
+
+          /**
+           * The ending point of the gradient.
+           */
+          to: WebKitGradientPoint,
+        |}
+    );
+/**
+ * The direction of a CSS `linear-gradient()`.
+ *
+ * See [LinearGradient](LinearGradient).
+ */
+export type LineDirection =
+  | {|
+      type: "angle",
+      value: Angle,
+    |}
+  | {|
+      type: "horizontal",
+      value: HorizontalPositionKeyword,
+    |}
+  | {|
+      type: "vertical",
+      value: VerticalPositionKeyword,
+    |}
+  | {|
+      /**
+       * A horizontal position keyword, e.g. `left` or `right.
+       */
+      horizontal: HorizontalPositionKeyword,
+      type: "corner",
+
+      /**
+       * A vertical posision keyword, e.g. `top` or `bottom`.
+       */
+      vertical: VerticalPositionKeyword,
+    |};
+/**
+ * A horizontal position keyword.
+ */
+export type HorizontalPositionKeyword = "left" | "right";
+/**
+ * A vertical position keyword.
+ */
+export type VerticalPositionKeyword = "top" | "bottom";
+/**
+ * Either a color stop or interpolation hint within a gradient.
+ *
+ * This type is generic, and items may be either a [LengthPercentage](super::length::LengthPercentage) or [Angle](super::angle::Angle) depending on what type of gradient it is within.
+ */
+export type GradientItemFor_DimensionPercentageFor_LengthValue =
+  | {|
+      /**
+       * The color of the color stop.
+       */
+      color: CssColor,
+
+      /**
+       * The position of the color stop.
+       */
+      position?: DimensionPercentageFor_LengthValue | null,
+      type: "color-stop",
+    |}
+  | {|
+      type: "hint",
+      value: DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A generic type that allows any kind of dimension and percentage to be used standalone or mixed within a `calc()` expression.
+ *
+ * <https://drafts.csswg.org/css-values-4/#mixed-percentages>
+ */
+export type DimensionPercentageFor_LengthValue =
+  | {|
+      type: "dimension",
+      value: LengthValue,
+    |}
+  | {|
+      type: "percentage",
+      value: number,
+    |}
+  | {|
+      type: "calc",
+      value: CalcFor_DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A mathematical expression used within the [`calc()`](https://www.w3.org/TR/css-values-4/#calc-func) function.
+ *
+ * This type supports generic value types. Values such as [Length](super::length::Length), [Percentage](super::percentage::Percentage), [Time](super::time::Time), and [Angle](super::angle::Angle) support `calc()` expressions.
+ */
+export type CalcFor_DimensionPercentageFor_LengthValue =
+  | {|
+      type: "value",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "sum",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_LengthValue,
+        CalcFor_DimensionPercentageFor_LengthValue
+      ],
+    |}
+  | {|
+      type: "product",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [number, CalcFor_DimensionPercentageFor_LengthValue],
+    |}
+  | {|
+      type: "function",
+      value: MathFunctionFor_DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A CSS [math function](https://www.w3.org/TR/css-values-4/#math-function).
+ *
+ * Math functions may be used in most properties and values that accept numeric values, including lengths, percentages, angles, times, etc.
+ */
+export type MathFunctionFor_DimensionPercentageFor_LengthValue =
+  | {|
+      type: "calc",
+      value: CalcFor_DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "min",
+      value: CalcFor_DimensionPercentageFor_LengthValue[],
+    |}
+  | {|
+      type: "max",
+      value: CalcFor_DimensionPercentageFor_LengthValue[],
+    |}
+  | {|
+      type: "clamp",
+
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_LengthValue,
+        CalcFor_DimensionPercentageFor_LengthValue,
+        CalcFor_DimensionPercentageFor_LengthValue
+      ],
+    |}
+  | {|
+      type: "round",
+
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [
+        RoundingStrategy,
+        CalcFor_DimensionPercentageFor_LengthValue,
+        CalcFor_DimensionPercentageFor_LengthValue
+      ],
+    |}
+  | {|
+      type: "rem",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_LengthValue,
+        CalcFor_DimensionPercentageFor_LengthValue
+      ],
+    |}
+  | {|
+      type: "mod",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_LengthValue,
+        CalcFor_DimensionPercentageFor_LengthValue
+      ],
+    |}
+  | {|
+      type: "abs",
+      value: CalcFor_DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "sign",
+      value: CalcFor_DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "hypot",
+      value: CalcFor_DimensionPercentageFor_LengthValue[],
+    |};
+/**
+ * A component within a [Position](Position) value, representing a position along either the horizontal or vertical axis of a box.
+ *
+ * This type is generic over side keywords.
+ */
+export type PositionComponentFor_HorizontalPositionKeyword =
+  | {|
+      type: "center",
+    |}
+  | {|
+      type: "length",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      /**
+       * Offset from the side.
+       */
+      offset?: DimensionPercentageFor_LengthValue | null,
+
+      /**
+       * A side keyword.
+       */
+      side: HorizontalPositionKeyword,
+      type: "side",
+    |};
+/**
+ * A component within a [Position](Position) value, representing a position along either the horizontal or vertical axis of a box.
+ *
+ * This type is generic over side keywords.
+ */
+export type PositionComponentFor_VerticalPositionKeyword =
+  | {|
+      type: "center",
+    |}
+  | {|
+      type: "length",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      /**
+       * Offset from the side.
+       */
+      offset?: DimensionPercentageFor_LengthValue | null,
+
+      /**
+       * A side keyword.
+       */
+      side: VerticalPositionKeyword,
+      type: "side",
+    |};
+/**
+ * A `radial-gradient()` [ending shape](https://www.w3.org/TR/css-images-3/#valdef-radial-gradient-ending-shape).
+ *
+ * See [RadialGradient](RadialGradient).
+ */
+export type EndingShape =
+  | {|
+      type: "ellipse",
+      value: Ellipse,
+    |}
+  | {|
+      type: "circle",
+      value: Circle,
+    |};
+/**
+ * An ellipse ending shape for a `radial-gradient()`.
+ *
+ * See [RadialGradient](RadialGradient).
+ */
+export type Ellipse =
+  | {|
+      type: "size",
+
+      /**
+       * The x-radius of the ellipse.
+       */
+      x: DimensionPercentageFor_LengthValue,
+
+      /**
+       * The y-radius of the ellipse.
+       */
+      y: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "extent",
+      value: ShapeExtent,
+    |};
+/**
+ * A shape extent for a `radial-gradient()`.
+ *
+ * See [RadialGradient](RadialGradient).
+ */
+export type ShapeExtent =
+  | "closest-side"
+  | "farthest-side"
+  | "closest-corner"
+  | "farthest-corner";
+/**
+ * A circle ending shape for a `radial-gradient()`.
+ *
+ * See [RadialGradient](RadialGradient).
+ */
+export type Circle =
+  | {|
+      type: "radius",
+      value: Length,
+    |}
+  | {|
+      type: "extent",
+      value: ShapeExtent,
+    |};
+/**
+ * Either a color stop or interpolation hint within a gradient.
+ *
+ * This type is generic, and items may be either a [LengthPercentage](super::length::LengthPercentage) or [Angle](super::angle::Angle) depending on what type of gradient it is within.
+ */
+export type GradientItemFor_DimensionPercentageFor_Angle =
+  | {|
+      /**
+       * The color of the color stop.
+       */
+      color: CssColor,
+
+      /**
+       * The position of the color stop.
+       */
+      position?: DimensionPercentageFor_Angle | null,
+      type: "color-stop",
+    |}
+  | {|
+      type: "hint",
+      value: DimensionPercentageFor_Angle,
+    |};
+/**
+ * A generic type that allows any kind of dimension and percentage to be used standalone or mixed within a `calc()` expression.
+ *
+ * <https://drafts.csswg.org/css-values-4/#mixed-percentages>
+ */
+export type DimensionPercentageFor_Angle =
+  | {|
+      type: "dimension",
+      value: Angle,
+    |}
+  | {|
+      type: "percentage",
+      value: number,
+    |}
+  | {|
+      type: "calc",
+      value: CalcFor_DimensionPercentageFor_Angle,
+    |};
+/**
+ * A mathematical expression used within the [`calc()`](https://www.w3.org/TR/css-values-4/#calc-func) function.
+ *
+ * This type supports generic value types. Values such as [Length](super::length::Length), [Percentage](super::percentage::Percentage), [Time](super::time::Time), and [Angle](super::angle::Angle) support `calc()` expressions.
+ */
+export type CalcFor_DimensionPercentageFor_Angle =
+  | {|
+      type: "value",
+      value: DimensionPercentageFor_Angle,
+    |}
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "sum",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_Angle,
+        CalcFor_DimensionPercentageFor_Angle
+      ],
+    |}
+  | {|
+      type: "product",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [number, CalcFor_DimensionPercentageFor_Angle],
+    |}
+  | {|
+      type: "function",
+      value: MathFunctionFor_DimensionPercentageFor_Angle,
+    |};
+/**
+ * A CSS [math function](https://www.w3.org/TR/css-values-4/#math-function).
+ *
+ * Math functions may be used in most properties and values that accept numeric values, including lengths, percentages, angles, times, etc.
+ */
+export type MathFunctionFor_DimensionPercentageFor_Angle =
+  | {|
+      type: "calc",
+      value: CalcFor_DimensionPercentageFor_Angle,
+    |}
+  | {|
+      type: "min",
+      value: CalcFor_DimensionPercentageFor_Angle[],
+    |}
+  | {|
+      type: "max",
+      value: CalcFor_DimensionPercentageFor_Angle[],
+    |}
+  | {|
+      type: "clamp",
+
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_Angle,
+        CalcFor_DimensionPercentageFor_Angle,
+        CalcFor_DimensionPercentageFor_Angle
+      ],
+    |}
+  | {|
+      type: "round",
+
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [
+        RoundingStrategy,
+        CalcFor_DimensionPercentageFor_Angle,
+        CalcFor_DimensionPercentageFor_Angle
+      ],
+    |}
+  | {|
+      type: "rem",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_Angle,
+        CalcFor_DimensionPercentageFor_Angle
+      ],
+    |}
+  | {|
+      type: "mod",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [
+        CalcFor_DimensionPercentageFor_Angle,
+        CalcFor_DimensionPercentageFor_Angle
+      ],
+    |}
+  | {|
+      type: "abs",
+      value: CalcFor_DimensionPercentageFor_Angle,
+    |}
+  | {|
+      type: "sign",
+      value: CalcFor_DimensionPercentageFor_Angle,
+    |}
+  | {|
+      type: "hypot",
+      value: CalcFor_DimensionPercentageFor_Angle[],
+    |};
+/**
+ * A keyword or number within a [WebKitGradientPoint](WebKitGradientPoint).
+ */
+export type WebKitGradientPointComponentFor_HorizontalPositionKeyword =
+  | {|
+      type: "center",
+    |}
+  | {|
+      type: "number",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "side",
+      value: HorizontalPositionKeyword,
+    |};
+/**
+ * Either a `<number>` or `<percentage>`.
+ */
+export type NumberOrPercentage =
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "percentage",
+      value: number,
+    |};
+/**
+ * A keyword or number within a [WebKitGradientPoint](WebKitGradientPoint).
+ */
+export type WebKitGradientPointComponentFor_VerticalPositionKeyword =
+  | {|
+      type: "center",
+    |}
+  | {|
+      type: "number",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "side",
+      value: VerticalPositionKeyword,
+    |};
+/**
+ * A value for the [background-size](https://www.w3.org/TR/css-backgrounds-3/#background-size) property.
+ */
+export type BackgroundSize =
+  | {|
+      /**
+       * The height of the background.
+       */
+      height: LengthPercentageOrAuto,
+      type: "explicit",
+
+      /**
+       * The width of the background.
+       */
+      width: LengthPercentageOrAuto,
+    |}
+  | {|
+      type: "cover",
+    |}
+  | {|
+      type: "contain",
+    |};
+/**
+ * Either a [`<length-percentage>`](https://www.w3.org/TR/css-values-4/#typedef-length-percentage), or the `auto` keyword.
+ */
+export type LengthPercentageOrAuto =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "length-percentage",
+      value: DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A [`<repeat-style>`](https://www.w3.org/TR/css-backgrounds-3/#typedef-repeat-style) value, used within the `background-repeat` property to represent how a background image is repeated in a single direction.
+ *
+ * See [BackgroundRepeat](BackgroundRepeat).
+ */
+export type BackgroundRepeatKeyword =
+  | "repeat"
+  | "space"
+  | "round"
+  | "no-repeat";
+/**
+ * A value for the [background-attachment](https://www.w3.org/TR/css-backgrounds-3/#background-attachment) property.
+ */
+export type BackgroundAttachment = "scroll" | "fixed" | "local";
+/**
+ * A value for the [background-clip](https://drafts.csswg.org/css-backgrounds-4/#background-clip) property.
+ */
+export type BackgroundClip =
+  | "border-box"
+  | "padding-box"
+  | "content-box"
+  | "border"
+  | "text";
+/**
+ * A value for the [background-origin](https://www.w3.org/TR/css-backgrounds-3/#background-origin) property.
+ */
+export type BackgroundOrigin = "border-box" | "padding-box" | "content-box";
+/**
+ * A value for the [display](https://drafts.csswg.org/css-display-3/#the-display-properties) property.
+ */
+export type Display =
+  | {|
+      type: "keyword",
+      value: DisplayKeyword,
+    |}
+  | {|
+      /**
+       * The inside display value.
+       */
+      inside: DisplayInside,
+
+      /**
+       * Whether this is a list item.
+       */
+      isListItem: boolean,
+
+      /**
+       * The outside display value.
+       */
+      outside: DisplayOutside,
+      type: "pair",
+    |};
+/**
+ * A `display` keyword.
+ *
+ * See [Display](Display).
+ */
+export type DisplayKeyword =
+  | "none"
+  | "contents"
+  | "table-row-group"
+  | "table-header-group"
+  | "table-footer-group"
+  | "table-row"
+  | "table-cell"
+  | "table-column-group"
+  | "table-column"
+  | "table-caption"
+  | "ruby-base"
+  | "ruby-text"
+  | "ruby-base-container"
+  | "ruby-text-container";
+/**
+ * A [`<display-inside>`](https://drafts.csswg.org/css-display-3/#typedef-display-inside) value.
+ */
+export type DisplayInside =
+  | {|
+      type: "flow",
+    |}
+  | {|
+      type: "flow-root",
+    |}
+  | {|
+      type: "table",
+    |}
+  | {|
+      type: "flex",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "box",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "grid",
+    |}
+  | {|
+      type: "ruby",
+    |};
+/**
+ * A [`<display-outside>`](https://drafts.csswg.org/css-display-3/#typedef-display-outside) value.
+ */
+export type DisplayOutside = "block" | "inline" | "run-in";
+/**
+ * A value for the [visibility](https://drafts.csswg.org/css-display-3/#visibility) property.
+ */
+export type Visibility = "visible" | "hidden" | "collapse";
+/**
+ * A value for the [preferred size properties](https://drafts.csswg.org/css-sizing-3/#preferred-size-properties), i.e. `width` and `height.
+ */
+export type Size =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "length-percentage",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "min-content",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "max-content",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "fit-content",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "fit-content-function",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "stretch",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "contain",
+    |};
+/**
+ * A value for the [minimum](https://drafts.csswg.org/css-sizing-3/#min-size-properties) and [maximum](https://drafts.csswg.org/css-sizing-3/#max-size-properties) size properties, e.g. `min-width` and `max-height`.
+ */
+export type MaxSize =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "length-percentage",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "min-content",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "max-content",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "fit-content",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "fit-content-function",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "stretch",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      type: "contain",
+    |};
+/**
+ * A value for the [box-sizing](https://drafts.csswg.org/css-sizing-3/#box-sizing) property.
+ */
+export type BoxSizing = "content-box" | "border-box";
+/**
+ * An [overflow](https://www.w3.org/TR/css-overflow-3/#overflow-properties) keyword as used in the `overflow-x`, `overflow-y`, and `overflow` properties.
+ */
+export type OverflowKeyword = "visible" | "hidden" | "clip" | "scroll" | "auto";
+/**
+ * A value for the [text-overflow](https://www.w3.org/TR/css-overflow-3/#text-overflow) property.
+ */
+export type TextOverflow = "clip" | "ellipsis";
+/**
+ * A value for the [position](https://www.w3.org/TR/css-position-3/#position-property) property.
+ */
+export type Position2 =
+  | {|
+      type: "static",
+    |}
+  | {|
+      type: "relative",
+    |}
+  | {|
+      type: "absolute",
+    |}
+  | {|
+      type: "sticky",
+      value: VendorPrefix,
+    |}
+  | {|
+      type: "fixed",
+    |};
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_Length = [Length, Length];
+/**
+ * A [`<line-style>`](https://drafts.csswg.org/css-backgrounds/#typedef-line-style) value, used in the `border-style` property.
+ */
+export type LineStyle =
+  | "none"
+  | "hidden"
+  | "inset"
+  | "groove"
+  | "outset"
+  | "ridge"
+  | "dotted"
+  | "dashed"
+  | "solid"
+  | "double";
+/**
+ * A value for the [border-width](https://www.w3.org/TR/css-backgrounds-3/#border-width) property.
+ */
+export type BorderSideWidth =
+  | {|
+      type: "thin",
+    |}
+  | {|
+      type: "medium",
+    |}
+  | {|
+      type: "thick",
+    |}
+  | {|
+      type: "length",
+      value: Length,
+    |};
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_DimensionPercentageFor_LengthValue = [
+  DimensionPercentageFor_LengthValue,
+  DimensionPercentageFor_LengthValue
+];
+/**
+ * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc.
+ *
+ * When serialized, as few components as possible are written when there are duplicate values.
+ * @minItems 4
+ * @maxItems 4
+ */
+export type RectFor_LengthOrNumber = [
+  LengthOrNumber,
+  LengthOrNumber,
+  LengthOrNumber,
+  LengthOrNumber
+];
+/**
+ * Either a [`<length>`](https://www.w3.org/TR/css-values-4/#lengths) or a [`<number>`](https://www.w3.org/TR/css-values-4/#numbers).
+ */
+export type LengthOrNumber =
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "length",
+      value: Length,
+    |};
+/**
+ * A single [border-image-repeat](https://www.w3.org/TR/css-backgrounds-3/#border-image-repeat) keyword.
+ */
+export type BorderImageRepeatKeyword = "stretch" | "repeat" | "round" | "space";
+/**
+ * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc.
+ *
+ * When serialized, as few components as possible are written when there are duplicate values.
+ * @minItems 4
+ * @maxItems 4
+ */
+export type RectFor_BorderImageSideWidth = [
+  BorderImageSideWidth,
+  BorderImageSideWidth,
+  BorderImageSideWidth,
+  BorderImageSideWidth
+];
+/**
+ * A value for the [border-image-width](https://www.w3.org/TR/css-backgrounds-3/#border-image-width) property.
+ */
+export type BorderImageSideWidth =
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "length-percentage",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "auto",
+    |};
+/**
+ * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc.
+ *
+ * When serialized, as few components as possible are written when there are duplicate values.
+ * @minItems 4
+ * @maxItems 4
+ */
+export type RectFor_NumberOrPercentage = [
+  NumberOrPercentage,
+  NumberOrPercentage,
+  NumberOrPercentage,
+  NumberOrPercentage
+];
+/**
+ * A value for the [outline-style](https://drafts.csswg.org/css-ui/#outline-style) property.
+ */
+export type OutlineStyle =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "line-style",
+      value: LineStyle,
+    |};
+/**
+ * A value for the [flex-direction](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#propdef-flex-direction) property.
+ */
+export type FlexDirection = "row" | "row-reverse" | "column" | "column-reverse";
+/**
+ * A value for the [flex-wrap](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-wrap-property) property.
+ */
+export type FlexWrap = "nowrap" | "wrap" | "wrap-reverse";
+/**
+ * A value for the [align-content](https://www.w3.org/TR/css-align-3/#propdef-align-content) property.
+ */
+export type AlignContent =
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "baseline-position",
+      value: BaselinePosition,
+    |}
+  | {|
+      type: "content-distribution",
+      value: ContentDistribution,
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "content-position",
+
+      /**
+       * A content position keyword.
+       */
+      value: ContentPosition,
+    |};
+/**
+ * A [`<baseline-position>`](https://www.w3.org/TR/css-align-3/#typedef-baseline-position) value, as used in the alignment properties.
+ */
+export type BaselinePosition = "first" | "last";
+/**
+ * A [`<content-distribution>`](https://www.w3.org/TR/css-align-3/#typedef-content-distribution) value.
+ */
+export type ContentDistribution =
+  | "space-between"
+  | "space-around"
+  | "space-evenly"
+  | "stretch";
+/**
+ * An [`<overflow-position>`](https://www.w3.org/TR/css-align-3/#typedef-overflow-position) value.
+ */
+export type OverflowPosition = "safe" | "unsafe";
+/**
+ * A [`<content-position>`](https://www.w3.org/TR/css-align-3/#typedef-content-position) value.
+ */
+export type ContentPosition =
+  | "center"
+  | "start"
+  | "end"
+  | "flex-start"
+  | "flex-end";
+/**
+ * A value for the [justify-content](https://www.w3.org/TR/css-align-3/#propdef-justify-content) property.
+ */
+export type JustifyContent =
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "content-distribution",
+      value: ContentDistribution,
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "content-position",
+
+      /**
+       * A content position keyword.
+       */
+      value: ContentPosition,
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "left",
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "right",
+    |};
+/**
+ * A value for the [align-self](https://www.w3.org/TR/css-align-3/#align-self-property) property.
+ */
+export type AlignSelf =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "stretch",
+    |}
+  | {|
+      type: "baseline-position",
+      value: BaselinePosition,
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "self-position",
+
+      /**
+       * A self position keyword.
+       */
+      value: SelfPosition,
+    |};
+/**
+ * A [`<self-position>`](https://www.w3.org/TR/css-align-3/#typedef-self-position) value.
+ */
+export type SelfPosition =
+  | "center"
+  | "start"
+  | "end"
+  | "self-start"
+  | "self-end"
+  | "flex-start"
+  | "flex-end";
+/**
+ * A value for the [justify-self](https://www.w3.org/TR/css-align-3/#justify-self-property) property.
+ */
+export type JustifySelf =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "stretch",
+    |}
+  | {|
+      type: "baseline-position",
+      value: BaselinePosition,
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "self-position",
+
+      /**
+       * A self position keyword.
+       */
+      value: SelfPosition,
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "left",
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "right",
+    |};
+/**
+ * A value for the [align-items](https://www.w3.org/TR/css-align-3/#align-items-property) property.
+ */
+export type AlignItems =
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "stretch",
+    |}
+  | {|
+      type: "baseline-position",
+      value: BaselinePosition,
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "self-position",
+
+      /**
+       * A self position keyword.
+       */
+      value: SelfPosition,
+    |};
+/**
+ * A value for the [justify-items](https://www.w3.org/TR/css-align-3/#justify-items-property) property.
+ */
+export type JustifyItems =
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "stretch",
+    |}
+  | {|
+      type: "baseline-position",
+      value: BaselinePosition,
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "self-position",
+
+      /**
+       * A self position keyword.
+       */
+      value: SelfPosition,
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "left",
+    |}
+  | {|
+      /**
+       * An overflow alignment mode.
+       */
+      overflow?: OverflowPosition | null,
+      type: "right",
+    |}
+  | {|
+      type: "legacy",
+      value: LegacyJustify,
+    |};
+/**
+ * A legacy justification keyword, as used in the `justify-items` property.
+ */
+export type LegacyJustify = "left" | "right" | "center";
+/**
+ * A [gap](https://www.w3.org/TR/css-align-3/#column-row-gap) value, as used in the `column-gap` and `row-gap` properties.
+ */
+export type GapValue =
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "length-percentage",
+      value: DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A value for the legacy (prefixed) [box-orient](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#orientation) property. Partially equivalent to `flex-direction` in the standard syntax.
+ */
+export type BoxOrient =
+  | "horizontal"
+  | "vertical"
+  | "inline-axis"
+  | "block-axis";
+/**
+ * A value for the legacy (prefixed) [box-direction](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#displayorder) property. Partially equivalent to the `flex-direction` property in the standard syntax.
+ */
+export type BoxDirection = "normal" | "reverse";
+/**
+ * A value for the legacy (prefixed) [box-align](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment) property. Equivalent to the `align-items` property in the standard syntax.
+ */
+export type BoxAlign = "start" | "end" | "center" | "baseline" | "stretch";
+/**
+ * A value for the legacy (prefixed) [box-pack](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#packing) property. Equivalent to the `justify-content` property in the standard syntax.
+ */
+export type BoxPack = "start" | "end" | "center" | "justify";
+/**
+ * A value for the legacy (prefixed) [box-lines](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#multiple) property. Equivalent to the `flex-wrap` property in the standard syntax.
+ */
+export type BoxLines = "single" | "multiple";
+/**
+ * A value for the legacy (prefixed) [flex-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack) property. Equivalent to the `justify-content` property in the standard syntax.
+ */
+export type FlexPack = "start" | "end" | "center" | "justify" | "distribute";
+/**
+ * A value for the legacy (prefixed) [flex-item-align](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align) property. Equivalent to the `align-self` property in the standard syntax.
+ */
+export type FlexItemAlign =
+  | "auto"
+  | "start"
+  | "end"
+  | "center"
+  | "baseline"
+  | "stretch";
+/**
+ * A value for the legacy (prefixed) [flex-line-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack) property. Equivalent to the `align-content` property in the standard syntax.
+ */
+export type FlexLinePack =
+  | "start"
+  | "end"
+  | "center"
+  | "justify"
+  | "distribute"
+  | "stretch";
+/**
+ * A [track sizing](https://drafts.csswg.org/css-grid-2/#track-sizing) value for the `grid-template-rows` and `grid-template-columns` properties.
+ */
+export type TrackSizing =
+  | {|
+      type: "none",
+    |}
+  | {|
+      /**
+       * A list of grid track items.
+       */
+      items: TrackListItem[],
+
+      /**
+       * A list of line names.
+       */
+      lineNames: String[][],
+      type: "track-list",
+    |};
+/**
+ * Either a track size or `repeat()` function.
+ *
+ * See [TrackList](TrackList).
+ */
+export type TrackListItem =
+  | {|
+      type: "track-size",
+      value: TrackSize,
+    |}
+  | {|
+      type: "track-repeat",
+      value: TrackRepeat,
+    |};
+/**
+ * A [`<track-size>`](https://drafts.csswg.org/css-grid-2/#typedef-track-size) value, as used in the `grid-template-rows` and `grid-template-columns` properties.
+ *
+ * See [TrackListItem](TrackListItem).
+ */
+export type TrackSize =
+  | {|
+      type: "track-breadth",
+      value: TrackBreadth,
+    |}
+  | {|
+      /**
+       * The maximum value.
+       */
+      max: TrackBreadth,
+
+      /**
+       * The minimum value.
+       */
+      min: TrackBreadth,
+      type: "min-max",
+    |}
+  | {|
+      type: "fit-content",
+      value: DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A [`<track-breadth>`](https://drafts.csswg.org/css-grid-2/#typedef-track-breadth) value.
+ *
+ * See [TrackSize](TrackSize).
+ */
+export type TrackBreadth =
+  | {|
+      type: "length",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "flex",
+      value: number,
+    |}
+  | {|
+      type: "min-content",
+    |}
+  | {|
+      type: "max-content",
+    |}
+  | {|
+      type: "auto",
+    |};
+/**
+ * A [`<repeat-count>`](https://drafts.csswg.org/css-grid-2/#typedef-track-repeat) value, used in the `repeat()` function.
+ *
+ * See [TrackRepeat](TrackRepeat).
+ */
+export type RepeatCount =
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "auto-fill",
+    |}
+  | {|
+      type: "auto-fit",
+    |};
+export type AutoFlowDirection = "row" | "column";
+/**
+ * A value for the [grid-template-areas](https://drafts.csswg.org/css-grid-2/#grid-template-areas-property) property. none | <string>+
+ */
+export type GridTemplateAreas =
+  | {|
+      type: "none",
+    |}
+  | {|
+      /**
+       * A flattened list of grid area names. Unnamed areas specified by the `.` token are represented as `None`.
+       */
+      areas: (string | null)[],
+
+      /**
+       * The number of columns in the grid.
+       */
+      columns: number,
+      type: "areas",
+    |};
+/**
+ * A [`<grid-line>`](https://drafts.csswg.org/css-grid-2/#typedef-grid-row-start-grid-line) value, used in the `grid-row-start`, `grid-row-end`, `grid-column-start`, and `grid-column-end` properties.
+ */
+export type GridLine =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      /**
+       * A grid area name.
+       */
+      name: String,
+      type: "area",
+    |}
+  | {|
+      /**
+       * A line number.
+       */
+      index: number,
+
+      /**
+       * A line name to filter by.
+       */
+      name?: String | null,
+      type: "line",
+    |}
+  | {|
+      /**
+       * A line number.
+       */
+      index: number,
+
+      /**
+       * A line name to filter by.
+       */
+      name?: String | null,
+      type: "span",
+    |};
+/**
+ * A value for the [font-weight](https://www.w3.org/TR/css-fonts-4/#font-weight-prop) property.
+ */
+export type FontWeight =
+  | {|
+      type: "absolute",
+      value: AbsoluteFontWeight,
+    |}
+  | {|
+      type: "bolder",
+    |}
+  | {|
+      type: "lighter",
+    |};
+/**
+ * An [absolute font weight](https://www.w3.org/TR/css-fonts-4/#font-weight-absolute-values), as used in the `font-weight` property.
+ *
+ * See [FontWeight](FontWeight).
+ */
+export type AbsoluteFontWeight =
+  | {|
+      type: "weight",
+      value: number,
+    |}
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "bold",
+    |};
+/**
+ * A value for the [font-size](https://www.w3.org/TR/css-fonts-4/#font-size-prop) property.
+ */
+export type FontSize =
+  | {|
+      type: "length",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "absolute",
+      value: AbsoluteFontSize,
+    |}
+  | {|
+      type: "relative",
+      value: RelativeFontSize,
+    |};
+/**
+ * An [absolute font size](https://www.w3.org/TR/css-fonts-3/#absolute-size-value), as used in the `font-size` property.
+ *
+ * See [FontSize](FontSize).
+ */
+export type AbsoluteFontSize =
+  | "xx-small"
+  | "x-small"
+  | "small"
+  | "medium"
+  | "large"
+  | "x-large"
+  | "xx-large"
+  | "xxx-large";
+/**
+ * A [relative font size](https://www.w3.org/TR/css-fonts-3/#relative-size-value), as used in the `font-size` property.
+ *
+ * See [FontSize](FontSize).
+ */
+export type RelativeFontSize = "smaller" | "larger";
+/**
+ * A value for the [font-stretch](https://www.w3.org/TR/css-fonts-4/#font-stretch-prop) property.
+ */
+export type FontStretch =
+  | {|
+      type: "keyword",
+      value: FontStretchKeyword,
+    |}
+  | {|
+      type: "percentage",
+      value: number,
+    |};
+/**
+ * A [font stretch keyword](https://www.w3.org/TR/css-fonts-4/#font-stretch-prop), as used in the `font-stretch` property.
+ *
+ * See [FontStretch](FontStretch).
+ */
+export type FontStretchKeyword =
+  | "normal"
+  | "ultra-condensed"
+  | "extra-condensed"
+  | "condensed"
+  | "semi-condensed"
+  | "semi-expanded"
+  | "expanded"
+  | "extra-expanded"
+  | "ultra-expanded";
+/**
+ * A value for the [font-family](https://www.w3.org/TR/css-fonts-4/#font-family-prop) property.
+ */
+export type FontFamily = GenericFontFamily | String;
+/**
+ * A [generic font family](https://www.w3.org/TR/css-fonts-4/#generic-font-families) name, as used in the `font-family` property.
+ *
+ * See [FontFamily](FontFamily).
+ */
+export type GenericFontFamily =
+  | "serif"
+  | "sans-serif"
+  | "cursive"
+  | "fantasy"
+  | "monospace"
+  | "system-ui"
+  | "emoji"
+  | "math"
+  | "fangsong"
+  | "ui-serif"
+  | "ui-sans-serif"
+  | "ui-monospace"
+  | "ui-rounded"
+  | "initial"
+  | "inherit"
+  | "unset"
+  | "default"
+  | "revert"
+  | "revert-layer";
+/**
+ * A value for the [font-style](https://www.w3.org/TR/css-fonts-4/#font-style-prop) property.
+ */
+export type FontStyle =
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "italic",
+    |}
+  | {|
+      type: "oblique",
+      value: Angle,
+    |};
+/**
+ * A value for the [font-variant-caps](https://www.w3.org/TR/css-fonts-4/#font-variant-caps-prop) property.
+ */
+export type FontVariantCaps =
+  | "normal"
+  | "small-caps"
+  | "all-small-caps"
+  | "petite-caps"
+  | "all-petite-caps"
+  | "unicase"
+  | "titling-caps";
+/**
+ * A value for the [line-height](https://www.w3.org/TR/2020/WD-css-inline-3-20200827/#propdef-line-height) property.
+ */
+export type LineHeight =
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "length",
+      value: DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A value for the [vertical align](https://drafts.csswg.org/css2/#propdef-vertical-align) property.
+ */
+export type VerticalAlign =
+  | {|
+      type: "keyword",
+      value: VerticalAlignKeyword,
+    |}
+  | {|
+      type: "length",
+      value: DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A keyword for the [vertical align](https://drafts.csswg.org/css2/#propdef-vertical-align) property.
+ */
+export type VerticalAlignKeyword =
+  | "baseline"
+  | "sub"
+  | "super"
+  | "top"
+  | "text-top"
+  | "middle"
+  | "bottom"
+  | "text-bottom";
+/**
+ * A CSS [easing function](https://www.w3.org/TR/css-easing-1/#easing-functions).
+ */
+export type EasingFunction =
+  | {|
+      type: "linear",
+    |}
+  | {|
+      type: "ease",
+    |}
+  | {|
+      type: "ease-in",
+    |}
+  | {|
+      type: "ease-out",
+    |}
+  | {|
+      type: "ease-in-out",
+    |}
+  | {|
+      type: "cubic-bezier",
+
+      /**
+       * The x-position of the first point in the curve.
+       */
+      x1: number,
+
+      /**
+       * The x-position of the second point in the curve.
+       */
+      x2: number,
+
+      /**
+       * The y-position of the first point in the curve.
+       */
+      y1: number,
+
+      /**
+       * The y-position of the second point in the curve.
+       */
+      y2: number,
+    |}
+  | {|
+      /**
+       * The number of intervals in the function.
+       */
+      count: number,
+
+      /**
+       * The step position.
+       */
+      position?: StepPosition,
+      type: "steps",
+    |};
+/**
+ * A [step position](https://www.w3.org/TR/css-easing-1/#step-position), used within the `steps()` function.
+ */
+export type StepPosition =
+  | {|
+      type: "start",
+    |}
+  | {|
+      type: "end",
+    |}
+  | {|
+      type: "jump-none",
+    |}
+  | {|
+      type: "jump-both",
+    |};
+/**
+ * A value for the [animation-iteration-count](https://drafts.csswg.org/css-animations/#animation-iteration-count) property.
+ */
+export type AnimationIterationCount =
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "infinite",
+    |};
+/**
+ * A value for the [animation-direction](https://drafts.csswg.org/css-animations/#animation-direction) property.
+ */
+export type AnimationDirection =
+  | "normal"
+  | "reverse"
+  | "alternate"
+  | "alternate-reverse";
+/**
+ * A value for the [animation-play-state](https://drafts.csswg.org/css-animations/#animation-play-state) property.
+ */
+export type AnimationPlayState = "running" | "paused";
+/**
+ * A value for the [animation-fill-mode](https://drafts.csswg.org/css-animations/#animation-fill-mode) property.
+ */
+export type AnimationFillMode = "none" | "forwards" | "backwards" | "both";
+/**
+ * A value for the [animation-composition](https://drafts.csswg.org/css-animations-2/#animation-composition) property.
+ */
+export type AnimationComposition = "replace" | "add" | "accumulate";
+/**
+ * A value for the [animation-timeline](https://drafts.csswg.org/css-animations-2/#animation-timeline) property.
+ */
+export type AnimationTimeline =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "dashed-ident",
+      value: String,
+    |}
+  | {|
+      type: "scroll",
+      value: ScrollTimeline,
+    |}
+  | {|
+      type: "view",
+      value: ViewTimeline,
+    |};
+/**
+ * A scroll axis, used in the `scroll()` function.
+ */
+export type ScrollAxis = "block" | "inline" | "x" | "y";
+/**
+ * A scroller, used in the `scroll()` function.
+ */
+export type Scroller = "root" | "nearest" | "self";
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_LengthPercentageOrAuto = [
+  LengthPercentageOrAuto,
+  LengthPercentageOrAuto
+];
+/**
+ * A value for the [animation-range-start](https://drafts.csswg.org/scroll-animations/#animation-range-start) property.
+ */
+export type AnimationRangeStart = AnimationAttachmentRange;
+/**
+ * A value for the [animation-range-start](https://drafts.csswg.org/scroll-animations/#animation-range-start) or [animation-range-end](https://drafts.csswg.org/scroll-animations/#animation-range-end) property.
+ */
+export type AnimationAttachmentRange =
+  | "normal"
+  | DimensionPercentageFor_LengthValue
+  | {|
+      /**
+       * The name of the timeline range.
+       */
+      name: TimelineRangeName,
+
+      /**
+       * The offset from the start of the named timeline range.
+       */
+      offset: DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A [view progress timeline range](https://drafts.csswg.org/scroll-animations/#view-timelines-ranges)
+ */
+export type TimelineRangeName =
+  | "cover"
+  | "contain"
+  | "entry"
+  | "exit"
+  | "entry-crossing"
+  | "exit-crossing";
+/**
+ * A value for the [animation-range-end](https://drafts.csswg.org/scroll-animations/#animation-range-end) property.
+ */
+export type AnimationRangeEnd = AnimationAttachmentRange;
+/**
+ * An individual [transform function](https://www.w3.org/TR/2019/CR-css-transforms-1-20190214/#two-d-transform-functions).
+ */
+export type Transform =
+  | {|
+      type: "translate",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [
+        DimensionPercentageFor_LengthValue,
+        DimensionPercentageFor_LengthValue
+      ],
+    |}
+  | {|
+      type: "translateX",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "translateY",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "translateZ",
+      value: Length,
+    |}
+  | {|
+      type: "translate3d",
+
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [
+        DimensionPercentageFor_LengthValue,
+        DimensionPercentageFor_LengthValue,
+        Length
+      ],
+    |}
+  | {|
+      type: "scale",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [NumberOrPercentage, NumberOrPercentage],
+    |}
+  | {|
+      type: "scaleX",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "scaleY",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "scaleZ",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "scale3d",
+
+      /**
+       * @minItems 3
+       * @maxItems 3
+       */
+      value: [NumberOrPercentage, NumberOrPercentage, NumberOrPercentage],
+    |}
+  | {|
+      type: "rotate",
+      value: Angle,
+    |}
+  | {|
+      type: "rotateX",
+      value: Angle,
+    |}
+  | {|
+      type: "rotateY",
+      value: Angle,
+    |}
+  | {|
+      type: "rotateZ",
+      value: Angle,
+    |}
+  | {|
+      type: "rotate3d",
+
+      /**
+       * @minItems 4
+       * @maxItems 4
+       */
+      value: [number, number, number, Angle],
+    |}
+  | {|
+      type: "skew",
+
+      /**
+       * @minItems 2
+       * @maxItems 2
+       */
+      value: [Angle, Angle],
+    |}
+  | {|
+      type: "skewX",
+      value: Angle,
+    |}
+  | {|
+      type: "skewY",
+      value: Angle,
+    |}
+  | {|
+      type: "perspective",
+      value: Length,
+    |}
+  | {|
+      type: "matrix",
+      value: MatrixForFloat,
+    |}
+  | {|
+      type: "matrix3d",
+      value: Matrix3DForFloat,
+    |};
+/**
+ * A value for the [transform-style](https://drafts.csswg.org/css-transforms-2/#transform-style-property) property.
+ */
+export type TransformStyle = "flat" | "preserve3d";
+/**
+ * A value for the [transform-box](https://drafts.csswg.org/css-transforms-1/#transform-box) property.
+ */
+export type TransformBox =
+  | "content-box"
+  | "border-box"
+  | "fill-box"
+  | "stroke-box"
+  | "view-box";
+/**
+ * A value for the [backface-visibility](https://drafts.csswg.org/css-transforms-2/#backface-visibility-property) property.
+ */
+export type BackfaceVisibility = "visible" | "hidden";
+/**
+ * A value for the [perspective](https://drafts.csswg.org/css-transforms-2/#perspective-property) property.
+ */
+export type Perspective =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "length",
+      value: Length,
+    |};
+/**
+ * A value for the [translate](https://drafts.csswg.org/css-transforms-2/#propdef-translate) property.
+ */
+export type Translate =
+  | "none"
+  | {|
+      /**
+       * The x translation.
+       */
+      x: DimensionPercentageFor_LengthValue,
+
+      /**
+       * The y translation.
+       */
+      y: DimensionPercentageFor_LengthValue,
+
+      /**
+       * The z translation.
+       */
+      z: Length,
+    |};
+/**
+ * A value for the [scale](https://drafts.csswg.org/css-transforms-2/#propdef-scale) property.
+ */
+export type Scale =
+  | "none"
+  | {|
+      /**
+       * Scale on the x axis.
+       */
+      x: NumberOrPercentage,
+
+      /**
+       * Scale on the y axis.
+       */
+      y: NumberOrPercentage,
+
+      /**
+       * Scale on the z axis.
+       */
+      z: NumberOrPercentage,
+    |};
+/**
+ * Defines how text case should be transformed in the [text-transform](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-transform-property) property.
+ */
+export type TextTransformCase =
+  | "none"
+  | "uppercase"
+  | "lowercase"
+  | "capitalize";
+/**
+ * A value for the [white-space](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#white-space-property) property.
+ */
+export type WhiteSpace =
+  | "normal"
+  | "pre"
+  | "nowrap"
+  | "pre-wrap"
+  | "break-spaces"
+  | "pre-line";
+/**
+ * A value for the [word-break](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#word-break-property) property.
+ */
+export type WordBreak = "normal" | "keep-all" | "break-all" | "break-word";
+/**
+ * A value for the [line-break](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#line-break-property) property.
+ */
+export type LineBreak = "auto" | "loose" | "normal" | "strict" | "anywhere";
+/**
+ * A value for the [hyphens](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#hyphenation) property.
+ */
+export type Hyphens = "none" | "manual" | "auto";
+/**
+ * A value for the [overflow-wrap](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#overflow-wrap-property) property.
+ */
+export type OverflowWrap = "normal" | "anywhere" | "break-word";
+/**
+ * A value for the [text-align](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-align-property) property.
+ */
+export type TextAlign =
+  | "start"
+  | "end"
+  | "left"
+  | "right"
+  | "center"
+  | "justify"
+  | "match-parent"
+  | "justify-all";
+/**
+ * A value for the [text-align-last](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-align-last-property) property.
+ */
+export type TextAlignLast =
+  | "auto"
+  | "start"
+  | "end"
+  | "left"
+  | "right"
+  | "center"
+  | "justify"
+  | "match-parent";
+/**
+ * A value for the [text-justify](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-justify-property) property.
+ */
+export type TextJustify = "auto" | "none" | "inter-word" | "inter-character";
+/**
+ * A value for the [word-spacing](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#word-spacing-property) and [letter-spacing](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#letter-spacing-property) properties.
+ */
+export type Spacing =
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "length",
+      value: Length,
+    |};
+export type TextDecorationLine =
+  | ExclusiveTextDecorationLine
+  | OtherTextDecorationLine[];
+export type ExclusiveTextDecorationLine =
+  | "none"
+  | "spelling-error"
+  | "grammar-error";
+export type OtherTextDecorationLine =
+  | "underline"
+  | "overline"
+  | "line-through"
+  | "blink";
+/**
+ * A value for the [text-decoration-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-style-property) property.
+ */
+export type TextDecorationStyle =
+  | "solid"
+  | "double"
+  | "dotted"
+  | "dashed"
+  | "wavy";
+/**
+ * A value for the [text-decoration-thickness](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-width-property) property.
+ */
+export type TextDecorationThickness =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "from-font",
+    |}
+  | {|
+      type: "length-percentage",
+      value: DimensionPercentageFor_LengthValue,
+    |};
+/**
+ * A value for the [text-decoration-skip-ink](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-skip-ink-property) property.
+ */
+export type TextDecorationSkipInk = "auto" | "none" | "all";
+/**
+ * A value for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property.
+ */
+export type TextEmphasisStyle =
+  | {|
+      type: "none",
+    |}
+  | {|
+      /**
+       * The fill mode for the marks.
+       */
+      fill: TextEmphasisFillMode,
+
+      /**
+       * The shape of the marks.
+       */
+      shape?: TextEmphasisShape | null,
+      type: "keyword",
+    |}
+  | {|
+      type: "string",
+      value: String,
+    |};
+/**
+ * A keyword for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property.
+ *
+ * See [TextEmphasisStyle](TextEmphasisStyle).
+ */
+export type TextEmphasisFillMode = "filled" | "open";
+/**
+ * A text emphasis shape for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property.
+ *
+ * See [TextEmphasisStyle](TextEmphasisStyle).
+ */
+export type TextEmphasisShape =
+  | "dot"
+  | "circle"
+  | "double-circle"
+  | "triangle"
+  | "sesame";
+/**
+ * A horizontal position keyword for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property.
+ *
+ * See [TextEmphasisPosition](TextEmphasisPosition).
+ */
+export type TextEmphasisPositionHorizontal = "left" | "right";
+/**
+ * A vertical position keyword for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property.
+ *
+ * See [TextEmphasisPosition](TextEmphasisPosition).
+ */
+export type TextEmphasisPositionVertical = "over" | "under";
+/**
+ * A value for the [text-size-adjust](https://w3c.github.io/csswg-drafts/css-size-adjust/#adjustment-control) property.
+ */
+export type TextSizeAdjust =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "percentage",
+      value: number,
+    |};
+/**
+ * A value for the [direction](https://drafts.csswg.org/css-writing-modes-3/#direction) property.
+ */
+export type Direction2 = "ltr" | "rtl";
+/**
+ * A value for the [unicode-bidi](https://drafts.csswg.org/css-writing-modes-3/#unicode-bidi) property.
+ */
+export type UnicodeBidi =
+  | "normal"
+  | "embed"
+  | "isolate"
+  | "bidi-override"
+  | "isolate-override"
+  | "plaintext";
+/**
+ * A value for the [box-decoration-break](https://www.w3.org/TR/css-break-3/#break-decoration) property.
+ */
+export type BoxDecorationBreak = "slice" | "clone";
+/**
+ * A value for the [resize](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#resize) property.
+ */
+export type Resize =
+  | "none"
+  | "both"
+  | "horizontal"
+  | "vertical"
+  | "block"
+  | "inline";
+/**
+ * A pre-defined [cursor](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) value, used in the `cursor` property.
+ *
+ * See [Cursor](Cursor).
+ */
+export type CursorKeyword =
+  | "auto"
+  | "default"
+  | "none"
+  | "context-menu"
+  | "help"
+  | "pointer"
+  | "progress"
+  | "wait"
+  | "cell"
+  | "crosshair"
+  | "text"
+  | "vertical-text"
+  | "alias"
+  | "copy"
+  | "move"
+  | "no-drop"
+  | "not-allowed"
+  | "grab"
+  | "grabbing"
+  | "e-resize"
+  | "n-resize"
+  | "ne-resize"
+  | "nw-resize"
+  | "s-resize"
+  | "se-resize"
+  | "sw-resize"
+  | "w-resize"
+  | "ew-resize"
+  | "ns-resize"
+  | "nesw-resize"
+  | "nwse-resize"
+  | "col-resize"
+  | "row-resize"
+  | "all-scroll"
+  | "zoom-in"
+  | "zoom-out";
+/**
+ * A value for the [caret-color](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret-color) property.
+ */
+export type ColorOrAuto =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "color",
+      value: CssColor,
+    |};
+/**
+ * A value for the [caret-shape](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret-shape) property.
+ */
+export type CaretShape = "auto" | "bar" | "block" | "underscore";
+/**
+ * A value for the [user-select](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#content-selection) property.
+ */
+export type UserSelect = "auto" | "text" | "none" | "contain" | "all";
+export type Appearance = string;
+/**
+ * A value for the [list-style-type](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#text-markers) property.
+ */
+export type ListStyleType =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "string",
+      value: String,
+    |}
+  | {|
+      type: "counter-style",
+      value: CounterStyle,
+    |};
+/**
+ * A [counter-style](https://www.w3.org/TR/css-counter-styles-3/#typedef-counter-style) name.
+ */
+export type CounterStyle =
+  | {|
+      type: "predefined",
+      value: PredefinedCounterStyle,
+    |}
+  | {|
+      type: "name",
+      value: String,
+    |}
+  | {|
+      /**
+       * The symbols.
+       */
+      symbols: Symbol[],
+
+      /**
+       * The counter system.
+       */
+      system?: {| ...SymbolsType, ...string |},
+      type: "symbols",
+    |};
+/**
+ * A [predefined counter](https://www.w3.org/TR/css-counter-styles-3/#predefined-counters) style.
+ */
+export type PredefinedCounterStyle =
+  | "decimal"
+  | "decimal-leading-zero"
+  | "arabic-indic"
+  | "armenian"
+  | "upper-armenian"
+  | "lower-armenian"
+  | "bengali"
+  | "cambodian"
+  | "khmer"
+  | "cjk-decimal"
+  | "devanagari"
+  | "georgian"
+  | "gujarati"
+  | "gurmukhi"
+  | "hebrew"
+  | "kannada"
+  | "lao"
+  | "malayalam"
+  | "mongolian"
+  | "myanmar"
+  | "oriya"
+  | "persian"
+  | "lower-roman"
+  | "upper-roman"
+  | "tamil"
+  | "telugu"
+  | "thai"
+  | "tibetan"
+  | "lower-alpha"
+  | "lower-latin"
+  | "upper-alpha"
+  | "upper-latin"
+  | "lower-greek"
+  | "hiragana"
+  | "hiragana-iroha"
+  | "katakana"
+  | "katakana-iroha"
+  | "disc"
+  | "circle"
+  | "square"
+  | "disclosure-open"
+  | "disclosure-closed"
+  | "cjk-earthly-branch"
+  | "cjk-heavenly-stem"
+  | "japanese-informal"
+  | "japanese-formal"
+  | "korean-hangul-formal"
+  | "korean-hanja-informal"
+  | "korean-hanja-formal"
+  | "simp-chinese-informal"
+  | "simp-chinese-formal"
+  | "trad-chinese-informal"
+  | "trad-chinese-formal"
+  | "ethiopic-numeric";
+/**
+ * A single [symbol](https://www.w3.org/TR/css-counter-styles-3/#funcdef-symbols) as used in the `symbols()` function.
+ *
+ * See [CounterStyle](CounterStyle).
+ */
+export type Symbol =
+  | {|
+      type: "string",
+      value: String,
+    |}
+  | {|
+      type: "image",
+      value: Image,
+    |};
+/**
+ * A [`<symbols-type>`](https://www.w3.org/TR/css-counter-styles-3/#typedef-symbols-type) value, as used in the `symbols()` function.
+ *
+ * See [CounterStyle](CounterStyle).
+ */
+export type SymbolsType =
+  | "cyclic"
+  | "numeric"
+  | "alphabetic"
+  | "symbolic"
+  | "fixed";
+/**
+ * A value for the [list-style-position](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#list-style-position-property) property.
+ */
+export type ListStylePosition = "inside" | "outside";
+/**
+ * A value for the [marker-side](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#marker-side) property.
+ */
+export type MarkerSide = "match-self" | "match-parent";
+/**
+ * An SVG [`<paint>`](https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint) value used in the `fill` and `stroke` properties.
+ */
+export type SVGPaint =
+  | {|
+      /**
+       * A fallback to be used used in case the paint server cannot be resolved.
+       */
+      fallback?: SVGPaintFallback | null,
+      type: "url",
+
+      /**
+       * The url of the paint server.
+       */
+      url: Url,
+    |}
+  | {|
+      type: "color",
+      value: CssColor,
+    |}
+  | {|
+      type: "context-fill",
+    |}
+  | {|
+      type: "context-stroke",
+    |}
+  | {|
+      type: "none",
+    |};
+/**
+ * A fallback for an SVG paint in case a paint server `url()` cannot be resolved.
+ *
+ * See [SVGPaint](SVGPaint).
+ */
+export type SVGPaintFallback =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "color",
+      value: CssColor,
+    |};
+/**
+ * A [`<fill-rule>`](https://www.w3.org/TR/css-shapes-1/#typedef-fill-rule) used to determine the interior of a `polygon()` shape.
+ *
+ * See [Polygon](Polygon).
+ */
+export type FillRule = "nonzero" | "evenodd";
+/**
+ * A value for the [stroke-linecap](https://www.w3.org/TR/SVG2/painting.html#LineCaps) property.
+ */
+export type StrokeLinecap = "butt" | "round" | "square";
+/**
+ * A value for the [stroke-linejoin](https://www.w3.org/TR/SVG2/painting.html#LineJoin) property.
+ */
+export type StrokeLinejoin =
+  | "miter"
+  | "miter-clip"
+  | "round"
+  | "bevel"
+  | "arcs";
+/**
+ * A value for the [stroke-dasharray](https://www.w3.org/TR/SVG2/painting.html#StrokeDashing) property.
+ */
+export type StrokeDasharray =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "values",
+      value: DimensionPercentageFor_LengthValue[],
+    |};
+/**
+ * A value for the [marker](https://www.w3.org/TR/SVG2/painting.html#VertexMarkerProperties) properties.
+ */
+export type Marker =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "url",
+      value: Url,
+    |};
+/**
+ * A value for the [color-interpolation](https://www.w3.org/TR/SVG2/painting.html#ColorInterpolation) property.
+ */
+export type ColorInterpolation = "auto" | "srgb" | "linearrgb";
+/**
+ * A value for the [color-rendering](https://www.w3.org/TR/SVG2/painting.html#ColorRendering) property.
+ */
+export type ColorRendering = "auto" | "optimizespeed" | "optimizequality";
+/**
+ * A value for the [shape-rendering](https://www.w3.org/TR/SVG2/painting.html#ShapeRendering) property.
+ */
+export type ShapeRendering =
+  | "auto"
+  | "optimizespeed"
+  | "crispedges"
+  | "geometricprecision";
+/**
+ * A value for the [text-rendering](https://www.w3.org/TR/SVG2/painting.html#TextRendering) property.
+ */
+export type TextRendering =
+  | "auto"
+  | "optimizespeed"
+  | "optimizelegibility"
+  | "geometricprecision";
+/**
+ * A value for the [image-rendering](https://www.w3.org/TR/SVG2/painting.html#ImageRendering) property.
+ */
+export type ImageRendering = "auto" | "optimizespeed" | "optimizequality";
+/**
+ * A value for the [clip-path](https://www.w3.org/TR/css-masking-1/#the-clip-path) property.
+ */
+export type ClipPath =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "url",
+      value: Url,
+    |}
+  | {|
+      /**
+       * A reference box that the shape is positioned according to.
+       */
+      referenceBox: GeometryBox,
+
+      /**
+       * A basic shape.
+       */
+      shape: BasicShape,
+      type: "shape",
+    |}
+  | {|
+      type: "box",
+      value: GeometryBox,
+    |};
+/**
+ * A [`<geometry-box>`](https://www.w3.org/TR/css-masking-1/#typedef-geometry-box) value as used in the `mask-clip` and `clip-path` properties.
+ */
+export type GeometryBox =
+  | "border-box"
+  | "padding-box"
+  | "content-box"
+  | "margin-box"
+  | "fill-box"
+  | "stroke-box"
+  | "view-box";
+/**
+ * A CSS [`<basic-shape>`](https://www.w3.org/TR/css-shapes-1/#basic-shape-functions) value.
+ */
+export type BasicShape =
+  | {|
+      type: "inset",
+      value: InsetRect,
+    |}
+  | {|
+      type: "circle",
+      value: Circle2,
+    |}
+  | {|
+      type: "ellipse",
+      value: Ellipse2,
+    |}
+  | {|
+      type: "polygon",
+      value: Polygon,
+    |};
+/**
+ * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc.
+ *
+ * When serialized, as few components as possible are written when there are duplicate values.
+ * @minItems 4
+ * @maxItems 4
+ */
+export type RectFor_DimensionPercentageFor_LengthValue = [
+  DimensionPercentageFor_LengthValue,
+  DimensionPercentageFor_LengthValue,
+  DimensionPercentageFor_LengthValue,
+  DimensionPercentageFor_LengthValue
+];
+/**
+ * A [`<shape-radius>`](https://www.w3.org/TR/css-shapes-1/#typedef-shape-radius) value that defines the radius of a `circle()` or `ellipse()` shape.
+ */
+export type ShapeRadius =
+  | {|
+      type: "length-percentage",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "closest-side",
+    |}
+  | {|
+      type: "farthest-side",
+    |};
+/**
+ * A value for the [mask-mode](https://www.w3.org/TR/css-masking-1/#the-mask-mode) property.
+ */
+export type MaskMode = "luminance" | "alpha" | "match-source";
+/**
+ * A value for the [mask-clip](https://www.w3.org/TR/css-masking-1/#the-mask-clip) property.
+ */
+export type MaskClip =
+  | {|
+      type: "geometry-box",
+      value: GeometryBox,
+    |}
+  | {|
+      type: "no-clip",
+    |};
+/**
+ * A value for the [mask-composite](https://www.w3.org/TR/css-masking-1/#the-mask-composite) property.
+ */
+export type MaskComposite = "add" | "subtract" | "intersect" | "exclude";
+/**
+ * A value for the [mask-type](https://www.w3.org/TR/css-masking-1/#the-mask-type) property.
+ */
+export type MaskType = "luminance" | "alpha";
+/**
+ * A value for the [mask-border-mode](https://www.w3.org/TR/css-masking-1/#the-mask-border-mode) property.
+ */
+export type MaskBorderMode = "luminance" | "alpha";
+/**
+ * A value for the [-webkit-mask-composite](https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-composite) property.
+ *
+ * See also [MaskComposite](MaskComposite).
+ */
+export type WebKitMaskComposite =
+  | (
+      | "clear"
+      | "copy"
+      | "source-atop"
+      | "destination-over"
+      | "destination-in"
+      | "destination-out"
+      | "destination-atop"
+    )
+  | "source-over"
+  | "source-in"
+  | "source-out"
+  | "xor";
+/**
+ * A value for the [-webkit-mask-source-type](https://github.com/WebKit/WebKit/blob/6eece09a1c31e47489811edd003d1e36910e9fd3/Source/WebCore/css/CSSProperties.json#L6578-L6587) property.
+ *
+ * See also [MaskMode](MaskMode).
+ */
+export type WebKitMaskSourceType = "auto" | "luminance" | "alpha";
+/**
+ * A value for the [filter](https://drafts.fxtf.org/filter-effects-1/#FilterProperty) and [backdrop-filter](https://drafts.fxtf.org/filter-effects-2/#BackdropFilterProperty) properties.
+ */
+export type FilterList =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "filters",
+      value: Filter[],
+    |};
+/**
+ * A [filter](https://drafts.fxtf.org/filter-effects-1/#filter-functions) function.
+ */
+export type Filter =
+  | {|
+      type: "blur",
+      value: Length,
+    |}
+  | {|
+      type: "brightness",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "contrast",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "grayscale",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "hue-rotate",
+      value: Angle,
+    |}
+  | {|
+      type: "invert",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "opacity",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "saturate",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "sepia",
+      value: NumberOrPercentage,
+    |}
+  | {|
+      type: "drop-shadow",
+      value: DropShadow,
+    |}
+  | {|
+      type: "url",
+      value: Url,
+    |};
+/**
+ * A value for the [z-index](https://drafts.csswg.org/css2/#z-index) property.
+ */
+export type ZIndex =
+  | {|
+      type: "auto",
+    |}
+  | {|
+      type: "integer",
+      value: number,
+    |};
+/**
+ * A value for the [container-type](https://drafts.csswg.org/css-contain-3/#container-type) property. Establishes the element as a query container for the purpose of container queries.
+ */
+export type ContainerType = "normal" | "inline-size" | "size" | "scroll-state";
+/**
+ * A value for the [container-name](https://drafts.csswg.org/css-contain-3/#container-name) property.
+ */
+export type ContainerNameList =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "names",
+      value: String[],
+    |};
+/**
+ * A value for the [view-transition-name](https://drafts.csswg.org/css-view-transitions-1/#view-transition-name-prop) property.
+ */
+export type ViewTransitionName = "none" | "auto" | String;
+/**
+ * The `none` keyword, or a space-separated list of custom idents.
+ */
+export type NoneOrCustomIdentList = "none" | String[];
+/**
+ * A value for the [view-transition-group](https://drafts.csswg.org/css-view-transitions-2/#view-transition-group-prop) property.
+ */
+export type ViewTransitionGroup = "normal" | "contain" | "nearest" | String;
+/**
+ * A value for the [print-color-adjust](https://drafts.csswg.org/css-color-adjust/#propdef-print-color-adjust) property.
+ */
+export type PrintColorAdjust = "economy" | "exact";
+/**
+ * A [CSS-wide keyword](https://drafts.csswg.org/css-cascade-5/#defaulting-keywords).
+ */
+export type CSSWideKeyword =
+  | "initial"
+  | "inherit"
+  | "unset"
+  | "revert"
+  | "revert-layer";
+/**
+ * A CSS custom property name.
+ */
+export type CustomPropertyName = String | String;
+export type SelectorComponent =
+  | {|
+      type: "combinator",
+      value: Combinator,
+    |}
+  | {|
+      type: "universal",
+    |}
+  | (
+      | {|
+          type: "namespace",
+          kind: "none",
+        |}
+      | {|
+          type: "namespace",
+          kind: "any",
+        |}
+      | {|
+          type: "namespace",
+          kind: "named",
+          prefix: string,
+        |}
+    )
+  | {|
+      name: string,
+      type: "type",
+    |}
+  | {|
+      name: string,
+      type: "id",
+    |}
+  | {|
+      name: string,
+      type: "class",
+    |}
+  | {|
+      name: string,
+      namespace?: NamespaceConstraint | null,
+      operation?: AttrOperation | null,
+      type: "attribute",
+    |}
+  | {|
+      ...{|
+        type: "pseudo-class",
+      |},
+      ...TSPseudoClass | PseudoClass,
+    |}
+  | {|
+      ...{|
+        type: "pseudo-element",
+      |},
+      ...BuiltinPseudoElement | PseudoElement,
+    |}
+  | {|
+      type: "nesting",
+    |};
+export type Combinator =
+  | ("child" | "descendant" | "next-sibling" | "later-sibling")
+  | "pseudo-element"
+  | "slot-assignment"
+  | "part"
+  | "deep-descendant"
+  | "deep";
+export type NamespaceConstraint =
+  | {|
+      type: "any",
+    |}
+  | {|
+      prefix: string,
+      type: "specific",
+      url: string,
+    |};
+export type ParsedCaseSensitivity =
+  | "explicit-case-sensitive"
+  | "ascii-case-insensitive"
+  | "case-sensitive"
+  | "ascii-case-insensitive-if-in-html-element-in-html-document";
+export type AttrSelectorOperator =
+  | "equal"
+  | "includes"
+  | "dash-match"
+  | "prefix"
+  | "substring"
+  | "suffix";
+export type TSPseudoClass =
+  | {|
+      kind: "not",
+      selectors: Selector[],
+    |}
+  | {|
+      kind: "first-child",
+    |}
+  | {|
+      kind: "last-child",
+    |}
+  | {|
+      kind: "only-child",
+    |}
+  | {|
+      kind: "root",
+    |}
+  | {|
+      kind: "empty",
+    |}
+  | {|
+      kind: "scope",
+    |}
+  | {|
+      a: number,
+      b: number,
+      kind: "nth-child",
+      of?: Selector[] | null,
+    |}
+  | {|
+      a: number,
+      b: number,
+      kind: "nth-last-child",
+      of?: Selector[] | null,
+    |}
+  | {|
+      a: number,
+      b: number,
+      kind: "nth-col",
+    |}
+  | {|
+      a: number,
+      b: number,
+      kind: "nth-last-col",
+    |}
+  | {|
+      a: number,
+      b: number,
+      kind: "nth-of-type",
+    |}
+  | {|
+      a: number,
+      b: number,
+      kind: "nth-last-of-type",
+    |}
+  | {|
+      kind: "first-of-type",
+    |}
+  | {|
+      kind: "last-of-type",
+    |}
+  | {|
+      kind: "only-of-type",
+    |}
+  | {|
+      kind: "host",
+      selectors?: Selector | null,
+    |}
+  | {|
+      kind: "where",
+      selectors: Selector[],
+    |}
+  | {|
+      kind: "is",
+      selectors: Selector[],
+    |}
+  | {|
+      kind: "any",
+      selectors: Selector[],
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "has",
+      selectors: Selector[],
+    |};
+/**
+ * A pseudo class.
+ */
+export type PseudoClass =
+  | {|
+      kind: "lang",
+
+      /**
+       * A list of language codes.
+       */
+      languages: String[],
+    |}
+  | {|
+      /**
+       * A direction.
+       */
+      direction: Direction,
+      kind: "dir",
+    |}
+  | {|
+      kind: "hover",
+    |}
+  | {|
+      kind: "active",
+    |}
+  | {|
+      kind: "focus",
+    |}
+  | {|
+      kind: "focus-visible",
+    |}
+  | {|
+      kind: "focus-within",
+    |}
+  | {|
+      kind: "current",
+    |}
+  | {|
+      kind: "past",
+    |}
+  | {|
+      kind: "future",
+    |}
+  | {|
+      kind: "playing",
+    |}
+  | {|
+      kind: "paused",
+    |}
+  | {|
+      kind: "seeking",
+    |}
+  | {|
+      kind: "buffering",
+    |}
+  | {|
+      kind: "stalled",
+    |}
+  | {|
+      kind: "muted",
+    |}
+  | {|
+      kind: "volume-locked",
+    |}
+  | {|
+      kind: "fullscreen",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "open",
+    |}
+  | {|
+      kind: "closed",
+    |}
+  | {|
+      kind: "modal",
+    |}
+  | {|
+      kind: "picture-in-picture",
+    |}
+  | {|
+      kind: "popover-open",
+    |}
+  | {|
+      kind: "defined",
+    |}
+  | {|
+      kind: "any-link",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "link",
+    |}
+  | {|
+      kind: "local-link",
+    |}
+  | {|
+      kind: "target",
+    |}
+  | {|
+      kind: "target-within",
+    |}
+  | {|
+      kind: "visited",
+    |}
+  | {|
+      kind: "enabled",
+    |}
+  | {|
+      kind: "disabled",
+    |}
+  | {|
+      kind: "read-only",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "read-write",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "placeholder-shown",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "default",
+    |}
+  | {|
+      kind: "checked",
+    |}
+  | {|
+      kind: "indeterminate",
+    |}
+  | {|
+      kind: "blank",
+    |}
+  | {|
+      kind: "valid",
+    |}
+  | {|
+      kind: "invalid",
+    |}
+  | {|
+      kind: "in-range",
+    |}
+  | {|
+      kind: "out-of-range",
+    |}
+  | {|
+      kind: "required",
+    |}
+  | {|
+      kind: "optional",
+    |}
+  | {|
+      kind: "user-valid",
+    |}
+  | {|
+      kind: "user-invalid",
+    |}
+  | {|
+      kind: "autofill",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "active-view-transition",
+    |}
+  | {|
+      kind: "active-view-transition-type",
+
+      /**
+       * A view transition type.
+       */
+      type: String[],
+    |}
+  | {|
+      kind: "state",
+
+      /**
+       * The custom state identifier.
+       */
+      state: String,
+    |}
+  | {|
+      kind: "local",
+
+      /**
+       * A local selector.
+       */
+      selector: Selector,
+    |}
+  | {|
+      kind: "global",
+
+      /**
+       * A global selector.
+       */
+      selector: Selector,
+    |}
+  | {|
+      kind: "webkit-scrollbar",
+      value: WebKitScrollbarPseudoClass,
+    |}
+  | {|
+      kind: "custom",
+
+      /**
+       * The pseudo class name.
+       */
+      name: String,
+    |}
+  | {|
+      /**
+       * The arguments of the pseudo class function.
+       */
+      arguments: TokenOrValue[],
+      kind: "custom-function",
+
+      /**
+       * The pseudo class name.
+       */
+      name: String,
+    |};
+/**
+ * The [:dir()](https://drafts.csswg.org/selectors-4/#the-dir-pseudo) pseudo class.
+ */
+export type Direction = "ltr" | "rtl";
+/**
+ * A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo class.
+ */
+export type WebKitScrollbarPseudoClass =
+  | "horizontal"
+  | "vertical"
+  | "decrement"
+  | "increment"
+  | "start"
+  | "end"
+  | "double-button"
+  | "single-button"
+  | "no-button"
+  | "corner-present"
+  | "window-inactive";
+export type BuiltinPseudoElement =
+  | {|
+      kind: "slotted",
+      selector: Selector,
+    |}
+  | {|
+      kind: "part",
+      names: string[],
+    |};
+/**
+ * A pseudo element.
+ */
+export type PseudoElement =
+  | {|
+      kind: "after",
+    |}
+  | {|
+      kind: "before",
+    |}
+  | {|
+      kind: "first-line",
+    |}
+  | {|
+      kind: "first-letter",
+    |}
+  | {|
+      kind: "details-content",
+    |}
+  | {|
+      kind: "target-text",
+    |}
+  | {|
+      kind: "selection",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "placeholder",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "marker",
+    |}
+  | {|
+      kind: "backdrop",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "file-selector-button",
+      vendorPrefix: VendorPrefix,
+    |}
+  | {|
+      kind: "webkit-scrollbar",
+      value: WebKitScrollbarPseudoElement,
+    |}
+  | {|
+      kind: "cue",
+    |}
+  | {|
+      kind: "cue-region",
+    |}
+  | {|
+      kind: "cue-function",
+
+      /**
+       * The selector argument.
+       */
+      selector: Selector,
+    |}
+  | {|
+      kind: "cue-region-function",
+
+      /**
+       * The selector argument.
+       */
+      selector: Selector,
+    |}
+  | {|
+      kind: "view-transition",
+    |}
+  | {|
+      kind: "view-transition-group",
+
+      /**
+       * A part name selector.
+       */
+      part: ViewTransitionPartSelector,
+    |}
+  | {|
+      kind: "view-transition-image-pair",
+
+      /**
+       * A part name selector.
+       */
+      part: ViewTransitionPartSelector,
+    |}
+  | {|
+      kind: "view-transition-old",
+
+      /**
+       * A part name selector.
+       */
+      part: ViewTransitionPartSelector,
+    |}
+  | {|
+      kind: "view-transition-new",
+
+      /**
+       * A part name selector.
+       */
+      part: ViewTransitionPartSelector,
+    |}
+  | {|
+      /**
+       * A form control identifier.
+       */
+      identifier: String,
+      kind: "picker-function",
+    |}
+  | {|
+      kind: "picker-icon",
+    |}
+  | {|
+      kind: "checkmark",
+    |}
+  | {|
+      kind: "grammar-error",
+    |}
+  | {|
+      kind: "spelling-error",
+    |}
+  | {|
+      kind: "custom",
+
+      /**
+       * The name of the pseudo element.
+       */
+      name: String,
+    |}
+  | {|
+      /**
+       * The arguments of the pseudo element function.
+       */
+      arguments: TokenOrValue[],
+      kind: "custom-function",
+
+      /**
+       * The name of the pseudo element.
+       */
+      name: String,
+    |};
+/**
+ * A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo element.
+ */
+export type WebKitScrollbarPseudoElement =
+  | "scrollbar"
+  | "button"
+  | "track"
+  | "track-piece"
+  | "thumb"
+  | "corner"
+  | "resizer";
+export type ViewTransitionPartName = string;
+export type Selector = SelectorComponent[];
+export type SelectorList = Selector[];
+/**
+ * A [keyframe selector](https://drafts.csswg.org/css-animations/#typedef-keyframe-selector) within an `@keyframes` rule.
+ */
+export type KeyframeSelector =
+  | {|
+      type: "percentage",
+      value: number,
+    |}
+  | {|
+      type: "from",
+    |}
+  | {|
+      type: "to",
+    |}
+  | {|
+      type: "timeline-range-percentage",
+      value: TimelineRangePercentage,
+    |};
+/**
+ * KeyframesName
+ */
+export type KeyframesName =
+  | {|
+      type: "ident",
+      value: String,
+    |}
+  | {|
+      type: "custom",
+      value: String,
+    |};
+/**
+ * A property within an `@font-face` rule.
+ *
+ * See [FontFaceRule](FontFaceRule).
+ */
+export type FontFaceProperty =
+  | {|
+      type: "source",
+      value: Source[],
+    |}
+  | {|
+      type: "font-family",
+      value: FontFamily,
+    |}
+  | {|
+      type: "font-style",
+      value: FontStyle2,
+    |}
+  | {|
+      type: "font-weight",
+      value: Size2DFor_FontWeight,
+    |}
+  | {|
+      type: "font-stretch",
+      value: Size2DFor_FontStretch,
+    |}
+  | {|
+      type: "unicode-range",
+      value: UnicodeRange[],
+    |}
+  | {|
+      type: "custom",
+      value: CustomProperty,
+    |};
+/**
+ * A value for the [src](https://drafts.csswg.org/css-fonts/#src-desc) property in an `@font-face` rule.
+ */
+export type Source =
+  | {|
+      type: "url",
+      value: UrlSource,
+    |}
+  | {|
+      type: "local",
+      value: FontFamily,
+    |};
+/**
+ * A font format keyword in the `format()` function of the the [src](https://drafts.csswg.org/css-fonts/#src-desc) property of an `@font-face` rule.
+ */
+export type FontFormat =
+  | {|
+      type: "woff",
+    |}
+  | {|
+      type: "woff2",
+    |}
+  | {|
+      type: "truetype",
+    |}
+  | {|
+      type: "opentype",
+    |}
+  | {|
+      type: "embedded-opentype",
+    |}
+  | {|
+      type: "collection",
+    |}
+  | {|
+      type: "svg",
+    |}
+  | {|
+      type: "string",
+      value: String,
+    |};
+/**
+ * A font format keyword in the `format()` function of the the [src](https://drafts.csswg.org/css-fonts/#src-desc) property of an `@font-face` rule.
+ */
+export type FontTechnology =
+  | "features-opentype"
+  | "features-aat"
+  | "features-graphite"
+  | "color-colrv0"
+  | "color-colrv1"
+  | "color-svg"
+  | "color-sbix"
+  | "color-cbdt"
+  | "variations"
+  | "palettes"
+  | "incremental";
+/**
+ * A value for the [font-style](https://w3c.github.io/csswg-drafts/css-fonts/#descdef-font-face-font-style) descriptor in an `@font-face` rule.
+ */
+export type FontStyle2 =
+  | {|
+      type: "normal",
+    |}
+  | {|
+      type: "italic",
+    |}
+  | {|
+      type: "oblique",
+      value: Size2DFor_Angle,
+    |};
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_Angle = [Angle, Angle];
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_FontWeight = [FontWeight, FontWeight];
+/**
+ * A generic value that represents a value with two components, e.g. a border radius.
+ *
+ * When serialized, only a single component will be written if both are equal.
+ * @minItems 2
+ * @maxItems 2
+ */
+export type Size2DFor_FontStretch = [FontStretch, FontStretch];
+/**
+ * A property within an `@font-palette-values` rule.
+ *
+ * See [FontPaletteValuesRule](FontPaletteValuesRule).
+ */
+export type FontPaletteValuesProperty =
+  | {|
+      type: "font-family",
+      value: FontFamily,
+    |}
+  | {|
+      type: "base-palette",
+      value: BasePalette,
+    |}
+  | {|
+      type: "override-colors",
+      value: OverrideColors[],
+    |}
+  | {|
+      type: "custom",
+      value: CustomProperty,
+    |};
+/**
+ * A value for the [base-palette](https://drafts.csswg.org/css-fonts-4/#base-palette-desc) property in an `@font-palette-values` rule.
+ */
+export type BasePalette =
+  | {|
+      type: "light",
+    |}
+  | {|
+      type: "dark",
+    |}
+  | {|
+      type: "integer",
+      value: number,
+    |};
+/**
+ * The name of the `@font-feature-values` sub-rule. font-feature-value-type = <@stylistic> | <@historical-forms> | <@styleset> | <@character-variant> | <@swash> | <@ornaments> | <@annotation>
+ */
+export type FontFeatureSubruleType =
+  | "stylistic"
+  | "historical-forms"
+  | "styleset"
+  | "character-variant"
+  | "swash"
+  | "ornaments"
+  | "annotation";
+/**
+ * A [page margin box](https://www.w3.org/TR/css-page-3/#margin-boxes).
+ */
+export type PageMarginBox =
+  | "top-left-corner"
+  | "top-left"
+  | "top-center"
+  | "top-right"
+  | "top-right-corner"
+  | "left-top"
+  | "left-middle"
+  | "left-bottom"
+  | "right-top"
+  | "right-middle"
+  | "right-bottom"
+  | "bottom-left-corner"
+  | "bottom-left"
+  | "bottom-center"
+  | "bottom-right"
+  | "bottom-right-corner";
+/**
+ * A page pseudo class within an `@page` selector.
+ *
+ * See [PageSelector](PageSelector).
+ */
+export type PagePseudoClass = "left" | "right" | "first" | "last" | "blank";
+/**
+ * A parsed value for a [SyntaxComponent](SyntaxComponent).
+ */
+export type ParsedComponent =
+  | {|
+      type: "length",
+      value: Length,
+    |}
+  | {|
+      type: "number",
+      value: number,
+    |}
+  | {|
+      type: "percentage",
+      value: number,
+    |}
+  | {|
+      type: "length-percentage",
+      value: DimensionPercentageFor_LengthValue,
+    |}
+  | {|
+      type: "string",
+      value: String,
+    |}
+  | {|
+      type: "color",
+      value: CssColor,
+    |}
+  | {|
+      type: "image",
+      value: Image,
+    |}
+  | {|
+      type: "url",
+      value: Url,
+    |}
+  | {|
+      type: "integer",
+      value: number,
+    |}
+  | {|
+      type: "angle",
+      value: Angle,
+    |}
+  | {|
+      type: "time",
+      value: Time,
+    |}
+  | {|
+      type: "resolution",
+      value: Resolution,
+    |}
+  | {|
+      type: "transform-function",
+      value: Transform,
+    |}
+  | {|
+      type: "transform-list",
+      value: Transform[],
+    |}
+  | {|
+      type: "custom-ident",
+      value: String,
+    |}
+  | {|
+      type: "literal",
+      value: String,
+    |}
+  | {|
+      type: "repeated",
+      value: {|
+        /**
+         * The components to repeat.
+         */
+        components: ParsedComponent[],
+
+        /**
+         * A multiplier describing how the components repeat.
+         */
+        multiplier: Multiplier,
+      |},
+    |}
+  | {|
+      type: "token-list",
+      value: TokenOrValue[],
+    |};
+/**
+ * A [multiplier](https://drafts.css-houdini.org/css-properties-values-api/#multipliers) for a [SyntaxComponent](SyntaxComponent). Indicates whether and how the component may be repeated.
+ */
+export type Multiplier =
+  | {|
+      type: "none",
+    |}
+  | {|
+      type: "space",
+    |}
+  | {|
+      type: "comma",
+    |};
+/**
+ * A CSS [syntax string](https://drafts.css-houdini.org/css-properties-values-api/#syntax-strings) used to define the grammar for a registered custom property.
+ */
+export type SyntaxString =
+  | {|
+      type: "components",
+      value: SyntaxComponent[],
+    |}
+  | {|
+      type: "universal",
+    |};
+/**
+ * A [syntax component component name](https://drafts.css-houdini.org/css-properties-values-api/#supported-names).
+ */
+export type SyntaxComponentKind =
+  | {|
+      type: "length",
+    |}
+  | {|
+      type: "number",
+    |}
+  | {|
+      type: "percentage",
+    |}
+  | {|
+      type: "length-percentage",
+    |}
+  | {|
+      type: "string",
+    |}
+  | {|
+      type: "color",
+    |}
+  | {|
+      type: "image",
+    |}
+  | {|
+      type: "url",
+    |}
+  | {|
+      type: "integer",
+    |}
+  | {|
+      type: "angle",
+    |}
+  | {|
+      type: "time",
+    |}
+  | {|
+      type: "resolution",
+    |}
+  | {|
+      type: "transform-function",
+    |}
+  | {|
+      type: "transform-list",
+    |}
+  | {|
+      type: "custom-ident",
+    |}
+  | {|
+      type: "literal",
+      value: string,
+    |};
+/**
+ * Represents a container condition.
+ */
+export type ContainerCondition<D = Declaration> =
+  | {|
+      type: "feature",
+      value: QueryFeatureFor_ContainerSizeFeatureId,
+    |}
+  | {|
+      type: "not",
+      value: ContainerCondition<D>,
+    |}
+  | {|
+      /**
+       * The conditions for the operator.
+       */
+      conditions: ContainerCondition<D>[],
+
+      /**
+       * The operator for the conditions.
+       */
+      operator: Operator,
+      type: "operation",
+    |}
+  | {|
+      type: "style",
+      value: StyleQuery<D>,
+    |}
+  | {|
+      type: "scroll-state",
+      value: ScrollStateQuery,
+    |}
+  | {|
+      type: "unknown",
+      value: TokenOrValue[],
+    |};
+/**
+ * A generic media feature or container feature.
+ */
+export type QueryFeatureFor_ContainerSizeFeatureId =
+  | {|
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ContainerSizeFeatureId,
+      type: "plain",
+
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue,
+    |}
+  | {|
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ContainerSizeFeatureId,
+      type: "boolean",
+    |}
+  | {|
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ContainerSizeFeatureId,
+
+      /**
+       * A comparator.
+       */
+      operator: MediaFeatureComparison,
+      type: "range",
+
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue,
+    |}
+  | {|
+      /**
+       * The end value.
+       */
+      end: MediaFeatureValue,
+
+      /**
+       * A comparator for the end value.
+       */
+      endOperator: MediaFeatureComparison,
+
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ContainerSizeFeatureId,
+
+      /**
+       * A start value.
+       */
+      start: MediaFeatureValue,
+
+      /**
+       * A comparator for the start value.
+       */
+      startOperator: MediaFeatureComparison,
+      type: "interval",
+    |};
+/**
+ * A media feature name.
+ */
+export type MediaFeatureNameFor_ContainerSizeFeatureId =
+  | ContainerSizeFeatureId
+  | String
+  | String;
+/**
+ * A container query size feature identifier.
+ */
+export type ContainerSizeFeatureId =
+  | "width"
+  | "height"
+  | "inline-size"
+  | "block-size"
+  | "aspect-ratio"
+  | "orientation";
+/**
+ * Represents a style query within a container condition.
+ */
+export type StyleQuery<D = Declaration> =
+  | {|
+      type: "declaration",
+      value: D,
+    |}
+  | {|
+      type: "property",
+      value: PropertyId,
+    |}
+  | {|
+      type: "not",
+      value: StyleQuery<D>,
+    |}
+  | {|
+      /**
+       * The conditions for the operator.
+       */
+      conditions: StyleQuery<D>[],
+
+      /**
+       * The operator for the conditions.
+       */
+      operator: Operator,
+      type: "operation",
+    |};
+/**
+ * Represents a scroll state query within a container condition.
+ */
+export type ScrollStateQuery =
+  | {|
+      type: "feature",
+      value: QueryFeatureFor_ScrollStateFeatureId,
+    |}
+  | {|
+      type: "not",
+      value: ScrollStateQuery,
+    |}
+  | {|
+      /**
+       * The conditions for the operator.
+       */
+      conditions: ScrollStateQuery[],
+
+      /**
+       * The operator for the conditions.
+       */
+      operator: Operator,
+      type: "operation",
+    |};
+/**
+ * A generic media feature or container feature.
+ */
+export type QueryFeatureFor_ScrollStateFeatureId =
+  | {|
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ScrollStateFeatureId,
+      type: "plain",
+
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue,
+    |}
+  | {|
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ScrollStateFeatureId,
+      type: "boolean",
+    |}
+  | {|
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ScrollStateFeatureId,
+
+      /**
+       * A comparator.
+       */
+      operator: MediaFeatureComparison,
+      type: "range",
+
+      /**
+       * The feature value.
+       */
+      value: MediaFeatureValue,
+    |}
+  | {|
+      /**
+       * The end value.
+       */
+      end: MediaFeatureValue,
+
+      /**
+       * A comparator for the end value.
+       */
+      endOperator: MediaFeatureComparison,
+
+      /**
+       * The name of the feature.
+       */
+      name: MediaFeatureNameFor_ScrollStateFeatureId,
+
+      /**
+       * A start value.
+       */
+      start: MediaFeatureValue,
+
+      /**
+       * A comparator for the start value.
+       */
+      startOperator: MediaFeatureComparison,
+      type: "interval",
+    |};
+/**
+ * A media feature name.
+ */
+export type MediaFeatureNameFor_ScrollStateFeatureId =
+  | ScrollStateFeatureId
+  | String
+  | String;
+/**
+ * A container query scroll state feature identifier.
+ */
+export type ScrollStateFeatureId =
+  | "stuck"
+  | "snapped"
+  | "scrollable"
+  | "scrolled";
+/**
+ * A property within a `@view-transition` rule.
+ *
+ * See [ViewTransitionRule](ViewTransitionRule).
+ */
+export type ViewTransitionProperty =
+  | {|
+      property: "navigation",
+      value: Navigation,
+    |}
+  | {|
+      property: "types",
+      value: NoneOrCustomIdentList,
+    |}
+  | {|
+      property: "custom",
+      value: CustomProperty,
+    |};
+/**
+ * A value for the [navigation](https://drafts.csswg.org/css-view-transitions-2/#view-transition-navigation-descriptor) property in a `@view-transition` rule.
+ */
+export type Navigation = "none" | "auto";
+export type DefaultAtRule = null;
+/**
+ * A CSS style sheet, representing a `.css` file or inline `<style>` element.
+ *
+ * Style sheets can be parsed from a string, constructed from scratch, or created using a [Bundler](super::bundler::Bundler). Then, they can be minified and transformed for a set of target browsers, and serialied to a string.
+ *
+ * # Example
+ *
+ * ``` use lightningcss::stylesheet::{ StyleSheet, ParserOptions, MinifyOptions, PrinterOptions };
+ *
+ * // Parse a style sheet from a string. let mut stylesheet = StyleSheet::parse( r#" .foo { color: red; }
+ *
+ * .bar { color: red; } "#, ParserOptions::default() ).unwrap();
+ *
+ * // Minify the stylesheet. stylesheet.minify(MinifyOptions::default()).unwrap();
+ *
+ * // Serialize it to a string. let res = stylesheet.to_css(PrinterOptions::default()).unwrap(); assert_eq!(res.code, ".foo, .bar {\n  color: red;\n}\n"); ```
+ */
+export interface StyleSheet<D = Declaration, M = MediaQuery> {
+  /**
+   * The license comments that appeared at the start of the file.
+   */
+  licenseComments: String[];
+
+  /**
+   * A list of top-level rules within the style sheet.
+   */
+  rules: Rule<D, M>[];
+
+  /**
+   * The source map URL extracted from the original style sheet.
+   */
+  sourceMapUrls: (string | null)[];
+
+  /**
+   * A list of file names for all source files included within the style sheet. Sources are referenced by index in the `loc` property of each rule.
+   */
+  sources: string[];
+}
+/**
+ * A [@media](https://drafts.csswg.org/css-conditional-3/#at-media) rule.
+ */
+export interface MediaRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The media query list.
+   */
+  query: MediaList<M>;
+
+  /**
+   * The rules within the `@media` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A source location.
+ */
+export interface Location2 {
+  /**
+   * The column number within a line, starting at 1 for first the character of the line. Column numbers are counted in UTF-16 code units.
+   */
+  column: number;
+
+  /**
+   * The line number, starting at 0.
+   */
+  line: number;
+
+  /**
+   * The index of the source file within the source map.
+   */
+  source_index: number;
+}
+/**
+ * A [media query list](https://drafts.csswg.org/mediaqueries/#mq-list).
+ */
+export interface MediaList<M = MediaQuery> {
+  /**
+   * The list of media queries.
+   */
+  mediaQueries: M[];
+}
+/**
+ * A [media query](https://drafts.csswg.org/mediaqueries/#media).
+ */
+export interface MediaQuery {
+  /**
+   * The condition that this media query contains. This cannot have `or` in the first level.
+   */
+  condition?: MediaCondition | null;
+
+  /**
+   * The media type for this query, that can be known, unknown, or "all".
+   */
+  mediaType: MediaType;
+
+  /**
+   * The qualifier for this query.
+   */
+  qualifier?: Qualifier | null;
+}
+export interface LengthValue {
+  /**
+   * The length unit.
+   */
+  unit: LengthUnit;
+
+  /**
+   * The length value.
+   */
+  value: number;
+}
+/**
+ * A CSS environment variable reference.
+ */
+export interface EnvironmentVariable {
+  /**
+   * A fallback value in case the variable is not defined.
+   */
+  fallback?: TokenOrValue[] | null;
+
+  /**
+   * Optional indices into the dimensions of the environment variable.
+   */
+  indices?: number[];
+
+  /**
+   * The environment variable name.
+   */
+  name: EnvironmentVariableName;
+}
+/**
+ * A CSS [url()](https://www.w3.org/TR/css-values-4/#urls) value and its source location.
+ */
+export interface Url {
+  /**
+   * The location where the `url()` was seen in the CSS source file.
+   */
+  loc: Location;
+
+  /**
+   * The url string.
+   */
+  url: String;
+}
+/**
+ * A line and column position within a source file.
+ */
+export interface Location {
+  /**
+   * The column number, starting from 1.
+   */
+  column: number;
+
+  /**
+   * The line number, starting from 1.
+   */
+  line: number;
+}
+/**
+ * A CSS variable reference.
+ */
+export interface Variable {
+  /**
+   * A fallback value in case the variable is not defined.
+   */
+  fallback?: TokenOrValue[] | null;
+
+  /**
+   * The variable name.
+   */
+  name: DashedIdentReference;
+}
+/**
+ * A CSS [`<dashed-ident>`](https://www.w3.org/TR/css-values-4/#dashed-idents) reference.
+ *
+ * Dashed idents are used in cases where an identifier can be either author defined _or_ CSS-defined. Author defined idents must start with two dash characters ("--") or parsing will fail.
+ *
+ * In CSS modules, when the `dashed_idents` option is enabled, the identifier may be followed by the `from` keyword and an argument indicating where the referenced identifier is declared (e.g. a filename).
+ */
+export interface DashedIdentReference {
+  /**
+   * CSS modules extension: the filename where the variable is defined. Only enabled when the CSS modules `dashed_idents` option is turned on.
+   */
+  from?: Specifier | null;
+
+  /**
+   * The referenced identifier.
+   */
+  ident: String;
+}
+/**
+ * A custom CSS function.
+ */
+export interface Function {
+  /**
+   * The function arguments.
+   */
+  arguments: TokenOrValue[];
+
+  /**
+   * The function name.
+   */
+  name: String;
+}
+/**
+ * A [@import](https://drafts.csswg.org/css-cascade/#at-import) rule.
+ */
+export interface ImportRule<M = MediaQuery> {
+  /**
+   * An optional cascade layer name, or `None` for an anonymous layer.
+   */
+  layer?: String[] | null;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * A media query.
+   */
+  media?: MediaList<M>;
+
+  /**
+   * An optional `supports()` condition.
+   */
+  supports?: SupportsCondition | null;
+
+  /**
+   * The url to import.
+   */
+  url: String;
+}
+/**
+ * A CSS [style rule](https://drafts.csswg.org/css-syntax/#style-rules).
+ */
+export interface StyleRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The declarations within the style rule.
+   */
+  declarations?: DeclarationBlock<D>;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * Nested rules within the style rule.
+   */
+  rules?: Rule<D, M>[];
+
+  /**
+   * The selectors for the style rule.
+   */
+  selectors: SelectorList;
+}
+/**
+ * A CSS declaration block.
+ *
+ * Properties are separated into a list of `!important` declararations, and a list of normal declarations. This reduces memory usage compared with storing a boolean along with each property.
+ */
+export interface DeclarationBlock<D = Declaration> {
+  /**
+   * A list of normal declarations in the block.
+   */
+  declarations?: D[];
+
+  /**
+   * A list of `!important` declarations in the block.
+   */
+  importantDeclarations?: D[];
+}
+/**
+ * A CSS [`<position>`](https://www.w3.org/TR/css3-values/#position) value, as used in the `background-position` property, gradients, masks, etc.
+ */
+export interface Position {
+  /**
+   * The x-position.
+   */
+  x: PositionComponentFor_HorizontalPositionKeyword;
+
+  /**
+   * The y-position.
+   */
+  y: PositionComponentFor_VerticalPositionKeyword;
+}
+/**
+ * An x/y position within a legacy `-webkit-gradient()`.
+ */
+export interface WebKitGradientPoint {
+  /**
+   * The x-position.
+   */
+  x: WebKitGradientPointComponentFor_HorizontalPositionKeyword;
+
+  /**
+   * The y-position.
+   */
+  y: WebKitGradientPointComponentFor_VerticalPositionKeyword;
+}
+/**
+ * A color stop within a legacy `-webkit-gradient()`.
+ */
+export interface WebKitColorStop {
+  /**
+   * The color of the color stop.
+   */
+  color: CssColor;
+
+  /**
+   * The position of the color stop.
+   */
+  position: number;
+}
+/**
+ * A CSS [`image-set()`](https://drafts.csswg.org/css-images-4/#image-set-notation) value.
+ *
+ * `image-set()` allows the user agent to choose between multiple versions of an image to display the most appropriate resolution or file type that it supports.
+ */
+export interface ImageSet {
+  /**
+   * The image options to choose from.
+   */
+  options: ImageSetOption[];
+
+  /**
+   * The vendor prefix for the `image-set()` function.
+   */
+  vendorPrefix: VendorPrefix;
+}
+/**
+ * An image option within the `image-set()` function. See [ImageSet](ImageSet).
+ */
+export interface ImageSetOption {
+  /**
+   * The mime type of the image.
+   */
+  fileType?: String | null;
+
+  /**
+   * The image for this option.
+   */
+  image: Image;
+
+  /**
+   * The resolution of the image.
+   */
+  resolution: Resolution;
+}
+/**
+ * A value for the [background-position](https://drafts.csswg.org/css-backgrounds/#background-position) shorthand property.
+ */
+export interface BackgroundPosition {
+  /**
+   * The x-position.
+   */
+  x: PositionComponentFor_HorizontalPositionKeyword;
+
+  /**
+   * The y-position.
+   */
+  y: PositionComponentFor_VerticalPositionKeyword;
+}
+/**
+ * A value for the [background-repeat](https://www.w3.org/TR/css-backgrounds-3/#background-repeat) property.
+ */
+export interface BackgroundRepeat {
+  /**
+   * A repeat style for the x direction.
+   */
+  x: BackgroundRepeatKeyword;
+
+  /**
+   * A repeat style for the y direction.
+   */
+  y: BackgroundRepeatKeyword;
+}
+/**
+ * A value for the [background](https://www.w3.org/TR/css-backgrounds-3/#background) shorthand property.
+ */
+export interface Background {
+  /**
+   * The background attachment.
+   */
+  attachment: BackgroundAttachment;
+
+  /**
+   * How the background should be clipped.
+   */
+  clip: BackgroundClip;
+
+  /**
+   * The background color.
+   */
+  color: CssColor;
+
+  /**
+   * The background image.
+   */
+  image: Image;
+
+  /**
+   * The background origin.
+   */
+  origin: BackgroundOrigin;
+
+  /**
+   * The background position.
+   */
+  position: BackgroundPosition;
+
+  /**
+   * How the background image should repeat.
+   */
+  repeat: BackgroundRepeat;
+
+  /**
+   * The size of the background image.
+   */
+  size: BackgroundSize;
+}
+/**
+ * A value for the [box-shadow](https://drafts.csswg.org/css-backgrounds/#box-shadow) property.
+ */
+export interface BoxShadow {
+  /**
+   * The blur radius of the shadow.
+   */
+  blur: Length;
+
+  /**
+   * The color of the box shadow.
+   */
+  color: CssColor;
+
+  /**
+   * Whether the shadow is inset within the box.
+   */
+  inset: boolean;
+
+  /**
+   * The spread distance of the shadow.
+   */
+  spread: Length;
+
+  /**
+   * The x offset of the shadow.
+   */
+  xOffset: Length;
+
+  /**
+   * The y offset of the shadow.
+   */
+  yOffset: Length;
+}
+/**
+ * A value for the [aspect-ratio](https://drafts.csswg.org/css-sizing-4/#aspect-ratio) property.
+ */
+export interface AspectRatio {
+  /**
+   * The `auto` keyword.
+   */
+  auto: boolean;
+
+  /**
+   * A preferred aspect ratio for the box, specified as width / height.
+   */
+  ratio?: Ratio | null;
+}
+/**
+ * A value for the [overflow](https://www.w3.org/TR/css-overflow-3/#overflow-properties) shorthand property.
+ */
+export interface Overflow {
+  /**
+   * The overflow mode for the x direction.
+   */
+  x: OverflowKeyword;
+
+  /**
+   * The overflow mode for the y direction.
+   */
+  y: OverflowKeyword;
+}
+/**
+ * A value for the [inset-block](https://drafts.csswg.org/css-logical/#propdef-inset-block) shorthand property.
+ */
+export interface InsetBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [inset-inline](https://drafts.csswg.org/css-logical/#propdef-inset-inline) shorthand property.
+ */
+export interface InsetInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [inset](https://drafts.csswg.org/css-logical/#propdef-inset) shorthand property.
+ */
+export interface Inset {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [border-radius](https://www.w3.org/TR/css-backgrounds-3/#border-radius) property.
+ */
+export interface BorderRadius {
+  /**
+   * The x and y radius values for the bottom left corner.
+   */
+  bottomLeft: Size2DFor_DimensionPercentageFor_LengthValue;
+
+  /**
+   * The x and y radius values for the bottom right corner.
+   */
+  bottomRight: Size2DFor_DimensionPercentageFor_LengthValue;
+
+  /**
+   * The x and y radius values for the top left corner.
+   */
+  topLeft: Size2DFor_DimensionPercentageFor_LengthValue;
+
+  /**
+   * The x and y radius values for the top right corner.
+   */
+  topRight: Size2DFor_DimensionPercentageFor_LengthValue;
+}
+/**
+ * A value for the [border-image-repeat](https://www.w3.org/TR/css-backgrounds-3/#border-image-repeat) property.
+ */
+export interface BorderImageRepeat {
+  /**
+   * The horizontal repeat value.
+   */
+  horizontal: BorderImageRepeatKeyword;
+
+  /**
+   * The vertical repeat value.
+   */
+  vertical: BorderImageRepeatKeyword;
+}
+/**
+ * A value for the [border-image-slice](https://www.w3.org/TR/css-backgrounds-3/#border-image-slice) property.
+ */
+export interface BorderImageSlice {
+  /**
+   * Whether the middle of the border image should be preserved.
+   */
+  fill: boolean;
+
+  /**
+   * The offsets from the edges of the image.
+   */
+  offsets: RectFor_NumberOrPercentage;
+}
+/**
+ * A value for the [border-image](https://www.w3.org/TR/css-backgrounds-3/#border-image) shorthand property.
+ */
+export interface BorderImage {
+  /**
+   * The amount that the image extends beyond the border box.
+   */
+  outset: RectFor_LengthOrNumber;
+
+  /**
+   * How the border image is scaled and tiled.
+   */
+  repeat: BorderImageRepeat;
+
+  /**
+   * The offsets that define where the image is sliced.
+   */
+  slice: BorderImageSlice;
+
+  /**
+   * The border image.
+   */
+  source: Image;
+
+  /**
+   * The width of the border image.
+   */
+  width: RectFor_BorderImageSideWidth;
+}
+/**
+ * A value for the [border-color](https://drafts.csswg.org/css-backgrounds/#propdef-border-color) shorthand property.
+ */
+export interface BorderColor {
+  /**
+   * The bottom value.
+   */
+  bottom: CssColor;
+
+  /**
+   * The left value.
+   */
+  left: CssColor;
+
+  /**
+   * The right value.
+   */
+  right: CssColor;
+
+  /**
+   * The top value.
+   */
+  top: CssColor;
+}
+/**
+ * A value for the [border-style](https://drafts.csswg.org/css-backgrounds/#propdef-border-style) shorthand property.
+ */
+export interface BorderStyle {
+  /**
+   * The bottom value.
+   */
+  bottom: LineStyle;
+
+  /**
+   * The left value.
+   */
+  left: LineStyle;
+
+  /**
+   * The right value.
+   */
+  right: LineStyle;
+
+  /**
+   * The top value.
+   */
+  top: LineStyle;
+}
+/**
+ * A value for the [border-width](https://drafts.csswg.org/css-backgrounds/#propdef-border-width) shorthand property.
+ */
+export interface BorderWidth {
+  /**
+   * The bottom value.
+   */
+  bottom: BorderSideWidth;
+
+  /**
+   * The left value.
+   */
+  left: BorderSideWidth;
+
+  /**
+   * The right value.
+   */
+  right: BorderSideWidth;
+
+  /**
+   * The top value.
+   */
+  top: BorderSideWidth;
+}
+/**
+ * A value for the [border-block-color](https://drafts.csswg.org/css-logical/#propdef-border-block-color) shorthand property.
+ */
+export interface BorderBlockColor {
+  /**
+   * The block end value.
+   */
+  end: CssColor;
+
+  /**
+   * The block start value.
+   */
+  start: CssColor;
+}
+/**
+ * A value for the [border-block-style](https://drafts.csswg.org/css-logical/#propdef-border-block-style) shorthand property.
+ */
+export interface BorderBlockStyle {
+  /**
+   * The block end value.
+   */
+  end: LineStyle;
+
+  /**
+   * The block start value.
+   */
+  start: LineStyle;
+}
+/**
+ * A value for the [border-block-width](https://drafts.csswg.org/css-logical/#propdef-border-block-width) shorthand property.
+ */
+export interface BorderBlockWidth {
+  /**
+   * The block end value.
+   */
+  end: BorderSideWidth;
+
+  /**
+   * The block start value.
+   */
+  start: BorderSideWidth;
+}
+/**
+ * A value for the [border-inline-color](https://drafts.csswg.org/css-logical/#propdef-border-inline-color) shorthand property.
+ */
+export interface BorderInlineColor {
+  /**
+   * The inline end value.
+   */
+  end: CssColor;
+
+  /**
+   * The inline start value.
+   */
+  start: CssColor;
+}
+/**
+ * A value for the [border-inline-style](https://drafts.csswg.org/css-logical/#propdef-border-inline-style) shorthand property.
+ */
+export interface BorderInlineStyle {
+  /**
+   * The inline end value.
+   */
+  end: LineStyle;
+
+  /**
+   * The inline start value.
+   */
+  start: LineStyle;
+}
+/**
+ * A value for the [border-inline-width](https://drafts.csswg.org/css-logical/#propdef-border-inline-width) shorthand property.
+ */
+export interface BorderInlineWidth {
+  /**
+   * The inline end value.
+   */
+  end: BorderSideWidth;
+
+  /**
+   * The inline start value.
+   */
+  start: BorderSideWidth;
+}
+/**
+ * A generic type that represents the `border` and `outline` shorthand properties.
+ */
+export interface GenericBorderFor_LineStyle {
+  /**
+   * The border color.
+   */
+  color: CssColor;
+
+  /**
+   * The border style.
+   */
+  style: LineStyle;
+
+  /**
+   * The width of the border.
+   */
+  width: BorderSideWidth;
+}
+/**
+ * A generic type that represents the `border` and `outline` shorthand properties.
+ */
+export interface GenericBorderFor_OutlineStyleAnd_11 {
+  /**
+   * The border color.
+   */
+  color: CssColor;
+
+  /**
+   * The border style.
+   */
+  style: OutlineStyle;
+
+  /**
+   * The width of the border.
+   */
+  width: BorderSideWidth;
+}
+/**
+ * A value for the [flex-flow](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-flow-property) shorthand property.
+ */
+export interface FlexFlow {
+  /**
+   * The direction that flex items flow.
+   */
+  direction: FlexDirection;
+
+  /**
+   * How the flex items wrap.
+   */
+  wrap: FlexWrap;
+}
+/**
+ * A value for the [flex](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-property) shorthand property.
+ */
+export interface Flex {
+  /**
+   * The flex basis.
+   */
+  basis: LengthPercentageOrAuto;
+
+  /**
+   * The flex grow factor.
+   */
+  grow: number;
+
+  /**
+   * The flex shrink factor.
+   */
+  shrink: number;
+}
+/**
+ * A value for the [place-content](https://www.w3.org/TR/css-align-3/#place-content) shorthand property.
+ */
+export interface PlaceContent {
+  /**
+   * The content alignment.
+   */
+  align: AlignContent;
+
+  /**
+   * The content justification.
+   */
+  justify: JustifyContent;
+}
+/**
+ * A value for the [place-self](https://www.w3.org/TR/css-align-3/#place-self-property) shorthand property.
+ */
+export interface PlaceSelf {
+  /**
+   * The item alignment.
+   */
+  align: AlignSelf;
+
+  /**
+   * The item justification.
+   */
+  justify: JustifySelf;
+}
+/**
+ * A value for the [place-items](https://www.w3.org/TR/css-align-3/#place-items-property) shorthand property.
+ */
+export interface PlaceItems {
+  /**
+   * The item alignment.
+   */
+  align: AlignItems;
+
+  /**
+   * The item justification.
+   */
+  justify: JustifyItems;
+}
+/**
+ * A value for the [gap](https://www.w3.org/TR/css-align-3/#gap-shorthand) shorthand property.
+ */
+export interface Gap {
+  /**
+   * The column gap.
+   */
+  column: GapValue;
+
+  /**
+   * The row gap.
+   */
+  row: GapValue;
+}
+/**
+ * A [`<track-repeat>`](https://drafts.csswg.org/css-grid-2/#typedef-track-repeat) value, representing the `repeat()` function in a track list.
+ *
+ * See [TrackListItem](TrackListItem).
+ */
+export interface TrackRepeat {
+  /**
+   * The repeat count.
+   */
+  count: RepeatCount;
+
+  /**
+   * The line names to repeat.
+   */
+  lineNames: String[][];
+
+  /**
+   * The track sizes to repeat.
+   */
+  trackSizes: TrackSize[];
+}
+export interface GridAutoFlow {
+  /**
+   * If specified, a dense packing algorithm is used, which fills in holes in the grid.
+   */
+  dense: boolean;
+
+  /**
+   * The direction of the auto flow.
+   */
+  direction: AutoFlowDirection;
+}
+/**
+ * A value for the [grid-template](https://drafts.csswg.org/css-grid-2/#explicit-grid-shorthand) shorthand property.
+ *
+ * none | [ <'grid-template-rows'> / <'grid-template-columns'> ] | [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <explicit-track-list> ]?
+ *
+ * If `areas` is not `None`, then `rows` must also not be `None`.
+ */
+export interface GridTemplate {
+  /**
+   * The named grid areas.
+   */
+  areas: GridTemplateAreas;
+
+  /**
+   * The grid template columns.
+   */
+  columns: TrackSizing;
+
+  /**
+   * The grid template rows.
+   */
+  rows: TrackSizing;
+}
+/**
+ * A value for the [grid](https://drafts.csswg.org/css-grid-2/#grid-shorthand) shorthand property.
+ *
+ * <'grid-template'> | <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>? | [ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>
+ *
+ * Explicit and implicit values may not be combined.
+ */
+export interface Grid {
+  /**
+   * Explicit grid template areas.
+   */
+  areas: GridTemplateAreas;
+
+  /**
+   * The grid auto columns.
+   */
+  autoColumns: TrackSize[];
+
+  /**
+   * The grid auto flow.
+   */
+  autoFlow: GridAutoFlow;
+
+  /**
+   * The grid auto rows.
+   */
+  autoRows: TrackSize[];
+
+  /**
+   * Explicit grid template columns.
+   */
+  columns: TrackSizing;
+
+  /**
+   * Explicit grid template rows.
+   */
+  rows: TrackSizing;
+}
+/**
+ * A value for the [grid-row](https://drafts.csswg.org/css-grid-2/#propdef-grid-row) shorthand property. <grid-line> [ / <grid-line> ]?
+ */
+export interface GridRow {
+  /**
+   * The ending line.
+   */
+  end: GridLine;
+
+  /**
+   * The starting line.
+   */
+  start: GridLine;
+}
+/**
+ * A value for the [grid-column](https://drafts.csswg.org/css-grid-2/#propdef-grid-column) shorthand property. <grid-line> [ / <grid-line> ]?
+ */
+export interface GridColumn {
+  /**
+   * The ending line.
+   */
+  end: GridLine;
+
+  /**
+   * The starting line.
+   */
+  start: GridLine;
+}
+/**
+ * A value for the [grid-area](https://drafts.csswg.org/css-grid-2/#propdef-grid-area) shorthand property. <grid-line> [ / <grid-line> ]{0,3}
+ */
+export interface GridArea {
+  /**
+   * The grid column end placement.
+   */
+  columnEnd: GridLine;
+
+  /**
+   * The grid column start placement.
+   */
+  columnStart: GridLine;
+
+  /**
+   * The grid row end placement.
+   */
+  rowEnd: GridLine;
+
+  /**
+   * The grid row start placement.
+   */
+  rowStart: GridLine;
+}
+/**
+ * A value for the [margin-block](https://drafts.csswg.org/css-logical/#propdef-margin-block) shorthand property.
+ */
+export interface MarginBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [margin-inline](https://drafts.csswg.org/css-logical/#propdef-margin-inline) shorthand property.
+ */
+export interface MarginInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [margin](https://drafts.csswg.org/css-box-4/#propdef-margin) shorthand property.
+ */
+export interface Margin {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [padding-block](https://drafts.csswg.org/css-logical/#propdef-padding-block) shorthand property.
+ */
+export interface PaddingBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [padding-inline](https://drafts.csswg.org/css-logical/#propdef-padding-inline) shorthand property.
+ */
+export interface PaddingInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [padding](https://drafts.csswg.org/css-box-4/#propdef-padding) shorthand property.
+ */
+export interface Padding {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-margin-block](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-margin-block) shorthand property.
+ */
+export interface ScrollMarginBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-margin-inline](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-margin-inline) shorthand property.
+ */
+export interface ScrollMarginInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-margin](https://drafts.csswg.org/css-scroll-snap/#scroll-margin) shorthand property.
+ */
+export interface ScrollMargin {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-padding-block](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-padding-block) shorthand property.
+ */
+export interface ScrollPaddingBlock {
+  /**
+   * The block end value.
+   */
+  blockEnd: LengthPercentageOrAuto;
+
+  /**
+   * The block start value.
+   */
+  blockStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-padding-inline](https://drafts.csswg.org/css-scroll-snap/#propdef-scroll-padding-inline) shorthand property.
+ */
+export interface ScrollPaddingInline {
+  /**
+   * The inline end value.
+   */
+  inlineEnd: LengthPercentageOrAuto;
+
+  /**
+   * The inline start value.
+   */
+  inlineStart: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [scroll-padding](https://drafts.csswg.org/css-scroll-snap/#scroll-padding) shorthand property.
+ */
+export interface ScrollPadding {
+  /**
+   * The bottom value.
+   */
+  bottom: LengthPercentageOrAuto;
+
+  /**
+   * The left value.
+   */
+  left: LengthPercentageOrAuto;
+
+  /**
+   * The right value.
+   */
+  right: LengthPercentageOrAuto;
+
+  /**
+   * The top value.
+   */
+  top: LengthPercentageOrAuto;
+}
+/**
+ * A value for the [font](https://www.w3.org/TR/css-fonts-4/#font-prop) shorthand property.
+ */
+export interface Font {
+  /**
+   * The font family.
+   */
+  family: FontFamily[];
+
+  /**
+   * The line height.
+   */
+  lineHeight: LineHeight;
+
+  /**
+   * The font size.
+   */
+  size: FontSize;
+
+  /**
+   * The font stretch.
+   */
+  stretch: FontStretch;
+
+  /**
+   * The font style.
+   */
+  style: FontStyle;
+
+  /**
+   * How the text should be capitalized. Only CSS 2.1 values are supported.
+   */
+  variantCaps: FontVariantCaps;
+
+  /**
+   * The font weight.
+   */
+  weight: FontWeight;
+}
+/**
+ * A value for the [transition](https://www.w3.org/TR/2018/WD-css-transitions-1-20181011/#transition-shorthand-property) property.
+ */
+export interface Transition {
+  /**
+   * The delay before the transition starts.
+   */
+  delay: Time;
+
+  /**
+   * The duration of the transition.
+   */
+  duration: Time;
+
+  /**
+   * The property to transition.
+   */
+  property: PropertyId;
+
+  /**
+   * The easing function for the transition.
+   */
+  timingFunction: EasingFunction;
+}
+/**
+ * The [scroll()](https://drafts.csswg.org/scroll-animations-1/#scroll-notation) function.
+ */
+export interface ScrollTimeline {
+  /**
+   * Specifies which axis of the scroll container to use as the progress for the timeline.
+   */
+  axis: ScrollAxis;
+
+  /**
+   * Specifies which element to use as the scroll container.
+   */
+  scroller: Scroller;
+}
+/**
+ * The [view()](https://drafts.csswg.org/scroll-animations-1/#view-notation) function.
+ */
+export interface ViewTimeline {
+  /**
+   * Specifies which axis of the scroll container to use as the progress for the timeline.
+   */
+  axis: ScrollAxis;
+
+  /**
+   * Provides an adjustment of the view progress visibility range.
+   */
+  inset: Size2DFor_LengthPercentageOrAuto;
+}
+/**
+ * A value for the [animation-range](https://drafts.csswg.org/scroll-animations/#animation-range) shorthand property.
+ */
+export interface AnimationRange {
+  /**
+   * The end of the animation's attachment range.
+   */
+  end: AnimationRangeEnd;
+
+  /**
+   * The start of the animation's attachment range.
+   */
+  start: AnimationRangeStart;
+}
+/**
+ * A value for the [animation](https://drafts.csswg.org/css-animations/#animation) shorthand property.
+ */
+export interface Animation {
+  /**
+   * The animation delay.
+   */
+  delay: Time;
+
+  /**
+   * The direction of the animation.
+   */
+  direction: AnimationDirection;
+
+  /**
+   * The animation duration.
+   */
+  duration: Time;
+
+  /**
+   * The animation fill mode.
+   */
+  fillMode: AnimationFillMode;
+
+  /**
+   * The number of times the animation will run.
+   */
+  iterationCount: AnimationIterationCount;
+
+  /**
+   * The animation name.
+   */
+  name: AnimationName;
+
+  /**
+   * The current play state of the animation.
+   */
+  playState: AnimationPlayState;
+
+  /**
+   * The animation timeline.
+   */
+  timeline: AnimationTimeline;
+
+  /**
+   * The easing function for the animation.
+   */
+  timingFunction: EasingFunction;
+}
+/**
+ * A 2D matrix.
+ */
+export interface MatrixForFloat {
+  a: number;
+  b: number;
+  c: number;
+  d: number;
+  e: number;
+  f: number;
+}
+/**
+ * A 3D matrix.
+ */
+export interface Matrix3DForFloat {
+  m11: number;
+  m12: number;
+  m13: number;
+  m14: number;
+  m21: number;
+  m22: number;
+  m23: number;
+  m24: number;
+  m31: number;
+  m32: number;
+  m33: number;
+  m34: number;
+  m41: number;
+  m42: number;
+  m43: number;
+  m44: number;
+}
+/**
+ * A value for the [rotate](https://drafts.csswg.org/css-transforms-2/#propdef-rotate) property.
+ */
+export interface Rotate {
+  /**
+   * The angle of rotation.
+   */
+  angle: Angle;
+
+  /**
+   * Rotation around the x axis.
+   */
+  x: number;
+
+  /**
+   * Rotation around the y axis.
+   */
+  y: number;
+
+  /**
+   * Rotation around the z axis.
+   */
+  z: number;
+}
+/**
+ * A value for the [text-transform](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-transform-property) property.
+ */
+export interface TextTransform {
+  /**
+   * How case should be transformed.
+   */
+  case: TextTransformCase;
+
+  /**
+   * Converts all small Kana characters to the equivalent full-size Kana.
+   */
+  fullSizeKana: boolean;
+
+  /**
+   * Puts all typographic character units in full-width form.
+   */
+  fullWidth: boolean;
+}
+/**
+ * A value for the [text-indent](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-indent-property) property.
+ */
+export interface TextIndent {
+  /**
+   * Affects the first line after each hard break.
+   */
+  eachLine: boolean;
+
+  /**
+   * Inverts which lines are affected.
+   */
+  hanging: boolean;
+
+  /**
+   * The amount to indent.
+   */
+  value: DimensionPercentageFor_LengthValue;
+}
+/**
+ * A value for the [text-decoration](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-property) shorthand property.
+ */
+export interface TextDecoration {
+  /**
+   * The color of the lines.
+   */
+  color: CssColor;
+
+  /**
+   * The lines to display.
+   */
+  line: TextDecorationLine;
+
+  /**
+   * The style of the lines.
+   */
+  style: TextDecorationStyle;
+
+  /**
+   * The thickness of the lines.
+   */
+  thickness: TextDecorationThickness;
+}
+/**
+ * A value for the [text-emphasis](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-property) shorthand property.
+ */
+export interface TextEmphasis {
+  /**
+   * The text emphasis color.
+   */
+  color: CssColor;
+
+  /**
+   * The text emphasis style.
+   */
+  style: TextEmphasisStyle;
+}
+/**
+ * A value for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property.
+ */
+export interface TextEmphasisPosition {
+  /**
+   * The horizontal position.
+   */
+  horizontal: TextEmphasisPositionHorizontal;
+
+  /**
+   * The vertical position.
+   */
+  vertical: TextEmphasisPositionVertical;
+}
+/**
+ * A value for the [text-shadow](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-shadow-property) property.
+ */
+export interface TextShadow {
+  /**
+   * The blur radius of the text shadow.
+   */
+  blur: Length;
+
+  /**
+   * The color of the text shadow.
+   */
+  color: CssColor;
+
+  /**
+   * The spread distance of the text shadow.
+   */
+  spread: Length;
+
+  /**
+   * The x offset of the text shadow.
+   */
+  xOffset: Length;
+
+  /**
+   * The y offset of the text shadow.
+   */
+  yOffset: Length;
+}
+/**
+ * A value for the [cursor](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) property.
+ */
+export interface Cursor {
+  /**
+   * A list of cursor images.
+   */
+  images: CursorImage[];
+
+  /**
+   * A pre-defined cursor.
+   */
+  keyword: CursorKeyword;
+}
+/**
+ * A [cursor image](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) value, used in the `cursor` property.
+ *
+ * See [Cursor](Cursor).
+ */
+export interface CursorImage {
+  /**
+   * The location in the image where the mouse pointer appears.
+   * @minItems 2
+   * @maxItems 2
+   */
+  hotspot?: [number, number] | null;
+
+  /**
+   * A url to the cursor image.
+   */
+  url: Url;
+}
+/**
+ * A value for the [caret](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret) shorthand property.
+ */
+export interface Caret {
+  /**
+   * The caret color.
+   */
+  color: ColorOrAuto;
+
+  /**
+   * The caret shape.
+   */
+  shape: CaretShape;
+}
+/**
+ * A value for the [list-style](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#list-style-property) shorthand property.
+ */
+export interface ListStyle {
+  /**
+   * The list marker image.
+   */
+  image: Image;
+
+  /**
+   * The list style type.
+   */
+  listStyleType: ListStyleType;
+
+  /**
+   * The position of the list marker.
+   */
+  position: ListStylePosition;
+}
+/**
+ * A value for the [composes](https://github.com/css-modules/css-modules/#dependencies) property from CSS modules.
+ */
+export interface Composes {
+  /**
+   * Where the class names are composed from.
+   */
+  from?: Specifier | null;
+
+  /**
+   * The source location of the `composes` property.
+   */
+  loc: Location;
+
+  /**
+   * A list of class names to compose.
+   */
+  names: String[];
+}
+/**
+ * An [`inset()`](https://www.w3.org/TR/css-shapes-1/#funcdef-inset) rectangle shape.
+ */
+export interface InsetRect {
+  /**
+   * A corner radius for the rectangle.
+   */
+  radius: BorderRadius;
+
+  /**
+   * The rectangle.
+   */
+  rect: RectFor_DimensionPercentageFor_LengthValue;
+}
+/**
+ * A [`circle()`](https://www.w3.org/TR/css-shapes-1/#funcdef-circle) shape.
+ */
+export interface Circle2 {
+  /**
+   * The position of the center of the circle.
+   */
+  position: Position;
+
+  /**
+   * The radius of the circle.
+   */
+  radius: ShapeRadius;
+}
+/**
+ * An [`ellipse()`](https://www.w3.org/TR/css-shapes-1/#funcdef-ellipse) shape.
+ */
+export interface Ellipse2 {
+  /**
+   * The position of the center of the ellipse.
+   */
+  position: Position;
+
+  /**
+   * The x-radius of the ellipse.
+   */
+  radiusX: ShapeRadius;
+
+  /**
+   * The y-radius of the ellipse.
+   */
+  radiusY: ShapeRadius;
+}
+/**
+ * A [`polygon()`](https://www.w3.org/TR/css-shapes-1/#funcdef-polygon) shape.
+ */
+export interface Polygon {
+  /**
+   * The fill rule used to determine the interior of the polygon.
+   */
+  fillRule: FillRule;
+
+  /**
+   * The points of each vertex of the polygon.
+   */
+  points: Point[];
+}
+/**
+ * A point within a `polygon()` shape.
+ *
+ * See [Polygon](Polygon).
+ */
+export interface Point {
+  /**
+   * The x position of the point.
+   */
+  x: DimensionPercentageFor_LengthValue;
+
+  /**
+   * the y position of the point.
+   */
+  y: DimensionPercentageFor_LengthValue;
+}
+/**
+ * A value for the [mask](https://www.w3.org/TR/css-masking-1/#the-mask) shorthand property.
+ */
+export interface Mask {
+  /**
+   * The box in which the mask is clipped.
+   */
+  clip: MaskClip;
+
+  /**
+   * How the mask is composited with the element.
+   */
+  composite: MaskComposite;
+
+  /**
+   * The mask image.
+   */
+  image: Image;
+
+  /**
+   * How the mask image is interpreted.
+   */
+  mode: MaskMode;
+
+  /**
+   * The origin of the mask.
+   */
+  origin: GeometryBox;
+
+  /**
+   * The position of the mask.
+   */
+  position: Position;
+
+  /**
+   * How the mask repeats.
+   */
+  repeat: BackgroundRepeat;
+
+  /**
+   * The size of the mask image.
+   */
+  size: BackgroundSize;
+}
+/**
+ * A value for the [mask-border](https://www.w3.org/TR/css-masking-1/#the-mask-border) shorthand property.
+ */
+export interface MaskBorder {
+  /**
+   * How the mask image is interpreted.
+   */
+  mode: MaskBorderMode;
+
+  /**
+   * The amount that the image extends beyond the border box.
+   */
+  outset: RectFor_LengthOrNumber;
+
+  /**
+   * How the mask image is scaled and tiled.
+   */
+  repeat: BorderImageRepeat;
+
+  /**
+   * The offsets that define where the image is sliced.
+   */
+  slice: BorderImageSlice;
+
+  /**
+   * The mask image.
+   */
+  source: Image;
+
+  /**
+   * The width of the mask image.
+   */
+  width: RectFor_BorderImageSideWidth;
+}
+/**
+ * A [`drop-shadow()`](https://drafts.fxtf.org/filter-effects-1/#funcdef-filter-drop-shadow) filter function.
+ */
+export interface DropShadow {
+  /**
+   * The blur radius of the drop shadow.
+   */
+  blur: Length;
+
+  /**
+   * The color of the drop shadow.
+   */
+  color: CssColor;
+
+  /**
+   * The x offset of the drop shadow.
+   */
+  xOffset: Length;
+
+  /**
+   * The y offset of the drop shadow.
+   */
+  yOffset: Length;
+}
+/**
+ * A value for the [container](https://drafts.csswg.org/css-contain-3/#container-shorthand) shorthand property.
+ */
+export interface Container {
+  /**
+   * The container type.
+   */
+  containerType: ContainerType;
+
+  /**
+   * The container name.
+   */
+  name: ContainerNameList;
+}
+export interface ColorScheme {
+  dark: boolean;
+  light: boolean;
+  only: boolean;
+}
+/**
+ * A known property with an unparsed value.
+ *
+ * This type is used when the value of a known property could not be parsed, e.g. in the case css `var()` references are encountered. In this case, the raw tokens are stored instead.
+ */
+export interface UnparsedProperty {
+  /**
+   * The id of the property.
+   */
+  propertyId: PropertyId;
+
+  /**
+   * The property value, stored as a raw token list.
+   */
+  value: TokenOrValue[];
+}
+/**
+ * A CSS custom property, representing any unknown property.
+ */
+export interface CustomProperty {
+  /**
+   * The name of the property.
+   */
+  name: CustomPropertyName;
+
+  /**
+   * The property value, stored as a raw token list.
+   */
+  value: TokenOrValue[];
+}
+export interface AttrOperation {
+  caseSensitivity?: {| ...ParsedCaseSensitivity, ...string |};
+  operator: AttrSelectorOperator;
+  value: string;
+}
+/**
+ * A [view transition part selector](https://w3c.github.io/csswg-drafts/css-view-transitions-1/#typedef-pt-name-selector).
+ */
+export interface ViewTransitionPartSelector {
+  /**
+   * A list of view transition classes.
+   */
+  classes: String[];
+
+  /**
+   * The view transition part name.
+   */
+  name?: ViewTransitionPartName | null;
+}
+/**
+ * A [@keyframes](https://drafts.csswg.org/css-animations/#keyframes) rule.
+ */
+export interface KeyframesRule<D = Declaration> {
+  /**
+   * A list of keyframes in the animation.
+   */
+  keyframes: Keyframe<D>[];
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The animation name. <keyframes-name> = <custom-ident> | <string>
+   */
+  name: KeyframesName;
+
+  /**
+   * A vendor prefix for the rule, e.g. `@-webkit-keyframes`.
+   */
+  vendorPrefix: VendorPrefix;
+}
+/**
+ * An individual keyframe within an `@keyframes` rule.
+ *
+ * See [KeyframesRule](KeyframesRule).
+ */
+export interface Keyframe<D = Declaration> {
+  /**
+   * The declarations for this keyframe.
+   */
+  declarations: DeclarationBlock<D>;
+
+  /**
+   * A list of keyframe selectors to associate with the declarations in this keyframe.
+   */
+  selectors: KeyframeSelector[];
+}
+/**
+ * A percentage of a given timeline range
+ */
+export interface TimelineRangePercentage {
+  /**
+   * The name of the timeline range.
+   */
+  name: TimelineRangeName;
+
+  /**
+   * The percentage progress between the start and end of the range.
+   */
+  percentage: number;
+}
+/**
+ * A [@font-face](https://drafts.csswg.org/css-fonts/#font-face-rule) rule.
+ */
+export interface FontFaceRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * Declarations in the `@font-face` rule.
+   */
+  properties: FontFaceProperty[];
+}
+/**
+ * A `url()` value for the [src](https://drafts.csswg.org/css-fonts/#src-desc) property in an `@font-face` rule.
+ */
+export interface UrlSource {
+  /**
+   * Optional `format()` function.
+   */
+  format?: FontFormat | null;
+
+  /**
+   * Optional `tech()` function.
+   */
+  tech: FontTechnology[];
+
+  /**
+   * The URL.
+   */
+  url: Url;
+}
+/**
+ * A contiguous range of Unicode code points.
+ *
+ * Cannot be empty. Can represent a single code point when start == end.
+ */
+export interface UnicodeRange {
+  /**
+   * Inclusive end of the range. In [0, 0x10FFFF].
+   */
+  end: number;
+
+  /**
+   * Inclusive start of the range. In [0, end].
+   */
+  start: number;
+}
+/**
+ * A [@font-palette-values](https://drafts.csswg.org/css-fonts-4/#font-palette-values) rule.
+ */
+export interface FontPaletteValuesRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The name of the font palette.
+   */
+  name: String;
+
+  /**
+   * Declarations in the `@font-palette-values` rule.
+   */
+  properties: FontPaletteValuesProperty[];
+}
+/**
+ * A value for the [override-colors](https://drafts.csswg.org/css-fonts-4/#override-color) property in an `@font-palette-values` rule.
+ */
+export interface OverrideColors {
+  /**
+   * The replacement color.
+   */
+  color: CssColor;
+
+  /**
+   * The index of the color within the palette to override.
+   */
+  index: number;
+}
+/**
+ * A [@font-feature-values](https://drafts.csswg.org/css-fonts/#font-feature-values) rule.
+ */
+export interface FontFeatureValuesRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The name of the font feature values.
+   */
+  name: String[];
+
+  /**
+   * The rules within the `@font-feature-values` rule.
+   */
+  rules: {
+    [k: string]: FontFeatureSubrule,
+  };
+}
+/**
+ * A sub-rule of `@font-feature-values` https://drafts.csswg.org/css-fonts/#font-feature-values-syntax
+ */
+export interface FontFeatureSubrule {
+  /**
+   * The declarations within the `@font-feature-values` sub-rules.
+   */
+  declarations: {
+    [k: string]: number[],
+  };
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The name of the `@font-feature-values` sub-rule.
+   */
+  name: FontFeatureSubruleType;
+}
+/**
+ * A [@page](https://www.w3.org/TR/css-page-3/#at-page-rule) rule.
+ */
+export interface PageRule<D = Declaration> {
+  /**
+   * The declarations within the `@page` rule.
+   */
+  declarations: DeclarationBlock<D>;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The nested margin rules.
+   */
+  rules: PageMarginRule<D>[];
+
+  /**
+   * A list of page selectors.
+   */
+  selectors: PageSelector[];
+}
+/**
+ * A [page margin rule](https://www.w3.org/TR/css-page-3/#margin-at-rules) rule.
+ */
+export interface PageMarginRule<D = Declaration> {
+  /**
+   * The declarations within the rule.
+   */
+  declarations: DeclarationBlock<D>;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The margin box identifier for this rule.
+   */
+  marginBox: PageMarginBox;
+}
+/**
+ * A [page selector](https://www.w3.org/TR/css-page-3/#typedef-page-selector) within a `@page` rule.
+ *
+ * Either a name or at least one pseudo class is required.
+ */
+export interface PageSelector {
+  /**
+   * An optional named page type.
+   */
+  name?: String | null;
+
+  /**
+   * A list of page pseudo classes.
+   */
+  pseudoClasses: PagePseudoClass[];
+}
+/**
+ * A [@supports](https://drafts.csswg.org/css-conditional-3/#at-supports) rule.
+ */
+export interface SupportsRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The supports condition.
+   */
+  condition: SupportsCondition;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The rules within the `@supports` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@counter-style](https://drafts.csswg.org/css-counter-styles/#the-counter-style-rule) rule.
+ */
+export interface CounterStyleRule<D = Declaration> {
+  /**
+   * Declarations in the `@counter-style` rule.
+   */
+  declarations: DeclarationBlock<D>;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The name of the counter style to declare.
+   */
+  name: String;
+}
+/**
+ * A [@namespace](https://drafts.csswg.org/css-namespaces/#declaration) rule.
+ */
+export interface NamespaceRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * An optional namespace prefix to declare, or `None` to declare the default namespace.
+   */
+  prefix?: String | null;
+
+  /**
+   * The url of the namespace.
+   */
+  url: String;
+}
+/**
+ * A [@-moz-document](https://www.w3.org/TR/2012/WD-css3-conditional-20120911/#at-document) rule.
+ *
+ * Note that only the `url-prefix()` function with no arguments is supported, and only the `-moz` prefix is allowed since Firefox was the only browser that ever implemented this rule.
+ */
+export interface MozDocumentRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * Nested rules within the `@-moz-document` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@nest](https://www.w3.org/TR/css-nesting-1/#at-nest) rule.
+ */
+export interface NestingRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The style rule that defines the selector and declarations for the `@nest` rule.
+   */
+  style: StyleRule<D, M>;
+}
+/**
+ * A [nested declarations](https://drafts.csswg.org/css-nesting/#nested-declarations-rule) rule.
+ */
+export interface NestedDeclarationsRule<D = Declaration> {
+  /**
+   * The style rule that defines the selector and declarations for the `@nest` rule.
+   */
+  declarations: DeclarationBlock<D>;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+}
+/**
+ * A [@viewport](https://drafts.csswg.org/css-device-adapt/#atviewport-rule) rule.
+ */
+export interface ViewportRule<D = Declaration> {
+  /**
+   * The declarations within the `@viewport` rule.
+   */
+  declarations: DeclarationBlock<D>;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The vendor prefix for this rule, e.g. `@-ms-viewport`.
+   */
+  vendorPrefix: VendorPrefix;
+}
+/**
+ * A [@custom-media](https://drafts.csswg.org/mediaqueries-5/#custom-mq) rule.
+ */
+export interface CustomMediaRule<M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The name of the declared media query.
+   */
+  name: String;
+
+  /**
+   * The media query to declare.
+   */
+  query: MediaList<M>;
+}
+/**
+ * A [@layer statement](https://drafts.csswg.org/css-cascade-5/#layer-empty) rule.
+ *
+ * See also [LayerBlockRule](LayerBlockRule).
+ */
+export interface LayerStatementRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The layer names to declare.
+   */
+  names: String[][];
+}
+/**
+ * A [@layer block](https://drafts.csswg.org/css-cascade-5/#layer-block) rule.
+ */
+export interface LayerBlockRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The name of the layer to declare, or `None` to declare an anonymous layer.
+   */
+  name?: String[] | null;
+
+  /**
+   * The rules within the `@layer` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@property](https://drafts.css-houdini.org/css-properties-values-api/#at-property-rule) rule.
+ */
+export interface PropertyRule {
+  /**
+   * Whether the custom property is inherited.
+   */
+  inherits: boolean;
+
+  /**
+   * An optional initial value for the custom property.
+   */
+  initialValue?: ParsedComponent | null;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The name of the custom property to declare.
+   */
+  name: String;
+
+  /**
+   * A syntax string to specify the grammar for the custom property.
+   */
+  syntax: SyntaxString;
+}
+/**
+ * A [syntax component](https://drafts.css-houdini.org/css-properties-values-api/#syntax-component) within a [SyntaxString](SyntaxString).
+ *
+ * A syntax component consists of a component kind an a multiplier, which indicates how the component may repeat during parsing.
+ */
+export interface SyntaxComponent {
+  /**
+   * The kind of component.
+   */
+  kind: SyntaxComponentKind;
+
+  /**
+   * A multiplier for the component.
+   */
+  multiplier: Multiplier;
+}
+/**
+ * A [@container](https://drafts.csswg.org/css-contain-3/#container-rule) rule.
+ */
+export interface ContainerRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The container condition.
+   */
+  condition?: ContainerCondition<D> | null;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The name of the container.
+   */
+  name?: String | null;
+
+  /**
+   * The rules within the `@container` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@scope](https://drafts.csswg.org/css-cascade-6/#scope-atrule) rule.
+ * @scope (<scope-start>) [to (<scope-end>)]? { <stylesheet> }
+ */
+export interface ScopeRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * Nested rules within the `@scope` rule.
+   */
+  rules: Rule<D, M>[];
+
+  /**
+   * A selector list used to identify any scoping limits.
+   */
+  scopeEnd?: SelectorList | null;
+
+  /**
+   * A selector list used to identify the scoping root(s).
+   */
+  scopeStart?: SelectorList | null;
+}
+/**
+ * A [@starting-style](https://drafts.csswg.org/css-transitions-2/#defining-before-change-style-the-starting-style-rule) rule.
+ */
+export interface StartingStyleRule<D = Declaration, M = MediaQuery> {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * Nested rules within the `@starting-style` rule.
+   */
+  rules: Rule<D, M>[];
+}
+/**
+ * A [@view-transition](https://drafts.csswg.org/css-view-transitions-2/#view-transition-rule) rule.
+ */
+export interface ViewTransitionRule {
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * Declarations in the `@view-transition` rule.
+   */
+  properties: ViewTransitionProperty[];
+}
+/**
+ * An unknown at-rule, stored as raw tokens.
+ */
+export interface UnknownAtRule {
+  /**
+   * The contents of the block, if any.
+   */
+  block?: TokenOrValue[] | null;
+
+  /**
+   * The location of the rule in the source file.
+   */
+  loc: Location2;
+
+  /**
+   * The name of the at-rule (without the @).
+   */
+  name: String;
+
+  /**
+   * The prelude of the rule.
+   */
+  prelude: TokenOrValue[];
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/browserslistToTargets.js b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/browserslistToTargets.js
new file mode 100644
index 0000000..fe9b6b4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/browserslistToTargets.js
@@ -0,0 +1,48 @@
+const BROWSER_MAPPING = {
+  and_chr: 'chrome',
+  and_ff: 'firefox',
+  ie_mob: 'ie',
+  op_mob: 'opera',
+  and_qq: null,
+  and_uc: null,
+  baidu: null,
+  bb: null,
+  kaios: null,
+  op_mini: null,
+};
+
+function browserslistToTargets(browserslist) {
+  let targets = {};
+  for (let browser of browserslist) {
+    let [name, v] = browser.split(' ');
+    if (BROWSER_MAPPING[name] === null) {
+      continue;
+    }
+
+    let version = parseVersion(v);
+    if (version == null) {
+      continue;
+    }
+
+    if (targets[name] == null || version < targets[name]) {
+      targets[name] = version;
+    }
+  }
+
+  return targets;
+}
+
+function parseVersion(version) {
+  let [major, minor = 0, patch = 0] = version
+    .split('-')[0]
+    .split('.')
+    .map(v => parseInt(v, 10));
+
+  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+    return null;
+  }
+
+  return (major << 16) | (minor << 8) | patch;
+}
+
+module.exports = browserslistToTargets;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/composeVisitors.js b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/composeVisitors.js
new file mode 100644
index 0000000..f299349
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/composeVisitors.js
@@ -0,0 +1,450 @@
+// @ts-check
+/** @typedef {import('./index').Visitor} Visitor */
+/** @typedef {import('./index').VisitorFunction} VisitorFunction */
+
+/**
+ * Composes multiple visitor objects into a single one.
+ * @param {(Visitor | VisitorFunction)[]} visitors 
+ * @return {Visitor | VisitorFunction}
+ */
+function composeVisitors(visitors) {
+  if (visitors.length === 1) {
+    return visitors[0];
+  }
+  
+  if (visitors.some(v => typeof v === 'function')) {
+    return (opts) => {
+      let v = visitors.map(v => typeof v === 'function' ? v(opts) : v);
+      return composeVisitors(v);
+    };
+  }
+
+  /** @type Visitor */
+  let res = {};
+  composeSimpleVisitors(res, visitors, 'StyleSheet');
+  composeSimpleVisitors(res, visitors, 'StyleSheetExit');
+  composeObjectVisitors(res, visitors, 'Rule', ruleVisitor, wrapCustomAndUnknownAtRule);
+  composeObjectVisitors(res, visitors, 'RuleExit', ruleVisitor, wrapCustomAndUnknownAtRule);
+  composeObjectVisitors(res, visitors, 'Declaration', declarationVisitor, wrapCustomProperty);
+  composeObjectVisitors(res, visitors, 'DeclarationExit', declarationVisitor, wrapCustomProperty);
+  composeSimpleVisitors(res, visitors, 'Url');
+  composeSimpleVisitors(res, visitors, 'Color');
+  composeSimpleVisitors(res, visitors, 'Image');
+  composeSimpleVisitors(res, visitors, 'ImageExit');
+  composeSimpleVisitors(res, visitors, 'Length');
+  composeSimpleVisitors(res, visitors, 'Angle');
+  composeSimpleVisitors(res, visitors, 'Ratio');
+  composeSimpleVisitors(res, visitors, 'Resolution');
+  composeSimpleVisitors(res, visitors, 'Time');
+  composeSimpleVisitors(res, visitors, 'CustomIdent');
+  composeSimpleVisitors(res, visitors, 'DashedIdent');
+  composeArrayFunctions(res, visitors, 'MediaQuery');
+  composeArrayFunctions(res, visitors, 'MediaQueryExit');
+  composeSimpleVisitors(res, visitors, 'SupportsCondition');
+  composeSimpleVisitors(res, visitors, 'SupportsConditionExit');
+  composeArrayFunctions(res, visitors, 'Selector');
+  composeTokenVisitors(res, visitors, 'Token', 'token', false);
+  composeTokenVisitors(res, visitors, 'Function', 'function', false);
+  composeTokenVisitors(res, visitors, 'FunctionExit', 'function', true);
+  composeTokenVisitors(res, visitors, 'Variable', 'var', false);
+  composeTokenVisitors(res, visitors, 'VariableExit', 'var', true);
+  composeTokenVisitors(res, visitors, 'EnvironmentVariable', 'env', false);
+  composeTokenVisitors(res, visitors, 'EnvironmentVariableExit', 'env', true);
+  return res;
+}
+
+module.exports = composeVisitors;
+
+function wrapCustomAndUnknownAtRule(k, f) {
+  if (k === 'unknown') {
+    return (value => f({ type: 'unknown', value }));
+  }
+  if (k === 'custom') {
+    return (value => f({ type: 'custom', value }));
+  }
+  return f;
+}
+
+function wrapCustomProperty(k, f) {
+  return k === 'custom' ? (value => f({ property: 'custom', value })) : f;
+}
+
+/**
+ * @param {import('./index').Visitor['Rule']} f 
+ * @param {import('./ast').Rule} item 
+ */
+function ruleVisitor(f, item) {
+  if (typeof f === 'object') {
+    if (item.type === 'unknown') {
+      let v = f.unknown;
+      if (typeof v === 'object') {
+        v = v[item.value.name];
+      }
+      return v?.(item.value);
+    }
+    if (item.type === 'custom') {
+      let v = f.custom;
+      if (typeof v === 'object') {
+        v = v[item.value.name];
+      }
+      return v?.(item.value);
+    }
+    return f[item.type]?.(item);
+  }
+  return f?.(item);
+}
+
+/**
+ * @param {import('./index').Visitor['Declaration']} f 
+ * @param {import('./ast').Declaration} item 
+ */
+function declarationVisitor(f, item) {
+  if (typeof f === 'object') {
+    /** @type {string} */
+    let name = item.property;
+    if (item.property === 'unparsed') {
+      name = item.value.propertyId.property;
+    } else if (item.property === 'custom') {
+      let v = f.custom;
+      if (typeof v === 'object') {
+        v = v[item.value.name];
+      }
+      return v?.(item.value);
+    }
+    return f[name]?.(item);
+  }
+  return f?.(item);
+}
+
+/**
+ * 
+ * @param {Visitor[]} visitors 
+ * @param {string} key 
+ * @returns {[any[], boolean, Set<string>]}
+ */
+function extractObjectsOrFunctions(visitors, key) {
+  let values = [];
+  let hasFunction = false;
+  let allKeys = new Set();
+  for (let visitor of visitors) {
+    let v = visitor[key];
+    if (v) {
+      if (typeof v === 'function') {
+        hasFunction = true;
+      } else {
+        for (let key in v) {
+          allKeys.add(key);
+        }
+      }
+      values.push(v);
+    }
+  }
+  return [values, hasFunction, allKeys];
+}
+
+/**
+ * @template {keyof Visitor} K
+ * @param {Visitor} res
+ * @param {Visitor[]} visitors
+ * @param {K} key
+ * @param {(visitor: Visitor[K], item: any) => any | any[] | void} apply 
+ * @param {(k: string, f: any) => any} wrapKey 
+ */
+function composeObjectVisitors(res, visitors, key, apply, wrapKey) {
+  let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);
+  if (values.length === 0) {
+    return;
+  }
+
+  if (values.length === 1) {
+    res[key] = values[0];
+    return;
+  }
+
+  let f = createArrayVisitor(visitors, (visitor, item) => apply(visitor[key], item));
+  if (hasFunction) {
+    res[key] = f;
+  } else {
+    /** @type {any} */
+    let v = {};
+    for (let k of allKeys) {
+      v[k] = wrapKey(k, f);
+    }
+    res[key] = v;
+  }
+}
+
+/**
+ * @param {Visitor} res 
+ * @param {Visitor[]} visitors 
+ * @param {string} key 
+ * @param {import('./ast').TokenOrValue['type']} type 
+ * @param {boolean} isExit 
+ */
+function composeTokenVisitors(res, visitors, key, type, isExit) {
+  let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);
+  if (values.length === 0) {
+    return;
+  }
+
+  if (values.length === 1) {
+    res[key] = values[0];
+    return;
+  }
+
+  let f = createTokenVisitor(visitors, type, isExit);
+  if (hasFunction) {
+    res[key] = f;
+  } else {
+    let v = {};
+    for (let key of allKeys) {
+      v[key] = f;
+    }
+    res[key] = v;
+  }
+}
+
+/**
+ * @param {Visitor[]} visitors 
+ * @param {import('./ast').TokenOrValue['type']} type 
+ */
+function createTokenVisitor(visitors, type, isExit) {
+  let v = createArrayVisitor(visitors, (visitor, /** @type {import('./ast').TokenOrValue} */ item) => {
+    let f;
+    switch (item.type) {
+      case 'token':
+        f = visitor.Token;
+        if (typeof f === 'object') {
+          f = f[item.value.type];
+        }
+        break;
+      case 'function':
+        f = isExit ? visitor.FunctionExit : visitor.Function;
+        if (typeof f === 'object') {
+          f = f[item.value.name];
+        }
+        break;
+      case 'var':
+        f = isExit ? visitor.VariableExit : visitor.Variable;
+        break;
+      case 'env':
+        f = isExit ? visitor.EnvironmentVariableExit : visitor.EnvironmentVariable;
+        if (typeof f === 'object') {
+          let name;
+          switch (item.value.name.type) {
+            case 'ua':
+            case 'unknown':
+              name = item.value.name.value;
+              break;
+            case 'custom':
+              name = item.value.name.ident;
+              break;
+          }
+          f = f[name];
+        }
+        break;
+      case 'color':
+        f = visitor.Color;
+        break;
+      case 'url':
+        f = visitor.Url;
+        break;
+      case 'length':
+        f = visitor.Length;
+        break;
+      case 'angle':
+        f = visitor.Angle;
+        break;
+      case 'time':
+        f = visitor.Time;
+        break;
+      case 'resolution':
+        f = visitor.Resolution;
+        break;
+      case 'dashed-ident':
+        f = visitor.DashedIdent;
+        break;
+    }
+
+    if (!f) {
+      return;
+    }
+
+    let res = f(item.value);
+    switch (item.type) {
+      case 'color':
+      case 'url':
+      case 'length':
+      case 'angle':
+      case 'time':
+      case 'resolution':
+      case 'dashed-ident':
+        if (Array.isArray(res)) {
+          res = res.map(value => ({ type: item.type, value }))
+        } else if (res) {
+          res = { type: item.type, value: res };
+        }
+        break;
+    }
+
+    return res;
+  });
+
+  return value => v({ type, value });
+}
+
+/**
+ * @param {Visitor[]} visitors 
+ * @param {string} key 
+ */
+function extractFunctions(visitors, key) {
+  let functions = [];
+  for (let visitor of visitors) {
+    let f = visitor[key];
+    if (f) {
+      functions.push(f);
+    }
+  }
+  return functions;
+}
+
+/**
+ * @param {Visitor} res 
+ * @param {Visitor[]} visitors 
+ * @param {string} key 
+ */
+function composeSimpleVisitors(res, visitors, key) {
+  let functions = extractFunctions(visitors, key);
+  if (functions.length === 0) {
+    return;
+  }
+
+  if (functions.length === 1) {
+    res[key] = functions[0];
+    return;
+  }
+
+  res[key] = arg => {
+    let mutated = false;
+    for (let f of functions) {
+      let res = f(arg);
+      if (res) {
+        arg = res;
+        mutated = true;
+      }
+    }
+
+    return mutated ? arg : undefined;
+  };
+}
+
+/**
+ * @param {Visitor} res 
+ * @param {Visitor[]} visitors 
+ * @param {string} key 
+ */
+function composeArrayFunctions(res, visitors, key) {
+  let functions = extractFunctions(visitors, key);
+  if (functions.length === 0) {
+    return;
+  }
+
+  if (functions.length === 1) {
+    res[key] = functions[0];
+    return;
+  }
+
+  res[key] = createArrayVisitor(functions, (f, item) => f(item));
+}
+
+/**
+ * @template T
+ * @template V
+ * @param {T[]} visitors 
+ * @param {(visitor: T, item: V) => V | V[] | void} apply 
+ * @returns {(item: V) => V | V[] | void}
+ */
+function createArrayVisitor(visitors, apply) {
+  let seen = new Bitset(visitors.length);
+  return arg => {
+    let arr = [arg];
+    let mutated = false;
+    seen.clear();
+    for (let i = 0; i < arr.length; i++) {
+      // For each value, call all visitors. If a visitor returns a new value,
+      // we start over, but skip the visitor that generated the value or saw
+      // it before (to avoid cycles). This way, visitors can be composed in any order. 
+      for (let v = 0; v < visitors.length && i < arr.length;) {
+        if (seen.get(v)) {
+          v++;
+          continue;
+        }
+
+        let item = arr[i];
+        let visitor = visitors[v];
+        let res = apply(visitor, item);
+        if (Array.isArray(res)) {
+          if (res.length === 0) {
+            arr.splice(i, 1);
+          } else if (res.length === 1) {
+            arr[i] = res[0];
+          } else {
+            arr.splice(i, 1, ...res);
+          }
+          mutated = true;
+          seen.set(v);
+          v = 0;
+        } else if (res) {
+          arr[i] = res;
+          mutated = true;
+          seen.set(v);
+          v = 0;
+        } else {
+          v++;
+        }
+      }
+    }
+
+    if (!mutated) {
+      return;
+    }
+
+    return arr.length === 1 ? arr[0] : arr;
+  };
+}
+
+class Bitset {
+  constructor(maxBits = 32) {
+    this.bits = 0;
+    this.more = maxBits > 32 ? new Uint32Array(Math.ceil((maxBits - 32) / 32)) : null;
+  }
+
+  /** @param {number} bit */
+  get(bit) {
+    if (bit >= 32 && this.more) {
+      let i = Math.floor((bit - 32) / 32);
+      let b = bit % 32;
+      return Boolean(this.more[i] & (1 << b));
+    } else {
+      return Boolean(this.bits & (1 << bit));
+    }
+  }
+
+  /** @param {number} bit */
+  set(bit) {
+    if (bit >= 32 && this.more) {
+      let i = Math.floor((bit - 32) / 32);
+      let b = bit % 32;
+      this.more[i] |= 1 << b;
+    } else {
+      this.bits |= 1 << bit;
+    }
+  }
+
+  clear() {
+    this.bits = 0;
+    if (this.more) {
+      this.more.fill(0);
+    }
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/flags.js b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/flags.js
new file mode 100644
index 0000000..a636a20
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/flags.js
@@ -0,0 +1,28 @@
+// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
+
+exports.Features = {
+  Nesting: 1,
+  NotSelectorList: 2,
+  DirSelector: 4,
+  LangSelectorList: 8,
+  IsSelector: 16,
+  TextDecorationThicknessPercent: 32,
+  MediaIntervalSyntax: 64,
+  MediaRangeSyntax: 128,
+  CustomMediaQueries: 256,
+  ClampFunction: 512,
+  ColorFunction: 1024,
+  OklabColors: 2048,
+  LabColors: 4096,
+  P3Colors: 8192,
+  HexAlphaColors: 16384,
+  SpaceSeparatedColorNotation: 32768,
+  FontFamilySystemUi: 65536,
+  DoublePositionGradients: 131072,
+  VendorPrefixes: 262144,
+  LogicalProperties: 524288,
+  LightDark: 1048576,
+  Selectors: 31,
+  MediaQueries: 448,
+  Colors: 1113088,
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.d.ts
new file mode 100644
index 0000000..6d727d7
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.d.ts
@@ -0,0 +1,494 @@
+import type { Angle, CssColor, Rule, CustomProperty, EnvironmentVariable, Function, Image, LengthValue, MediaQuery, Declaration, Ratio, Resolution, Selector, SupportsCondition, Time, Token, TokenOrValue, UnknownAtRule, Url, Variable, StyleRule, DeclarationBlock, ParsedComponent, Multiplier, StyleSheet, Location2 } from './ast';
+import { Targets, Features } from './targets';
+
+export * from './ast';
+
+export { Targets, Features };
+
+export interface TransformOptions<C extends CustomAtRules> {
+  /** The filename being transformed. Used for error messages and source maps. */
+  filename: string,
+  /** The source code to transform. */
+  code: Uint8Array,
+  /** Whether to enable minification. */
+  minify?: boolean,
+  /** Whether to output a source map. */
+  sourceMap?: boolean,
+  /** An input source map to extend. */
+  inputSourceMap?: string,
+  /**
+   * An optional project root path, used as the source root in the output source map.
+   * Also used to generate relative paths for sources used in CSS module hashes.
+   */
+  projectRoot?: string,
+  /** The browser targets for the generated code. */
+  targets?: Targets,
+  /** Features that should always be compiled, even when supported by targets. */
+  include?: number,
+  /** Features that should never be compiled, even when unsupported by targets. */
+  exclude?: number,
+  /** Whether to enable parsing various draft syntax. */
+  drafts?: Drafts,
+  /** Whether to enable various non-standard syntax. */
+  nonStandard?: NonStandard,
+  /** Whether to compile this file as a CSS module. */
+  cssModules?: boolean | CSSModulesConfig,
+  /**
+   * Whether to analyze dependencies (e.g. `@import` and `url()`).
+   * When enabled, `@import` rules are removed, and `url()` dependencies
+   * are replaced with hashed placeholders that can be replaced with the final
+   * urls later (after bundling). Dependencies are returned as part of the result.
+   */
+  analyzeDependencies?: boolean | DependencyOptions,
+  /**
+   * Replaces user action pseudo classes with class names that can be applied from JavaScript.
+   * This is useful for polyfills, for example.
+   */
+  pseudoClasses?: PseudoClasses,
+  /**
+   * A list of class names, ids, and custom identifiers (e.g. @keyframes) that are known
+   * to be unused. These will be removed during minification. Note that these are not
+   * selectors but individual names (without any . or # prefixes).
+   */
+  unusedSymbols?: string[],
+  /**
+   * Whether to ignore invalid rules and declarations rather than erroring.
+   * When enabled, warnings are returned, and the invalid rule or declaration is
+   * omitted from the output code.
+   */
+  errorRecovery?: boolean,
+  /**
+   * An AST visitor object. This allows custom transforms or analysis to be implemented in JavaScript.
+   * Multiple visitors can be composed into one using the `composeVisitors` function.
+   * For optimal performance, visitors should be as specific as possible about what types of values
+   * they care about so that JavaScript has to be called as little as possible.
+   */
+  visitor?: Visitor<C> | VisitorFunction<C>,
+  /**
+   * Defines how to parse custom CSS at-rules. Each at-rule can have a prelude, defined using a CSS
+   * [syntax string](https://drafts.css-houdini.org/css-properties-values-api/#syntax-strings), and
+   * a block body. The body can be a declaration list, rule list, or style block as defined in the
+   * [css spec](https://drafts.csswg.org/css-syntax/#declaration-rule-list).
+   */
+  customAtRules?: C
+}
+
+// This is a hack to make TS still provide autocomplete for `property` vs. just making it `string`.
+type PropertyStart = '-' | '_' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+export type ReturnedDeclaration = Declaration | {
+  /** The property name. */
+  property: `${PropertyStart}${string}`,
+  /** The raw string value for the declaration. */
+  raw: string
+};
+
+export type ReturnedMediaQuery = MediaQuery | {
+  /** The raw string value for the media query. */
+  raw: string
+};
+
+type FindByType<Union, Name> = Union extends { type: Name } ? Union : never;
+export type ReturnedRule = Rule<ReturnedDeclaration, ReturnedMediaQuery>;
+type RequiredValue<Rule> = Rule extends { value: object }
+  ? Rule['value'] extends StyleRule
+  ? Rule & { value: Required<StyleRule> & { declarations: Required<DeclarationBlock> } }
+  : Rule & { value: Required<Rule['value']> }
+  : Rule;
+type RuleVisitor<R = RequiredValue<Rule>> = ((rule: R) => ReturnedRule | ReturnedRule[] | void);
+type MappedRuleVisitors = {
+  [Name in Exclude<Rule['type'], 'unknown' | 'custom'>]?: RuleVisitor<RequiredValue<FindByType<Rule, Name>>>;
+}
+
+type UnknownVisitors<T> = {
+  [name: string]: RuleVisitor<T>
+}
+
+type CustomVisitors<T extends CustomAtRules> = {
+  [Name in keyof T]?: RuleVisitor<CustomAtRule<Name, T[Name]>>
+};
+
+type AnyCustomAtRule<C extends CustomAtRules> = {
+  [Key in keyof C]: CustomAtRule<Key, C[Key]>
+}[keyof C];
+
+type RuleVisitors<C extends CustomAtRules> = MappedRuleVisitors & {
+  unknown?: UnknownVisitors<UnknownAtRule> | Omit<RuleVisitor<UnknownAtRule>, keyof CallableFunction>,
+  custom?: CustomVisitors<C> | Omit<RuleVisitor<AnyCustomAtRule<C>>, keyof CallableFunction>
+};
+
+type PreludeTypes = Exclude<ParsedComponent['type'], 'literal' | 'repeated' | 'token'>;
+type SyntaxString = `<${PreludeTypes}>` | `<${PreludeTypes}>+` | `<${PreludeTypes}>#` | (string & {});
+type ComponentTypes = {
+  [Key in PreludeTypes as `<${Key}>`]: FindByType<ParsedComponent, Key>
+};
+
+type Repetitions = {
+  [Key in PreludeTypes as `<${Key}>+` | `<${Key}>#`]: {
+    type: "repeated",
+    value: {
+      components: FindByType<ParsedComponent, Key>[],
+      multiplier: Multiplier
+    }
+  }
+};
+
+type MappedPrelude = ComponentTypes & Repetitions;
+type MappedBody<P extends CustomAtRuleDefinition['body']> = P extends 'style-block' ? 'rule-list' : P;
+interface CustomAtRule<N, R extends CustomAtRuleDefinition> {
+  name: N,
+  prelude: R['prelude'] extends keyof MappedPrelude ? MappedPrelude[R['prelude']] : ParsedComponent,
+  body: FindByType<CustomAtRuleBody, MappedBody<R['body']>>,
+  loc: Location2
+}
+
+type CustomAtRuleBody = {
+  type: 'declaration-list',
+  value: Required<DeclarationBlock>
+} | {
+  type: 'rule-list',
+  value: RequiredValue<Rule>[]
+};
+
+type FindProperty<Union, Name> = Union extends { property: Name } ? Union : never;
+type DeclarationVisitor<P = Declaration> = ((property: P) => ReturnedDeclaration | ReturnedDeclaration[] | void);
+type MappedDeclarationVisitors = {
+  [Name in Exclude<Declaration['property'], 'unparsed' | 'custom'>]?: DeclarationVisitor<FindProperty<Declaration, Name> | FindProperty<Declaration, 'unparsed'>>;
+}
+
+type CustomPropertyVisitors = {
+  [name: string]: DeclarationVisitor<CustomProperty>
+}
+
+type DeclarationVisitors = MappedDeclarationVisitors & {
+  custom?: CustomPropertyVisitors | DeclarationVisitor<CustomProperty>
+}
+
+interface RawValue {
+  /** A raw string value which will be parsed like CSS. */
+  raw: string
+}
+
+type TokenReturnValue = TokenOrValue | TokenOrValue[] | RawValue | void;
+type TokenVisitor = (token: Token) => TokenReturnValue;
+type VisitableTokenTypes = 'ident' | 'at-keyword' | 'hash' | 'id-hash' | 'string' | 'number' | 'percentage' | 'dimension';
+type TokenVisitors = {
+  [Name in VisitableTokenTypes]?: (token: FindByType<Token, Name>) => TokenReturnValue;
+}
+
+type FunctionVisitor = (fn: Function) => TokenReturnValue;
+type EnvironmentVariableVisitor = (env: EnvironmentVariable) => TokenReturnValue;
+type EnvironmentVariableVisitors = {
+  [name: string]: EnvironmentVariableVisitor
+};
+
+export interface Visitor<C extends CustomAtRules> {
+  StyleSheet?(stylesheet: StyleSheet): StyleSheet<ReturnedDeclaration, ReturnedMediaQuery> | void;
+  StyleSheetExit?(stylesheet: StyleSheet): StyleSheet<ReturnedDeclaration, ReturnedMediaQuery> | void;
+  Rule?: RuleVisitor | RuleVisitors<C>;
+  RuleExit?: RuleVisitor | RuleVisitors<C>;
+  Declaration?: DeclarationVisitor | DeclarationVisitors;
+  DeclarationExit?: DeclarationVisitor | DeclarationVisitors;
+  Url?(url: Url): Url | void;
+  Color?(color: CssColor): CssColor | void;
+  Image?(image: Image): Image | void;
+  ImageExit?(image: Image): Image | void;
+  Length?(length: LengthValue): LengthValue | void;
+  Angle?(angle: Angle): Angle | void;
+  Ratio?(ratio: Ratio): Ratio | void;
+  Resolution?(resolution: Resolution): Resolution | void;
+  Time?(time: Time): Time | void;
+  CustomIdent?(ident: string): string | void;
+  DashedIdent?(ident: string): string | void;
+  MediaQuery?(query: MediaQuery): ReturnedMediaQuery | ReturnedMediaQuery[] | void;
+  MediaQueryExit?(query: MediaQuery): ReturnedMediaQuery | ReturnedMediaQuery[] | void;
+  SupportsCondition?(condition: SupportsCondition): SupportsCondition;
+  SupportsConditionExit?(condition: SupportsCondition): SupportsCondition;
+  Selector?(selector: Selector): Selector | Selector[] | void;
+  Token?: TokenVisitor | TokenVisitors;
+  Function?: FunctionVisitor | { [name: string]: FunctionVisitor };
+  FunctionExit?: FunctionVisitor | { [name: string]: FunctionVisitor };
+  Variable?(variable: Variable): TokenReturnValue;
+  VariableExit?(variable: Variable): TokenReturnValue;
+  EnvironmentVariable?: EnvironmentVariableVisitor | EnvironmentVariableVisitors;
+  EnvironmentVariableExit?: EnvironmentVariableVisitor | EnvironmentVariableVisitors;
+}
+
+export type VisitorDependency = FileDependency | GlobDependency;
+export interface VisitorOptions {
+  addDependency: (dep: VisitorDependency) => void
+}
+
+export type VisitorFunction<C extends CustomAtRules> = (options: VisitorOptions) => Visitor<C>;
+
+export interface CustomAtRules {
+  [name: string]: CustomAtRuleDefinition
+}
+
+export interface CustomAtRuleDefinition {
+  /**
+   * Defines the syntax for a custom at-rule prelude. The value should be a
+   * CSS [syntax string](https://drafts.css-houdini.org/css-properties-values-api/#syntax-strings)
+   * representing the types of values that are accepted. This property may be omitted or
+   * set to null to indicate that no prelude is accepted.
+   */
+  prelude?: SyntaxString | null,
+  /**
+   * Defines the type of body contained within the at-rule block.
+   *   - declaration-list: A CSS declaration list, as in a style rule.
+   *   - rule-list: A list of CSS rules, as supported within a non-nested
+   *       at-rule such as `@media` or `@supports`.
+   *   - style-block: Both a declaration list and rule list, as accepted within
+   *       a nested at-rule within a style rule (e.g. `@media` inside a style rule
+   *       with directly nested declarations).
+   */
+  body?: 'declaration-list' | 'rule-list' | 'style-block' | null
+}
+
+export interface DependencyOptions {
+  /** Whether to preserve `@import` rules rather than removing them. */
+  preserveImports?: boolean
+}
+
+export type BundleOptions<C extends CustomAtRules> = Omit<TransformOptions<C>, 'code'>;
+
+export interface BundleAsyncOptions<C extends CustomAtRules> extends BundleOptions<C> {
+  resolver?: Resolver;
+}
+
+/** Custom resolver to use when loading CSS files. */
+export interface Resolver {
+  /** Read the given file and return its contents as a string. */
+  read?: (file: string) => string | Promise<string>;
+
+  /**
+   * Resolve the given CSS import specifier from the provided originating file to a
+   * path which gets passed to `read()`.
+   */
+  resolve?: (specifier: string, originatingFile: string) => string | Promise<string>;
+}
+
+export interface Drafts {
+  /** Whether to enable @custom-media rules. */
+  customMedia?: boolean
+}
+
+export interface NonStandard {
+  /** Whether to enable the non-standard >>> and /deep/ selector combinators used by Angular and Vue. */
+  deepSelectorCombinator?: boolean
+}
+
+export interface PseudoClasses {
+  hover?: string,
+  active?: string,
+  focus?: string,
+  focusVisible?: string,
+  focusWithin?: string
+}
+
+export interface TransformResult {
+  /** The transformed code. */
+  code: Uint8Array,
+  /** The generated source map, if enabled. */
+  map: Uint8Array | void,
+  /** CSS module exports, if enabled. */
+  exports: CSSModuleExports | void,
+  /** CSS module references, if `dashedIdents` is enabled. */
+  references: CSSModuleReferences,
+  /** `@import` and `url()` dependencies, if enabled. */
+  dependencies: Dependency[] | void,
+  /** Warnings that occurred during compilation. */
+  warnings: Warning[]
+}
+
+export interface Warning {
+  message: string,
+  type: string,
+  value?: any,
+  loc: ErrorLocation
+}
+
+export interface CSSModulesConfig {
+  /** The pattern to use when renaming class names and other identifiers. Default is `[hash]_[local]`. */
+  pattern?: string,
+  /** Whether to rename dashed identifiers, e.g. custom properties. */
+  dashedIdents?: boolean,
+  /** Whether to enable hashing for `@keyframes`. */
+  animation?: boolean,
+  /** Whether to enable hashing for CSS grid identifiers. */
+  grid?: boolean,
+  /** Whether to enable hashing for `@container` names. */
+  container?: boolean,
+  /** Whether to enable hashing for custom identifiers. */
+  customIdents?: boolean,
+  /** Whether to require at least one class or id selector in each rule. */
+  pure?: boolean
+}
+
+export type CSSModuleExports = {
+  /** Maps exported (i.e. original) names to local names. */
+  [name: string]: CSSModuleExport
+};
+
+export interface CSSModuleExport {
+  /** The local (compiled) name for this export. */
+  name: string,
+  /** Whether the export is referenced in this file. */
+  isReferenced: boolean,
+  /** Other names that are composed by this export. */
+  composes: CSSModuleReference[]
+}
+
+export type CSSModuleReferences = {
+  /** Maps placeholder names to references. */
+  [name: string]: DependencyCSSModuleReference,
+};
+
+export type CSSModuleReference = LocalCSSModuleReference | GlobalCSSModuleReference | DependencyCSSModuleReference;
+
+export interface LocalCSSModuleReference {
+  type: 'local',
+  /** The local (compiled) name for the reference. */
+  name: string,
+}
+
+export interface GlobalCSSModuleReference {
+  type: 'global',
+  /** The referenced global name. */
+  name: string,
+}
+
+export interface DependencyCSSModuleReference {
+  type: 'dependency',
+  /** The name to reference within the dependency. */
+  name: string,
+  /** The dependency specifier for the referenced file. */
+  specifier: string
+}
+
+export type Dependency = ImportDependency | UrlDependency | FileDependency | GlobDependency;
+
+export interface ImportDependency {
+  type: 'import',
+  /** The url of the `@import` dependency. */
+  url: string,
+  /** The media query for the `@import` rule. */
+  media: string | null,
+  /** The `supports()` query for the `@import` rule. */
+  supports: string | null,
+  /** The source location where the `@import` rule was found. */
+  loc: SourceLocation,
+  /** The placeholder that the import was replaced with. */
+  placeholder: string
+}
+
+export interface UrlDependency {
+  type: 'url',
+  /** The url of the dependency. */
+  url: string,
+  /** The source location where the `url()` was found. */
+  loc: SourceLocation,
+  /** The placeholder that the url was replaced with. */
+  placeholder: string
+}
+
+export interface FileDependency {
+  type: 'file',
+  filePath: string
+}
+
+export interface GlobDependency {
+  type: 'glob',
+  glob: string
+}
+
+export interface SourceLocation {
+  /** The file path in which the dependency exists. */
+  filePath: string,
+  /** The start location of the dependency. */
+  start: Location,
+  /** The end location (inclusive) of the dependency. */
+  end: Location
+}
+
+export interface Location {
+  /** The line number (1-based). */
+  line: number,
+  /** The column number (0-based). */
+  column: number
+}
+
+export interface ErrorLocation extends Location {
+  filename: string
+}
+
+/**
+ * Compiles a CSS file, including optionally minifying and lowering syntax to the given
+ * targets. A source map may also be generated, but this is not enabled by default.
+ */
+export declare function transform<C extends CustomAtRules>(options: TransformOptions<C>): TransformResult;
+
+export interface TransformAttributeOptions {
+  /** The filename in which the style attribute appeared. Used for error messages and dependencies. */
+  filename?: string,
+  /** The source code to transform. */
+  code: Uint8Array,
+  /** Whether to enable minification. */
+  minify?: boolean,
+  /** The browser targets for the generated code. */
+  targets?: Targets,
+  /**
+   * Whether to analyze `url()` dependencies.
+   * When enabled, `url()` dependencies are replaced with hashed placeholders
+   * that can be replaced with the final urls later (after bundling).
+   * Dependencies are returned as part of the result.
+   */
+  analyzeDependencies?: boolean,
+  /**
+   * Whether to ignore invalid rules and declarations rather than erroring.
+   * When enabled, warnings are returned, and the invalid rule or declaration is
+   * omitted from the output code.
+   */
+  errorRecovery?: boolean,
+  /**
+   * An AST visitor object. This allows custom transforms or analysis to be implemented in JavaScript.
+   * Multiple visitors can be composed into one using the `composeVisitors` function.
+   * For optimal performance, visitors should be as specific as possible about what types of values
+   * they care about so that JavaScript has to be called as little as possible.
+   */
+  visitor?: Visitor<never> | VisitorFunction<never>
+}
+
+export interface TransformAttributeResult {
+  /** The transformed code. */
+  code: Uint8Array,
+  /** `@import` and `url()` dependencies, if enabled. */
+  dependencies: Dependency[] | void,
+  /** Warnings that occurred during compilation. */
+  warnings: Warning[]
+}
+
+/**
+ * Compiles a single CSS declaration list, such as an inline style attribute in HTML.
+ */
+export declare function transformStyleAttribute(options: TransformAttributeOptions): TransformAttributeResult;
+
+/**
+ * Converts a browserslist result into targets that can be passed to lightningcss.
+ * @param browserslist the result of calling `browserslist`
+ */
+export declare function browserslistToTargets(browserslist: string[]): Targets;
+
+/**
+ * Bundles a CSS file and its dependencies, inlining @import rules.
+ */
+export declare function bundle<C extends CustomAtRules>(options: BundleOptions<C>): TransformResult;
+
+/**
+ * Bundles a CSS file and its dependencies asynchronously, inlining @import rules.
+ */
+export declare function bundleAsync<C extends CustomAtRules>(options: BundleAsyncOptions<C>): Promise<TransformResult>;
+
+/**
+ * Composes multiple visitor objects into a single one.
+ */
+export declare function composeVisitors<C extends CustomAtRules>(visitors: (Visitor<C> | VisitorFunction<C>)[]): Visitor<C> | VisitorFunction<C>;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.js b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.js
new file mode 100644
index 0000000..6fe25ae
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.js
@@ -0,0 +1,59 @@
+let parts = [process.platform, process.arch];
+if (process.platform === 'linux') {
+  const { MUSL, familySync } = require('detect-libc');
+  const family = familySync();
+  if (family === MUSL) {
+    parts.push('musl');
+  } else if (process.arch === 'arm') {
+    parts.push('gnueabihf');
+  } else {
+    parts.push('gnu');
+  }
+} else if (process.platform === 'win32') {
+  parts.push('msvc');
+}
+
+let native;
+try {
+  native = require(`lightningcss-${parts.join('-')}`);
+} catch (err) {
+  native = require(`../lightningcss.${parts.join('-')}.node`);
+}
+
+module.exports.transform = wrap(native.transform);
+module.exports.transformStyleAttribute = wrap(native.transformStyleAttribute);
+module.exports.bundle = wrap(native.bundle);
+module.exports.bundleAsync = wrap(native.bundleAsync);
+module.exports.browserslistToTargets = require('./browserslistToTargets');
+module.exports.composeVisitors = require('./composeVisitors');
+module.exports.Features = require('./flags').Features;
+
+function wrap(call) {
+  return (options) => {
+    if (typeof options.visitor === 'function') {
+      let deps = [];
+      options.visitor = options.visitor({
+        addDependency(dep) {
+          deps.push(dep);
+        }
+      });
+
+      let result = call(options);
+      if (result instanceof Promise) {
+        result = result.then(res => {
+          if (deps.length) {
+            res.dependencies ??= [];
+            res.dependencies.push(...deps);
+          }
+          return res;
+        });
+      } else if (deps.length) {
+        result.dependencies ??= [];
+        result.dependencies.push(...deps);
+      }
+      return result;
+    } else {
+      return call(options);
+    }
+  };
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.js.flow b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.js.flow
new file mode 100644
index 0000000..0d14ea7
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.js.flow
@@ -0,0 +1,843 @@
+// @flow
+
+type Exclude<A, B> = A;
+// see https://gist.github.com/thecotne/6e5969f4aaf8f253985ed36b30ac9fe0
+type $FlowGen$If<X: boolean, Then, Else = empty> = $Call<
+  ((true, Then, Else) => Then) & ((false, Then, Else) => Else),
+  X,
+  Then,
+  Else
+>;
+
+type $FlowGen$Assignable<A, B> = $Call<
+  ((...r: [B]) => true) & ((...r: [A]) => false),
+  A
+>;
+
+import type {
+  Angle,
+  CssColor,
+  Rule,
+  CustomProperty,
+  EnvironmentVariable,
+  Function,
+  Image,
+  LengthValue,
+  MediaQuery,
+  Declaration,
+  Ratio,
+  Resolution,
+  Selector,
+  SupportsCondition,
+  Time,
+  Token,
+  TokenOrValue,
+  UnknownAtRule,
+  Url,
+  Variable,
+  StyleRule,
+  DeclarationBlock,
+  ParsedComponent,
+  Multiplier,
+  StyleSheet,
+  Location2,
+} from "./ast.js.flow";
+import { Targets, Features } from "./targets.js.flow";
+declare export * from "./ast.js.flow";
+declare export { Targets, Features };
+export type TransformOptions<C: CustomAtRules> = {|
+  /**
+   * The filename being transformed. Used for error messages and source maps.
+   */
+  filename: string,
+
+  /**
+   * The source code to transform.
+   */
+  code: Uint8Array,
+
+  /**
+   * Whether to enable minification.
+   */
+  minify?: boolean,
+
+  /**
+   * Whether to output a source map.
+   */
+  sourceMap?: boolean,
+
+  /**
+   * An input source map to extend.
+   */
+  inputSourceMap?: string,
+
+  /**
+   * An optional project root path, used as the source root in the output source map.
+   * Also used to generate relative paths for sources used in CSS module hashes.
+   */
+  projectRoot?: string,
+
+  /**
+   * The browser targets for the generated code.
+   */
+  targets?: Targets,
+
+  /**
+   * Features that should always be compiled, even when supported by targets.
+   */
+  include?: number,
+
+  /**
+   * Features that should never be compiled, even when unsupported by targets.
+   */
+  exclude?: number,
+
+  /**
+   * Whether to enable parsing various draft syntax.
+   */
+  drafts?: Drafts,
+
+  /**
+   * Whether to enable various non-standard syntax.
+   */
+  nonStandard?: NonStandard,
+
+  /**
+   * Whether to compile this file as a CSS module.
+   */
+  cssModules?: boolean | CSSModulesConfig,
+
+  /**
+   * Whether to analyze dependencies (e.g. string).
+   * When enabled, string dependencies
+   * are replaced with hashed placeholders that can be replaced with the final
+   * urls later (after bundling). Dependencies are returned as part of the result.
+   */
+  analyzeDependencies?: boolean | DependencyOptions,
+
+  /**
+   * Replaces user action pseudo classes with class names that can be applied from JavaScript.
+   * This is useful for polyfills, for example.
+   */
+  pseudoClasses?: PseudoClasses,
+
+  /**
+   * A list of class names, ids, and custom identifiers (e.g. @keyframes) that are known
+   * to be unused. These will be removed during minification. Note that these are not
+   * selectors but individual names (without any . or # prefixes).
+   */
+  unusedSymbols?: string[],
+
+  /**
+   * Whether to ignore invalid rules and declarations rather than erroring.
+   * When enabled, warnings are returned, and the invalid rule or declaration is
+   * omitted from the output code.
+   */
+  errorRecovery?: boolean,
+
+  /**
+   * An AST visitor object. This allows custom transforms or analysis to be implemented in JavaScript.
+   * Multiple visitors can be composed into one using the string function.
+   * For optimal performance, visitors should be as specific as possible about what types of values
+   * they care about so that JavaScript has to be called as little as possible.
+   */
+  visitor?: Visitor<C> | VisitorFunction<C>,
+
+  /**
+   * Defines how to parse custom CSS at-rules. Each at-rule can have a prelude, defined using a CSS
+   * [syntax string](https://drafts.css-houdini.org/css-properties-values-api/#syntax-strings), and
+   * a block body. The body can be a declaration list, rule list, or style block as defined in the
+   * [css spec](https://drafts.csswg.org/css-syntax/#declaration-rule-list).
+   */
+  customAtRules?: C,
+|};
+declare type PropertyStart =
+  | "-"
+  | "_"
+  | "a"
+  | "b"
+  | "c"
+  | "d"
+  | "e"
+  | "f"
+  | "g"
+  | "h"
+  | "i"
+  | "j"
+  | "k"
+  | "l"
+  | "m"
+  | "n"
+  | "o"
+  | "p"
+  | "q"
+  | "r"
+  | "s"
+  | "t"
+  | "u"
+  | "v"
+  | "w"
+  | "x"
+  | "y"
+  | "z";
+export type ReturnedDeclaration =
+  | Declaration
+  | {|
+      /**
+       * The property name.
+       */
+      property: string,
+
+      /**
+       * The raw string value for the declaration.
+       */
+      raw: string,
+    |};
+export type ReturnedMediaQuery =
+  | MediaQuery
+  | {|
+      /**
+       * The raw string value for the media query.
+       */
+      raw: string,
+    |};
+declare type FindByType<Union, Name> = $FlowGen$If<
+  $FlowGen$Assignable<
+    Union,
+    {|
+      type: Name,
+    |}
+  >,
+  Union,
+  empty
+>;
+export type ReturnedRule = Rule<ReturnedDeclaration, ReturnedMediaQuery>;
+declare type RequiredValue<Rule> = $FlowGen$If<
+  $FlowGen$Assignable<
+    Rule,
+    {|
+      value: { [key: string]: any },
+    |}
+  >,
+  $FlowGen$If<
+    $FlowGen$Assignable<$PropertyType<Rule, "value">, StyleRule>,
+    {|
+      ...Rule,
+      ...{|
+        value: {|
+          ...Required<StyleRule>,
+          ...{|
+            declarations: Required<DeclarationBlock>,
+          |},
+        |},
+      |},
+    |},
+    {|
+      ...Rule,
+      ...{|
+        value: Required<$PropertyType<Rule, "value">>,
+      |},
+    |}
+  >,
+  Rule
+>;
+declare type RuleVisitor<R = RequiredValue<Rule>> = (
+  rule: R
+) => ReturnedRule | ReturnedRule[] | void;
+declare type MappedRuleVisitors = $ObjMapi<
+  { [k: Exclude<$PropertyType<Rule, "type">, "unknown" | "custom">]: any },
+  <Name>(Name) => RuleVisitor<RequiredValue<FindByType<Rule, Name>>>
+>;
+declare type UnknownVisitors<T> = {
+  [name: string]: RuleVisitor<T>,
+};
+declare type CustomVisitors<T: CustomAtRules> = $ObjMapi<
+  T,
+  <Name>(Name) => RuleVisitor<CustomAtRule<Name, $ElementType<T, Name>>>
+>;
+declare type AnyCustomAtRule<C: CustomAtRules> = $ElementType<
+  $ObjMapi<C, <Key>(Key) => CustomAtRule<Key, $ElementType<C, Key>>>,
+  $Keys<C>
+>;
+declare type RuleVisitors<C: CustomAtRules> = {|
+  ...MappedRuleVisitors,
+  ...{|
+    unknown?:
+      | UnknownVisitors<UnknownAtRule>
+      | $Diff<
+          RuleVisitor<UnknownAtRule>,
+          { [key: $Keys<CallableFunction>]: any }
+        >,
+    custom?:
+      | CustomVisitors<C>
+      | $Diff<
+          RuleVisitor<AnyCustomAtRule<C>>,
+          { [key: $Keys<CallableFunction>]: any }
+        >,
+  |},
+|};
+declare type PreludeTypes = Exclude<
+  $PropertyType<ParsedComponent, "type">,
+  "literal" | "repeated" | "token"
+>;
+declare type SyntaxString = string | string;
+declare type ComponentTypes = $ObjMapi<
+  { [k: PreludeTypes]: any },
+  <Key>(Key) => FindByType<ParsedComponent, Key>
+>;
+declare type Repetitions = $ObjMapi<
+  { [k: PreludeTypes]: any },
+  <Key>(Key) => {|
+    type: "repeated",
+    value: {|
+      components: FindByType<ParsedComponent, Key>[],
+      multiplier: Multiplier,
+    |},
+  |}
+>;
+declare type MappedPrelude = {| ...ComponentTypes, ...Repetitions |};
+declare type MappedBody<P: $PropertyType<CustomAtRuleDefinition, "body">> =
+  $FlowGen$If<$FlowGen$Assignable<P, "style-block">, "rule-list", P>;
+declare type CustomAtRule<N, R: CustomAtRuleDefinition> = {|
+  name: N,
+  prelude: $FlowGen$If<
+    $FlowGen$Assignable<$PropertyType<R, "prelude">, $Keys<MappedPrelude>>,
+    $ElementType<MappedPrelude, $PropertyType<R, "prelude">>,
+    ParsedComponent
+  >,
+  body: FindByType<CustomAtRuleBody, MappedBody<$PropertyType<R, "body">>>,
+  loc: Location2,
+|};
+declare type CustomAtRuleBody =
+  | {|
+      type: "declaration-list",
+      value: Required<DeclarationBlock>,
+    |}
+  | {|
+      type: "rule-list",
+      value: RequiredValue<Rule>[],
+    |};
+declare type FindProperty<Union, Name> = $FlowGen$If<
+  $FlowGen$Assignable<
+    Union,
+    {|
+      property: Name,
+    |}
+  >,
+  Union,
+  empty
+>;
+declare type DeclarationVisitor<P = Declaration> = (
+  property: P
+) => ReturnedDeclaration | ReturnedDeclaration[] | void;
+declare type MappedDeclarationVisitors = $ObjMapi<
+  {
+    [k: Exclude<
+      $PropertyType<Declaration, "property">,
+      "unparsed" | "custom"
+    >]: any,
+  },
+  <Name>(
+    Name
+  ) => DeclarationVisitor<
+    FindProperty<Declaration, Name> | FindProperty<Declaration, "unparsed">
+  >
+>;
+declare type CustomPropertyVisitors = {
+  [name: string]: DeclarationVisitor<CustomProperty>,
+};
+declare type DeclarationVisitors = {|
+  ...MappedDeclarationVisitors,
+  ...{|
+    custom?: CustomPropertyVisitors | DeclarationVisitor<CustomProperty>,
+  |},
+|};
+declare type RawValue = {|
+  /**
+   * A raw string value which will be parsed like CSS.
+   */
+  raw: string,
+|};
+declare type TokenReturnValue = TokenOrValue | TokenOrValue[] | RawValue | void;
+declare type TokenVisitor = (token: Token) => TokenReturnValue;
+declare type VisitableTokenTypes =
+  | "ident"
+  | "at-keyword"
+  | "hash"
+  | "id-hash"
+  | "string"
+  | "number"
+  | "percentage"
+  | "dimension";
+declare type TokenVisitors = $ObjMapi<
+  { [k: VisitableTokenTypes]: any },
+  <Name>(Name) => (token: FindByType<Token, Name>) => TokenReturnValue
+>;
+declare type FunctionVisitor = (fn: Function) => TokenReturnValue;
+declare type EnvironmentVariableVisitor = (
+  env: EnvironmentVariable
+) => TokenReturnValue;
+declare type EnvironmentVariableVisitors = {
+  [name: string]: EnvironmentVariableVisitor,
+};
+export type Visitor<C: CustomAtRules> = {|
+  StyleSheet?: (
+    stylesheet: StyleSheet
+  ) => StyleSheet<ReturnedDeclaration, ReturnedMediaQuery> | void,
+  StyleSheetExit?: (
+    stylesheet: StyleSheet
+  ) => StyleSheet<ReturnedDeclaration, ReturnedMediaQuery> | void,
+  Rule?: RuleVisitor<> | RuleVisitors<C>,
+  RuleExit?: RuleVisitor<> | RuleVisitors<C>,
+  Declaration?: DeclarationVisitor<> | DeclarationVisitors,
+  DeclarationExit?: DeclarationVisitor<> | DeclarationVisitors,
+  Url?: (url: Url) => Url | void,
+  Color?: (color: CssColor) => CssColor | void,
+  Image?: (image: Image) => Image | void,
+  ImageExit?: (image: Image) => Image | void,
+  Length?: (length: LengthValue) => LengthValue | void,
+  Angle?: (angle: Angle) => Angle | void,
+  Ratio?: (ratio: Ratio) => Ratio | void,
+  Resolution?: (resolution: Resolution) => Resolution | void,
+  Time?: (time: Time) => Time | void,
+  CustomIdent?: (ident: string) => string | void,
+  DashedIdent?: (ident: string) => string | void,
+  MediaQuery?: (
+    query: MediaQuery
+  ) => ReturnedMediaQuery | ReturnedMediaQuery[] | void,
+  MediaQueryExit?: (
+    query: MediaQuery
+  ) => ReturnedMediaQuery | ReturnedMediaQuery[] | void,
+  SupportsCondition?: (condition: SupportsCondition) => SupportsCondition,
+  SupportsConditionExit?: (condition: SupportsCondition) => SupportsCondition,
+  Selector?: (selector: Selector) => Selector | Selector[] | void,
+  Token?: TokenVisitor | TokenVisitors,
+  Function?:
+    | FunctionVisitor
+    | {
+        [name: string]: FunctionVisitor,
+      },
+  FunctionExit?:
+    | FunctionVisitor
+    | {
+        [name: string]: FunctionVisitor,
+      },
+  Variable?: (variable: Variable) => TokenReturnValue,
+  VariableExit?: (variable: Variable) => TokenReturnValue,
+  EnvironmentVariable?:
+    | EnvironmentVariableVisitor
+    | EnvironmentVariableVisitors,
+  EnvironmentVariableExit?:
+    | EnvironmentVariableVisitor
+    | EnvironmentVariableVisitors,
+|};
+export type VisitorDependency = FileDependency | GlobDependency;
+export type VisitorOptions = {|
+  addDependency: (dep: VisitorDependency) => void,
+|};
+export type VisitorFunction<C: CustomAtRules> = (
+  options: VisitorOptions
+) => Visitor<C>;
+export type CustomAtRules = {|
+  [name: string]: CustomAtRuleDefinition,
+|};
+export type CustomAtRuleDefinition = {|
+  /**
+   * Defines the syntax for a custom at-rule prelude. The value should be a
+   * CSS [syntax string](https://drafts.css-houdini.org/css-properties-values-api/#syntax-strings)
+   * representing the types of values that are accepted. This property may be omitted or
+   * set to null to indicate that no prelude is accepted.
+   */
+  prelude?: SyntaxString | null,
+
+  /**
+   * Defines the type of body contained within the at-rule block.
+   *   - declaration-list: A CSS declaration list, as in a style rule.
+   *   - rule-list: A list of CSS rules, as supported within a non-nested
+   *       at-rule such as string.
+   *   - style-block: Both a declaration list and rule list, as accepted within
+   *       a nested at-rule within a style rule (e.g. string inside a style rule
+   *       with directly nested declarations).
+   */
+  body?: "declaration-list" | "rule-list" | "style-block" | null,
+|};
+export type DependencyOptions = {|
+  /**
+   * Whether to preserve string rules rather than removing them.
+   */
+  preserveImports?: boolean,
+|};
+export type BundleOptions<C: CustomAtRules> = $Diff<
+  TransformOptions<C>,
+  {| code: any |}
+>;
+export type BundleAsyncOptions<C: CustomAtRules> = {|
+  ...$Exact<BundleOptions<C>>,
+
+  resolver?: Resolver,
+|};
+
+/**
+ * Custom resolver to use when loading CSS files.
+ */
+export type Resolver = {|
+  /**
+   * Read the given file and return its contents as a string.
+   */
+  read?: (file: string) => string | Promise<string>,
+
+  /**
+   * Resolve the given CSS import specifier from the provided originating file to a
+   * path which gets passed to string.
+   */
+  resolve?: (
+    specifier: string,
+    originatingFile: string
+  ) => string | Promise<string>,
+|};
+export type Drafts = {|
+  /**
+   * Whether to enable @custom-media rules.
+   */
+  customMedia?: boolean,
+|};
+export type NonStandard = {|
+  /**
+   * Whether to enable the non-standard >>> and /deep/ selector combinators used by Angular and Vue.
+   */
+  deepSelectorCombinator?: boolean,
+|};
+export type PseudoClasses = {|
+  hover?: string,
+  active?: string,
+  focus?: string,
+  focusVisible?: string,
+  focusWithin?: string,
+|};
+export type TransformResult = {|
+  /**
+   * The transformed code.
+   */
+  code: Uint8Array,
+
+  /**
+   * The generated source map, if enabled.
+   */
+  map: Uint8Array | void,
+
+  /**
+   * CSS module exports, if enabled.
+   */
+  exports: CSSModuleExports | void,
+
+  /**
+   * CSS module references, if string is enabled.
+   */
+  references: CSSModuleReferences,
+
+  /**
+   * string dependencies, if enabled.
+   */
+  dependencies: Dependency[] | void,
+
+  /**
+   * Warnings that occurred during compilation.
+   */
+  warnings: Warning[],
+|};
+export type Warning = {|
+  message: string,
+  type: string,
+  value?: any,
+  loc: ErrorLocation,
+|};
+export type CSSModulesConfig = {|
+  /**
+   * The pattern to use when renaming class names and other identifiers. Default is string.
+   */
+  pattern?: string,
+
+  /**
+   * Whether to rename dashed identifiers, e.g. custom properties.
+   */
+  dashedIdents?: boolean,
+
+  /**
+   * Whether to enable hashing for string.
+   */
+  animation?: boolean,
+
+  /**
+   * Whether to enable hashing for CSS grid identifiers.
+   */
+  grid?: boolean,
+
+  /**
+   * Whether to enable hashing for string names.
+   */
+  container?: boolean,
+
+  /**
+   * Whether to enable hashing for custom identifiers.
+   */
+  customIdents?: boolean,
+
+  /**
+   * Whether to require at least one class or id selector in each rule.
+   */
+  pure?: boolean,
+|};
+export type CSSModuleExports = {
+  /**
+   * Maps exported (i.e. original) names to local names.
+   */
+  [name: string]: CSSModuleExport,
+};
+export type CSSModuleExport = {|
+  /**
+   * The local (compiled) name for this export.
+   */
+  name: string,
+
+  /**
+   * Whether the export is referenced in this file.
+   */
+  isReferenced: boolean,
+
+  /**
+   * Other names that are composed by this export.
+   */
+  composes: CSSModuleReference[],
+|};
+export type CSSModuleReferences = {
+  /**
+   * Maps placeholder names to references.
+   */
+  [name: string]: DependencyCSSModuleReference,
+};
+export type CSSModuleReference =
+  | LocalCSSModuleReference
+  | GlobalCSSModuleReference
+  | DependencyCSSModuleReference;
+export type LocalCSSModuleReference = {|
+  type: "local",
+
+  /**
+   * The local (compiled) name for the reference.
+   */
+  name: string,
+|};
+export type GlobalCSSModuleReference = {|
+  type: "global",
+
+  /**
+   * The referenced global name.
+   */
+  name: string,
+|};
+export type DependencyCSSModuleReference = {|
+  type: "dependency",
+
+  /**
+   * The name to reference within the dependency.
+   */
+  name: string,
+
+  /**
+   * The dependency specifier for the referenced file.
+   */
+  specifier: string,
+|};
+export type Dependency =
+  | ImportDependency
+  | UrlDependency
+  | FileDependency
+  | GlobDependency;
+export type ImportDependency = {|
+  type: "import",
+
+  /**
+   * The url of the string dependency.
+   */
+  url: string,
+
+  /**
+   * The media query for the string rule.
+   */
+  media: string | null,
+
+  /**
+   * The string rule.
+   */
+  supports: string | null,
+
+  /**
+   * The source location where the string rule was found.
+   */
+  loc: SourceLocation,
+
+  /**
+   * The placeholder that the import was replaced with.
+   */
+  placeholder: string,
+|};
+export type UrlDependency = {|
+  type: "url",
+
+  /**
+   * The url of the dependency.
+   */
+  url: string,
+
+  /**
+   * The source location where the string was found.
+   */
+  loc: SourceLocation,
+
+  /**
+   * The placeholder that the url was replaced with.
+   */
+  placeholder: string,
+|};
+export type FileDependency = {|
+  type: "file",
+  filePath: string,
+|};
+export type GlobDependency = {|
+  type: "glob",
+  glob: string,
+|};
+export type SourceLocation = {|
+  /**
+   * The file path in which the dependency exists.
+   */
+  filePath: string,
+
+  /**
+   * The start location of the dependency.
+   */
+  start: Location,
+
+  /**
+   * The end location (inclusive) of the dependency.
+   */
+  end: Location,
+|};
+export type Location = {|
+  /**
+   * The line number (1-based).
+   */
+  line: number,
+
+  /**
+   * The column number (0-based).
+   */
+  column: number,
+|};
+export type ErrorLocation = {|
+  ...$Exact<Location>,
+
+  filename: string,
+|};
+
+/**
+ * Compiles a CSS file, including optionally minifying and lowering syntax to the given
+ * targets. A source map may also be generated, but this is not enabled by default.
+ */
+declare export function transform<C: CustomAtRules>(
+  options: TransformOptions<C>
+): TransformResult;
+export type TransformAttributeOptions = {|
+  /**
+   * The filename in which the style attribute appeared. Used for error messages and dependencies.
+   */
+  filename?: string,
+
+  /**
+   * The source code to transform.
+   */
+  code: Uint8Array,
+
+  /**
+   * Whether to enable minification.
+   */
+  minify?: boolean,
+
+  /**
+   * The browser targets for the generated code.
+   */
+  targets?: Targets,
+
+  /**
+   * Whether to analyze string dependencies.
+   * When enabled, string dependencies are replaced with hashed placeholders
+   * that can be replaced with the final urls later (after bundling).
+   * Dependencies are returned as part of the result.
+   */
+  analyzeDependencies?: boolean,
+
+  /**
+   * Whether to ignore invalid rules and declarations rather than erroring.
+   * When enabled, warnings are returned, and the invalid rule or declaration is
+   * omitted from the output code.
+   */
+  errorRecovery?: boolean,
+
+  /**
+   * An AST visitor object. This allows custom transforms or analysis to be implemented in JavaScript.
+   * Multiple visitors can be composed into one using the string function.
+   * For optimal performance, visitors should be as specific as possible about what types of values
+   * they care about so that JavaScript has to be called as little as possible.
+   */
+  visitor?: Visitor<empty> | VisitorFunction<empty>,
+|};
+export type TransformAttributeResult = {|
+  /**
+   * The transformed code.
+   */
+  code: Uint8Array,
+
+  /**
+   * string dependencies, if enabled.
+   */
+  dependencies: Dependency[] | void,
+
+  /**
+   * Warnings that occurred during compilation.
+   */
+  warnings: Warning[],
+|};
+
+/**
+ * Compiles a single CSS declaration list, such as an inline style attribute in HTML.
+ */
+declare export function transformStyleAttribute(
+  options: TransformAttributeOptions
+): TransformAttributeResult;
+
+/**
+ * Converts a browserslist result into targets that can be passed to lightningcss.
+ * @param browserslist the result of calling string
+ */
+declare export function browserslistToTargets(browserslist: string[]): Targets;
+
+/**
+ * Bundles a CSS file and its dependencies, inlining @import rules.
+ */
+declare export function bundle<C: CustomAtRules>(
+  options: BundleOptions<C>
+): TransformResult;
+
+/**
+ * Bundles a CSS file and its dependencies asynchronously, inlining @import rules.
+ */
+declare export function bundleAsync<C: CustomAtRules>(
+  options: BundleAsyncOptions<C>
+): Promise<TransformResult>;
+
+/**
+ * Composes multiple visitor objects into a single one.
+ */
+declare export function composeVisitors<C: CustomAtRules>(
+  visitors: (Visitor<C> | VisitorFunction<C>)[]
+): Visitor<C> | VisitorFunction<C>;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.mjs
new file mode 100644
index 0000000..a1ff934
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/index.mjs
@@ -0,0 +1,4 @@
+import index from './index.js';
+
+const { transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features } = index;
+export { transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/targets.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/targets.d.ts
new file mode 100644
index 0000000..ccc7c95
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/targets.d.ts
@@ -0,0 +1,40 @@
+// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
+
+export interface Targets {
+  android?: number,
+  chrome?: number,
+  edge?: number,
+  firefox?: number,
+  ie?: number,
+  ios_saf?: number,
+  opera?: number,
+  safari?: number,
+  samsung?: number
+}
+
+export const Features: {
+  Nesting: 1,
+  NotSelectorList: 2,
+  DirSelector: 4,
+  LangSelectorList: 8,
+  IsSelector: 16,
+  TextDecorationThicknessPercent: 32,
+  MediaIntervalSyntax: 64,
+  MediaRangeSyntax: 128,
+  CustomMediaQueries: 256,
+  ClampFunction: 512,
+  ColorFunction: 1024,
+  OklabColors: 2048,
+  LabColors: 4096,
+  P3Colors: 8192,
+  HexAlphaColors: 16384,
+  SpaceSeparatedColorNotation: 32768,
+  FontFamilySystemUi: 65536,
+  DoublePositionGradients: 131072,
+  VendorPrefixes: 262144,
+  LogicalProperties: 524288,
+  LightDark: 1048576,
+  Selectors: 31,
+  MediaQueries: 448,
+  Colors: 1113088,
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/targets.js.flow b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/targets.js.flow
new file mode 100644
index 0000000..71ce5dc
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/node/targets.js.flow
@@ -0,0 +1,39 @@
+// @flow
+
+export interface Targets {
+  android?: number;
+  chrome?: number;
+  edge?: number;
+  firefox?: number;
+  ie?: number;
+  ios_saf?: number;
+  opera?: number;
+  safari?: number;
+  samsung?: number;
+}
+declare export var Features: {|
+  Nesting: 1,
+  NotSelectorList: 2,
+  DirSelector: 4,
+  LangSelectorList: 8,
+  IsSelector: 16,
+  TextDecorationThicknessPercent: 32,
+  MediaIntervalSyntax: 64,
+  MediaRangeSyntax: 128,
+  CustomMediaQueries: 256,
+  ClampFunction: 512,
+  ColorFunction: 1024,
+  OklabColors: 2048,
+  LabColors: 4096,
+  P3Colors: 8192,
+  HexAlphaColors: 16384,
+  SpaceSeparatedColorNotation: 32768,
+  FontFamilySystemUi: 65536,
+  DoublePositionGradients: 131072,
+  VendorPrefixes: 262144,
+  LogicalProperties: 524288,
+  LightDark: 1048576,
+  Selectors: 31,
+  MediaQueries: 448,
+  Colors: 1113088,
+|};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/package.json
new file mode 100644
index 0000000..7a283a6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/lightningcss/package.json
@@ -0,0 +1,110 @@
+{
+  "name": "lightningcss",
+  "version": "1.32.0",
+  "license": "MPL-2.0",
+  "description": "A CSS parser, transformer, and minifier written in Rust",
+  "main": "node/index.js",
+  "types": "node/index.d.ts",
+  "exports": {
+    "types": "./node/index.d.ts",
+    "import": "./node/index.mjs",
+    "require": "./node/index.js"
+  },
+  "browserslist": "last 2 versions, not dead",
+  "targets": {
+    "main": false,
+    "types": false
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/lightningcss.git"
+  },
+  "engines": {
+    "node": ">= 12.0.0"
+  },
+  "napi": {
+    "name": "lightningcss"
+  },
+  "files": [
+    "node/*.js",
+    "node/*.mjs",
+    "node/*.d.ts",
+    "node/*.flow"
+  ],
+  "dependencies": {
+    "detect-libc": "^2.0.3"
+  },
+  "devDependencies": {
+    "@babel/parser": "7.21.4",
+    "@babel/traverse": "7.21.4",
+    "@codemirror/lang-css": "^6.0.1",
+    "@codemirror/lang-javascript": "^6.1.2",
+    "@codemirror/lint": "^6.1.0",
+    "@codemirror/theme-one-dark": "^6.1.0",
+    "@mdn/browser-compat-data": "~7.3.6",
+    "@napi-rs/cli": "^2.14.0",
+    "autoprefixer": "^10.4.27",
+    "caniuse-lite": "^1.0.30001777",
+    "codemirror": "^6.0.1",
+    "cssnano": "^7.0.6",
+    "esbuild": "^0.19.8",
+    "flowgen": "^1.21.0",
+    "jest-diff": "^27.4.2",
+    "json-schema-to-typescript": "^11.0.2",
+    "markdown-it-anchor": "^8.6.6",
+    "markdown-it-prism": "^2.3.0",
+    "markdown-it-table-of-contents": "^0.6.0",
+    "napi-wasm": "^1.0.1",
+    "node-fetch": "^3.1.0",
+    "parcel": "^2.8.2",
+    "patch-package": "^6.5.0",
+    "path-browserify": "^1.0.1",
+    "postcss": "^8.3.11",
+    "posthtml-include": "^1.7.4",
+    "posthtml-markdownit": "^1.3.1",
+    "posthtml-prism": "^1.0.4",
+    "process": "^0.11.10",
+    "puppeteer": "^12.0.1",
+    "recast": "^0.22.0",
+    "sharp": "^0.33.5",
+    "typescript": "^5.7.2",
+    "util": "^0.12.4",
+    "uvu": "^0.5.6"
+  },
+  "resolutions": {
+    "lightningcss": "link:."
+  },
+  "scripts": {
+    "prepare": "patch-package",
+    "build": "node scripts/build.js && node scripts/build-flow.js",
+    "build-release": "node scripts/build.js --release && node scripts/build-flow.js",
+    "prepublishOnly": "node scripts/build-flow.js",
+    "wasm:build": "cargo build --target wasm32-unknown-unknown -p lightningcss_node && wasm-opt target/wasm32-unknown-unknown/debug/lightningcss_node.wasm --asyncify --pass-arg=asyncify-imports@env.await_promise_sync -Oz -o wasm/lightningcss_node.wasm && node scripts/build-wasm.js",
+    "wasm:build-release": "cargo build --target wasm32-unknown-unknown -p lightningcss_node --release && wasm-opt target/wasm32-unknown-unknown/release/lightningcss_node.wasm --asyncify --pass-arg=asyncify-imports@env.await_promise_sync -Oz -o wasm/lightningcss_node.wasm && node scripts/build-wasm.js",
+    "website:start": "parcel 'website/*.html' website/playground/index.html",
+    "website:build": "yarn wasm:build-release && parcel build 'website/*.html' website/playground/index.html",
+    "build-ast": "cargo run --example schema --features jsonschema && node scripts/build-ast.js",
+    "tsc": "tsc -p node/tsconfig.json",
+    "test": "uvu node/test"
+  },
+  "optionalDependencies": {
+    "lightningcss-darwin-x64": "1.32.0",
+    "lightningcss-linux-x64-gnu": "1.32.0",
+    "lightningcss-win32-x64-msvc": "1.32.0",
+    "lightningcss-win32-arm64-msvc": "1.32.0",
+    "lightningcss-darwin-arm64": "1.32.0",
+    "lightningcss-linux-arm64-gnu": "1.32.0",
+    "lightningcss-linux-arm-gnueabihf": "1.32.0",
+    "lightningcss-linux-arm64-musl": "1.32.0",
+    "lightningcss-linux-x64-musl": "1.32.0",
+    "lightningcss-freebsd-x64": "1.32.0",
+    "lightningcss-android-arm64": "1.32.0"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/.claude/settings.local.json b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/.claude/settings.local.json
new file mode 100644
index 0000000..7ee57f3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/.claude/settings.local.json
@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node /workspaces/nanoid/test/check-versions.js)",
+      "Bash(echo \"Exit: $?\")",
+      "Bash(node --version)",
+      "Bash(node --experimental-strip-types test/check-prebuild.js)",
+      "Bash(node --experimental-strip-types test/update-prebuild.js)",
+      "Bash(node test/check-versions.js)",
+      "Bash(node bin/nanoid.js --version)",
+      "Bash(node bin/nanoid.js -s 10)"
+    ]
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/LICENSE
new file mode 100644
index 0000000..37f56aa
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>
+
+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.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/README.md
new file mode 100644
index 0000000..35abb57
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/README.md
@@ -0,0 +1,39 @@
+# Nano ID
+
+<img src="https://ai.github.io/nanoid/logo.svg" align="right"
+     alt="Nano ID logo by Anton Lovchikov" width="180" height="94">
+
+**English** | [Русский](./README.ru.md) | [简体中文](./README.zh-CN.md) | [Bahasa Indonesia](./README.id-ID.md)
+
+A tiny, secure, URL-friendly, unique string ID generator for JavaScript.
+
+> “An amazing level of senseless perfectionism,
+> which is simply impossible not to respect.”
+
+* **Small.** 130 bytes (minified and gzipped). No dependencies.
+  [Size Limit] controls the size.
+* **Fast.** It is 2 times faster than UUID.
+* **Safe.** It uses hardware random generator. Can be used in clusters.
+* **Short IDs.** It uses a larger alphabet than UUID (`A-Za-z0-9_-`).
+  So ID size was reduced from 36 to 21 symbols.
+* **Portable.** Nano ID was ported
+  to [20 programming languages](#other-programming-languages).
+
+```js
+import { nanoid } from 'nanoid'
+model.id = nanoid() //=> "V1StGXR8_Z5jdHi6B-myT"
+```
+
+Supports modern browsers, IE [with Babel], Node.js and React Native.
+
+[online tool]: https://gitpod.io/#https://github.com/ai/nanoid/
+[with Babel]:  https://developer.epages.com/blog/coding/how-to-transpile-node-modules-with-babel-and-webpack-in-a-monorepo/
+[Size Limit]:  https://github.com/ai/size-limit
+
+<a href="https://evilmartians.com/?utm_source=nanoid">
+  <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
+       alt="Sponsored by Evil Martians" width="236" height="54">
+</a>
+
+## Docs
+Read full docs **[here](https://github.com/ai/nanoid#readme)**.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.browser.cjs b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.browser.cjs
new file mode 100644
index 0000000..80d1871
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.browser.cjs
@@ -0,0 +1,69 @@
+let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes))
+
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  // First, a bitmask is necessary to generate the ID. The bitmask makes bytes
+  // values closer to the alphabet size. The bitmask calculates the closest
+  // `2^31 - 1` number, which exceeds the alphabet size.
+  // For example, the bitmask for the alphabet size 30 is 31 (00011111).
+  // `Math.clz32` is not used, because it is not available in browsers.
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  // Though, the bitmask solution is not perfect since the bytes exceeding
+  // the alphabet size are refused. Therefore, to reliably generate the ID,
+  // the random bytes redundancy has to be satisfied.
+
+  // Note: every hardware random generator call is performance expensive,
+  // because the system call for entropy collection takes a lot of time.
+  // So, to avoid additional system calls, extra bytes are requested in advance.
+
+  // Next, a step determines how many random bytes to generate.
+  // The number of random bytes gets decided upon the ID size, mask,
+  // alphabet size, and magic number 1.6 (using 1.6 peaks at performance
+  // according to benchmarks).
+
+  // `-~f => Math.ceil(f)` if f is a float
+  // `-~i => i + 1` if i is an integer
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+
+  return async (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = crypto.getRandomValues(new Uint8Array(step))
+      // A compact alternative for `for (var i = 0; i < step; i++)`.
+      let i = step | 0
+      while (i--) {
+        // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+
+let nanoid = async (size = 21) => {
+  let id = ''
+  let bytes = crypto.getRandomValues(new Uint8Array((size |= 0)))
+
+  // A compact alternative for `for (var i = 0; i < step; i++)`.
+  while (size--) {
+    // It is incorrect to use bytes exceeding the alphabet size.
+    // The following mask reduces the random byte in the 0-255 value
+    // range to the 0-63 value range. Therefore, adding hacks, such
+    // as empty string fallback or magic numbers, is unneccessary because
+    // the bitmask trims bytes down to the alphabet size.
+    let byte = bytes[size] & 63
+    if (byte < 36) {
+      // `0-9a-z`
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      // `A-Z`
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte < 63) {
+      id += '_'
+    } else {
+      id += '-'
+    }
+  }
+  return id
+}
+
+module.exports = { nanoid, customAlphabet, random }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.browser.js b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.browser.js
new file mode 100644
index 0000000..fbaa230
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.browser.js
@@ -0,0 +1,34 @@
+let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+  return async (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = crypto.getRandomValues(new Uint8Array(step))
+      let i = step | 0
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let nanoid = async (size = 21) => {
+  let id = ''
+  let bytes = crypto.getRandomValues(new Uint8Array((size |= 0)))
+  while (size--) {
+    let byte = bytes[size] & 63
+    if (byte < 36) {
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte < 63) {
+      id += '_'
+    } else {
+      id += '-'
+    }
+  }
+  return id
+}
+export { nanoid, customAlphabet, random }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.cjs b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.cjs
new file mode 100644
index 0000000..f1b0ad0
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.cjs
@@ -0,0 +1,71 @@
+let crypto = require('crypto')
+
+let { urlAlphabet } = require('../url-alphabet/index.cjs')
+
+// `crypto.randomFill()` is a little faster than `crypto.randomBytes()`,
+// because it is possible to use in combination with `Buffer.allocUnsafe()`.
+let random = bytes =>
+  new Promise((resolve, reject) => {
+    // `Buffer.allocUnsafe()` is faster because it doesn’t flush the memory.
+    // Memory flushing is unnecessary since the buffer allocation itself resets
+    // the memory with the new bytes.
+    crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(buf)
+      }
+    })
+  })
+
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  // First, a bitmask is necessary to generate the ID. The bitmask makes bytes
+  // values closer to the alphabet size. The bitmask calculates the closest
+  // `2^31 - 1` number, which exceeds the alphabet size.
+  // For example, the bitmask for the alphabet size 30 is 31 (00011111).
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  // Though, the bitmask solution is not perfect since the bytes exceeding
+  // the alphabet size are refused. Therefore, to reliably generate the ID,
+  // the random bytes redundancy has to be satisfied.
+
+  // Note: every hardware random generator call is performance expensive,
+  // because the system call for entropy collection takes a lot of time.
+  // So, to avoid additional system calls, extra bytes are requested in advance.
+
+  // Next, a step determines how many random bytes to generate.
+  // The number of random bytes gets decided upon the ID size, mask,
+  // alphabet size, and magic number 1.6 (using 1.6 peaks at performance
+  // according to benchmarks).
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+
+  let tick = (id, size = defaultSize) =>
+    random(step).then(bytes => {
+      // A compact alternative for `for (var i = 0; i < step; i++)`.
+      let i = step
+      while (i--) {
+        // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length >= size) return id
+      }
+      return tick(id, size)
+    })
+
+  return size => tick('', size)
+}
+
+let nanoid = (size = 21) =>
+  random((size |= 0)).then(bytes => {
+    let id = ''
+    // A compact alternative for `for (var i = 0; i < step; i++)`.
+    while (size--) {
+      // It is incorrect to use bytes exceeding the alphabet size.
+      // The following mask reduces the random byte in the 0-255 value
+      // range to the 0-63 value range. Therefore, adding hacks, such
+      // as empty string fallback or magic numbers, is unneccessary because
+      // the bitmask trims bytes down to the alphabet size.
+      id += urlAlphabet[bytes[size] & 63]
+    }
+    return id
+  })
+
+module.exports = { nanoid, customAlphabet, random }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.d.ts
new file mode 100644
index 0000000..9e91965
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.d.ts
@@ -0,0 +1,56 @@
+/**
+ * Generate secure URL-friendly unique ID. The non-blocking version.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid/async'
+ * nanoid().then(id => {
+ *   model.id = id
+ * })
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A promise with a random string.
+ */
+export function nanoid(size?: number): Promise<string>
+
+/**
+ * A low-level function.
+ * Generate secure unique ID with custom alphabet. The non-blocking version.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A function that returns a promise with a random string.
+ *
+ * ```js
+ * import { customAlphabet } from 'nanoid/async'
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid().then(id => {
+ *   model.id = id //=> "8ё56а"
+ * })
+ * ```
+ */
+export function customAlphabet(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => Promise<string>
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { random } from 'nanoid/async'
+ * random(5).then(bytes => {
+ *   bytes //=> [10, 67, 212, 67, 89]
+ * })
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns A promise with a random bytes array.
+ */
+export function random(bytes: number): Promise<Uint8Array>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.js b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.js
new file mode 100644
index 0000000..cec454a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.js
@@ -0,0 +1,35 @@
+import crypto from 'crypto'
+import { urlAlphabet } from '../url-alphabet/index.js'
+let random = bytes =>
+  new Promise((resolve, reject) => {
+    crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(buf)
+      }
+    })
+  })
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  let tick = (id, size = defaultSize) =>
+    random(step).then(bytes => {
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length >= size) return id
+      }
+      return tick(id, size)
+    })
+  return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+  random((size |= 0)).then(bytes => {
+    let id = ''
+    while (size--) {
+      id += urlAlphabet[bytes[size] & 63]
+    }
+    return id
+  })
+export { nanoid, customAlphabet, random }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.native.js b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.native.js
new file mode 100644
index 0000000..7c1d6f3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/index.native.js
@@ -0,0 +1,26 @@
+import { getRandomBytesAsync } from 'expo-random'
+import { urlAlphabet } from '../url-alphabet/index.js'
+let random = getRandomBytesAsync
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  let tick = (id, size = defaultSize) =>
+    random(step).then(bytes => {
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length >= size) return id
+      }
+      return tick(id, size)
+    })
+  return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+  random((size |= 0)).then(bytes => {
+    let id = ''
+    while (size--) {
+      id += urlAlphabet[bytes[size] & 63]
+    }
+    return id
+  })
+export { nanoid, customAlphabet, random }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/package.json
new file mode 100644
index 0000000..578cdb4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/async/package.json
@@ -0,0 +1,12 @@
+{
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "react-native": {
+    "./index.js": "./index.native.js"
+  },
+  "browser": {
+    "./index.js": "./index.browser.js",
+    "./index.cjs": "./index.browser.cjs"
+  }
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/bin/nanoid.cjs b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/bin/nanoid.cjs
new file mode 100644
index 0000000..c76db0f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/bin/nanoid.cjs
@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+let { nanoid, customAlphabet } = require('..')
+
+function print(msg) {
+  process.stdout.write(msg + '\n')
+}
+
+function error(msg) {
+  process.stderr.write(msg + '\n')
+  process.exit(1)
+}
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  print(`
+  Usage
+    $ nanoid [options]
+
+  Options
+    -s, --size       Generated ID size
+    -a, --alphabet   Alphabet to use
+    -h, --help       Show this help
+
+  Examples
+    $ nanoid --s 15
+    S9sBF77U6sDB8Yg
+
+    $ nanoid --size 10 --alphabet abc
+    bcabababca`)
+  process.exit()
+}
+
+let alphabet, size
+for (let i = 2; i < process.argv.length; i++) {
+  let arg = process.argv[i]
+  if (arg === '--size' || arg === '-s') {
+    size = Number(process.argv[i + 1])
+    i += 1
+    if (Number.isNaN(size) || size <= 0) {
+      error('Size must be positive integer')
+    }
+  } else if (arg === '--alphabet' || arg === '-a') {
+    alphabet = process.argv[i + 1]
+    i += 1
+  } else {
+    error('Unknown argument ' + arg)
+  }
+}
+
+if (alphabet) {
+  let customNanoid = customAlphabet(alphabet, size)
+  print(customNanoid())
+} else {
+  print(nanoid(size))
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.browser.cjs b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.browser.cjs
new file mode 100644
index 0000000..d21a91f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.browser.cjs
@@ -0,0 +1,72 @@
+// This file replaces `index.js` in bundlers like webpack or Rollup,
+// according to `browser` config in `package.json`.
+
+let { urlAlphabet } = require('./url-alphabet/index.cjs')
+
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  // First, a bitmask is necessary to generate the ID. The bitmask makes bytes
+  // values closer to the alphabet size. The bitmask calculates the closest
+  // `2^31 - 1` number, which exceeds the alphabet size.
+  // For example, the bitmask for the alphabet size 30 is 31 (00011111).
+  // `Math.clz32` is not used, because it is not available in browsers.
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  // Though, the bitmask solution is not perfect since the bytes exceeding
+  // the alphabet size are refused. Therefore, to reliably generate the ID,
+  // the random bytes redundancy has to be satisfied.
+
+  // Note: every hardware random generator call is performance expensive,
+  // because the system call for entropy collection takes a lot of time.
+  // So, to avoid additional system calls, extra bytes are requested in advance.
+
+  // Next, a step determines how many random bytes to generate.
+  // The number of random bytes gets decided upon the ID size, mask,
+  // alphabet size, and magic number 1.6 (using 1.6 peaks at performance
+  // according to benchmarks).
+
+  // `-~f => Math.ceil(f)` if f is a float
+  // `-~i => i + 1` if i is an integer
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      // A compact alternative for `for (var i = 0; i < step; i++)`.
+      let j = step | 0
+      while (j--) {
+        // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
+        id += alphabet[bytes[j] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size, random)
+
+let nanoid = (size = 21) =>
+  crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+    // It is incorrect to use bytes exceeding the alphabet size.
+    // The following mask reduces the random byte in the 0-255 value
+    // range to the 0-63 value range. Therefore, adding hacks, such
+    // as empty string fallback or magic numbers, is unneccessary because
+    // the bitmask trims bytes down to the alphabet size.
+    byte &= 63
+    if (byte < 36) {
+      // `0-9a-z`
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      // `A-Z`
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte > 62) {
+      id += '-'
+    } else {
+      id += '_'
+    }
+    return id
+  }, '')
+
+module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.browser.js b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.browser.js
new file mode 100644
index 0000000..7d3b876
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.browser.js
@@ -0,0 +1,34 @@
+import { urlAlphabet } from './url-alphabet/index.js'
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      let j = step | 0
+      while (j--) {
+        id += alphabet[bytes[j] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size, random)
+let nanoid = (size = 21) =>
+  crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+    byte &= 63
+    if (byte < 36) {
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte > 62) {
+      id += '-'
+    } else {
+      id += '_'
+    }
+    return id
+  }, '')
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.cjs b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.cjs
new file mode 100644
index 0000000..0623c66
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.cjs
@@ -0,0 +1,86 @@
+let crypto = require('crypto')
+
+let { urlAlphabet } = require('./url-alphabet/index.cjs')
+
+// It is best to make fewer, larger requests to the crypto module to
+// avoid system call overhead. So, random numbers are generated in a
+// pool. The pool is a Buffer that is larger than the initial random
+// request size by this multiplier. The pool is enlarged if subsequent
+// requests exceed the maximum buffer size.
+const POOL_SIZE_MULTIPLIER = 128
+let pool, poolOffset
+
+let fillPool = bytes => {
+  if (bytes < 0 || bytes > 1024) throw new RangeError('Wrong ID size')
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER)
+    crypto.randomFillSync(pool)
+    poolOffset = 0
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.randomFillSync(pool)
+    poolOffset = 0
+  }
+  poolOffset += bytes
+}
+
+let random = bytes => {
+  // `|=` convert `bytes` to number to prevent `valueOf` abusing and pool pollution
+  fillPool((bytes |= 0))
+  return pool.subarray(poolOffset - bytes, poolOffset)
+}
+
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  // First, a bitmask is necessary to generate the ID. The bitmask makes bytes
+  // values closer to the alphabet size. The bitmask calculates the closest
+  // `2^31 - 1` number, which exceeds the alphabet size.
+  // For example, the bitmask for the alphabet size 30 is 31 (00011111).
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  // Though, the bitmask solution is not perfect since the bytes exceeding
+  // the alphabet size are refused. Therefore, to reliably generate the ID,
+  // the random bytes redundancy has to be satisfied.
+
+  // Note: every hardware random generator call is performance expensive,
+  // because the system call for entropy collection takes a lot of time.
+  // So, to avoid additional system calls, extra bytes are requested in advance.
+
+  // Next, a step determines how many random bytes to generate.
+  // The number of random bytes gets decided upon the ID size, mask,
+  // alphabet size, and magic number 1.6 (using 1.6 peaks at performance
+  // according to benchmarks).
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      // A compact alternative for `for (let i = 0; i < step; i++)`.
+      let i = step
+      while (i--) {
+        // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size, random)
+
+let nanoid = (size = 21) => {
+  // `|=` convert `size` to number to prevent `valueOf` abusing and pool pollution
+  fillPool((size |= 0))
+  let id = ''
+  // We are reading directly from the random pool to avoid creating new array
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    // It is incorrect to use bytes exceeding the alphabet size.
+    // The following mask reduces the random byte in the 0-255 value
+    // range to the 0-63 value range. Therefore, adding hacks, such
+    // as empty string fallback or magic numbers, is unneccessary because
+    // the bitmask trims bytes down to the alphabet size.
+    id += urlAlphabet[pool[i] & 63]
+  }
+  return id
+}
+
+module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.d.cts b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.d.cts
new file mode 100644
index 0000000..3e111a3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.d.cts
@@ -0,0 +1,91 @@
+/**
+ * Generate secure URL-friendly unique ID.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate secure unique ID with custom alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * const { customAlphabet } = require('nanoid')
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid() //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => string
+
+/**
+ * Generate unique ID with custom random generator and alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * ```js
+ * import { customRandom } from 'nanoid/format'
+ *
+ * const nanoid = customRandom('abcdef', 5, size => {
+ *   const random = []
+ *   for (let i = 0; i < size; i++) {
+ *     random.push(randomByte())
+ *   }
+ *   return random
+ * })
+ *
+ * nanoid() //=> "fbaef"
+ * ```
+ *
+ * @param alphabet Alphabet used to generate a random string.
+ * @param size Size of the random string.
+ * @param random A random bytes generator.
+ * @returns A random string generator.
+ */
+export function customRandom(
+  alphabet: string,
+  size: number,
+  random: (bytes: number) => Uint8Array
+): () => string
+
+/**
+ * URL safe symbols.
+ *
+ * ```js
+ * import { urlAlphabet } from 'nanoid'
+ * const nanoid = customAlphabet(urlAlphabet, 10)
+ * nanoid() //=> "Uakgb_J5m9"
+ * ```
+ */
+export const urlAlphabet: string
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { customRandom, random } from 'nanoid'
+ * const nanoid = customRandom("abcdef", 5, random)
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns An array of random bytes.
+ */
+export function random(bytes: number): Uint8Array
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.d.ts
new file mode 100644
index 0000000..3e111a3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.d.ts
@@ -0,0 +1,91 @@
+/**
+ * Generate secure URL-friendly unique ID.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate secure unique ID with custom alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * const { customAlphabet } = require('nanoid')
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid() //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => string
+
+/**
+ * Generate unique ID with custom random generator and alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * ```js
+ * import { customRandom } from 'nanoid/format'
+ *
+ * const nanoid = customRandom('abcdef', 5, size => {
+ *   const random = []
+ *   for (let i = 0; i < size; i++) {
+ *     random.push(randomByte())
+ *   }
+ *   return random
+ * })
+ *
+ * nanoid() //=> "fbaef"
+ * ```
+ *
+ * @param alphabet Alphabet used to generate a random string.
+ * @param size Size of the random string.
+ * @param random A random bytes generator.
+ * @returns A random string generator.
+ */
+export function customRandom(
+  alphabet: string,
+  size: number,
+  random: (bytes: number) => Uint8Array
+): () => string
+
+/**
+ * URL safe symbols.
+ *
+ * ```js
+ * import { urlAlphabet } from 'nanoid'
+ * const nanoid = customAlphabet(urlAlphabet, 10)
+ * nanoid() //=> "Uakgb_J5m9"
+ * ```
+ */
+export const urlAlphabet: string
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { customRandom, random } from 'nanoid'
+ * const nanoid = customRandom("abcdef", 5, random)
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns An array of random bytes.
+ */
+export function random(bytes: number): Uint8Array
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.js b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.js
new file mode 100644
index 0000000..186d339
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/index.js
@@ -0,0 +1,46 @@
+import crypto from 'crypto'
+import { urlAlphabet } from './url-alphabet/index.js'
+const POOL_SIZE_MULTIPLIER = 128
+let pool, poolOffset
+let fillPool = bytes => {
+  if (bytes < 0 || bytes > 1024) throw new RangeError('Wrong ID size')
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER)
+    crypto.randomFillSync(pool)
+    poolOffset = 0
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.randomFillSync(pool)
+    poolOffset = 0
+  }
+  poolOffset += bytes
+}
+let random = bytes => {
+  fillPool((bytes |= 0))
+  return pool.subarray(poolOffset - bytes, poolOffset)
+}
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size, random)
+let nanoid = (size = 21) => {
+  fillPool((size |= 0))
+  let id = ''
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63]
+  }
+  return id
+}
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/nanoid.js b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/nanoid.js
new file mode 100644
index 0000000..ec242ea
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/nanoid.js
@@ -0,0 +1 @@
+export let nanoid=(t=21)=>crypto.getRandomValues(new Uint8Array(t)).reduce(((t,e)=>t+=(e&=63)<36?e.toString(36):e<62?(e-26).toString(36).toUpperCase():e<63?"_":"-"),"");
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/index.cjs b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/index.cjs
new file mode 100644
index 0000000..d51fcb6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/index.cjs
@@ -0,0 +1,34 @@
+// This alphabet uses `A-Za-z0-9_-` symbols.
+// The order of characters is optimized for better gzip and brotli compression.
+// References to the same file (works both for gzip and brotli):
+// `'use`, `andom`, and `rict'`
+// References to the brotli default dictionary:
+// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = ''
+    // A compact alternative for `for (var i = 0; i < step; i++)`.
+    let i = size | 0
+    while (i--) {
+      // `| 0` is more compact and faster than `Math.floor()`.
+      id += alphabet[(Math.random() * alphabet.length) | 0]
+    }
+    return id
+  }
+}
+
+let nanoid = (size = 21) => {
+  let id = ''
+  // A compact alternative for `for (var i = 0; i < step; i++)`.
+  let i = size | 0
+  while (i--) {
+    // `| 0` is more compact and faster than `Math.floor()`.
+    id += urlAlphabet[(Math.random() * 64) | 0]
+  }
+  return id
+}
+
+module.exports = { nanoid, customAlphabet }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/index.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/index.d.ts
new file mode 100644
index 0000000..4965322
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/index.d.ts
@@ -0,0 +1,33 @@
+/**
+ * Generate URL-friendly unique ID. This method uses the non-secure
+ * predictable random generator with bigger collision probability.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid/non-secure'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate a unique ID based on a custom alphabet.
+ * This method uses the non-secure predictable random generator
+ * with bigger collision probability.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * import { customAlphabet } from 'nanoid/non-secure'
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * model.id = //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => string
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/index.js b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/index.js
new file mode 100644
index 0000000..2ea5827
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/index.js
@@ -0,0 +1,21 @@
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = ''
+    let i = size | 0
+    while (i--) {
+      id += alphabet[(Math.random() * alphabet.length) | 0]
+    }
+    return id
+  }
+}
+let nanoid = (size = 21) => {
+  let id = ''
+  let i = size | 0
+  while (i--) {
+    id += urlAlphabet[(Math.random() * 64) | 0]
+  }
+  return id
+}
+export { nanoid, customAlphabet }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/package.json
new file mode 100644
index 0000000..9930d6a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/non-secure/package.json
@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "react-native": "index.js"
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/package.json
new file mode 100644
index 0000000..416c53f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/package.json
@@ -0,0 +1,89 @@
+{
+  "name": "nanoid",
+  "version": "3.3.12",
+  "description": "A tiny (116 bytes), secure URL-friendly unique string ID generator",
+  "keywords": [
+    "uuid",
+    "random",
+    "id",
+    "url"
+  ],
+  "engines": {
+    "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/ai"
+    }
+  ],
+  "author": "Andrey Sitnik <andrey@sitnik.ru>",
+  "license": "MIT",
+  "repository": "ai/nanoid",
+  "browser": {
+    "./index.js": "./index.browser.js",
+    "./async/index.js": "./async/index.browser.js",
+    "./async/index.cjs": "./async/index.browser.cjs",
+    "./index.cjs": "./index.browser.cjs"
+  },
+  "react-native": "index.js",
+  "bin": "./bin/nanoid.cjs",
+  "sideEffects": false,
+  "types": "./index.d.ts",
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "exports": {
+    ".": {
+      "react-native": "./index.browser.js",
+      "browser": "./index.browser.js",
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./index.cjs"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json",
+    "./async/package.json": "./async/package.json",
+    "./async": {
+      "browser": "./async/index.browser.js",
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./async/index.cjs"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./async/index.js"
+      },
+      "default": "./async/index.js"
+    },
+    "./non-secure/package.json": "./non-secure/package.json",
+    "./non-secure": {
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./non-secure/index.cjs"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./non-secure/index.js"
+      },
+      "default": "./non-secure/index.js"
+    },
+    "./url-alphabet/package.json": "./url-alphabet/package.json",
+    "./url-alphabet": {
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./url-alphabet/index.cjs"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./url-alphabet/index.js"
+      },
+      "default": "./url-alphabet/index.js"
+    }
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/url-alphabet/index.cjs b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/url-alphabet/index.cjs
new file mode 100644
index 0000000..a332f0b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/url-alphabet/index.cjs
@@ -0,0 +1,7 @@
+// This alphabet uses `A-Za-z0-9_-` symbols.
+// The order of characters is optimized for better gzip and brotli compression.
+// Same as in non-secure/index.js
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+
+module.exports = { urlAlphabet }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/url-alphabet/index.js b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/url-alphabet/index.js
new file mode 100644
index 0000000..c2782e5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/url-alphabet/index.js
@@ -0,0 +1,3 @@
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+export { urlAlphabet }
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/url-alphabet/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/url-alphabet/package.json
new file mode 100644
index 0000000..9930d6a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/nanoid/url-alphabet/package.json
@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "react-native": "index.js"
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/LICENSE
new file mode 100644
index 0000000..46c9b95
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/LICENSE
@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2021-2024 Oleksii Raspopov, Kostiantyn Denysov, Anton Verinov
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/README.md
new file mode 100644
index 0000000..8e47aa8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/README.md
@@ -0,0 +1,21 @@
+# picocolors
+
+The tiniest and the fastest library for terminal output formatting with ANSI colors.
+
+```javascript
+import pc from "picocolors"
+
+console.log(
+  pc.green(`How are ${pc.italic(`you`)} doing?`)
+)
+```
+
+- **No dependencies.**
+- **14 times** smaller and **2 times** faster than chalk.
+- Used by popular tools like PostCSS, SVGO, Stylelint, and Browserslist.
+- Node.js v6+ & browsers support. Support for both CJS and ESM projects.
+- TypeScript type declarations included.
+- [`NO_COLOR`](https://no-color.org/) friendly.
+
+## Docs
+Read **[full docs](https://github.com/alexeyraspopov/picocolors#readme)** on GitHub.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/package.json
new file mode 100644
index 0000000..372d4b6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "picocolors",
+  "version": "1.1.1",
+  "main": "./picocolors.js",
+  "types": "./picocolors.d.ts",
+  "browser": {
+    "./picocolors.js": "./picocolors.browser.js"
+  },
+  "sideEffects": false,
+  "description": "The tiniest and the fastest library for terminal output formatting with ANSI colors",
+  "files": [
+    "picocolors.*",
+    "types.d.ts"
+  ],
+  "keywords": [
+    "terminal",
+    "colors",
+    "formatting",
+    "cli",
+    "console"
+  ],
+  "author": "Alexey Raspopov",
+  "repository": "alexeyraspopov/picocolors",
+  "license": "ISC"
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/picocolors.browser.js b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/picocolors.browser.js
new file mode 100644
index 0000000..9dcf637
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/picocolors.browser.js
@@ -0,0 +1,4 @@
+var x=String;
+var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}};
+module.exports=create();
+module.exports.createColors = create;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/picocolors.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/picocolors.d.ts
new file mode 100644
index 0000000..94e146a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/picocolors.d.ts
@@ -0,0 +1,5 @@
+import { Colors } from "./types"
+
+declare const picocolors: Colors & { createColors: (enabled?: boolean) => Colors }
+
+export = picocolors
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/picocolors.js b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/picocolors.js
new file mode 100644
index 0000000..e32df85
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/picocolors.js
@@ -0,0 +1,75 @@
+let p = process || {}, argv = p.argv || [], env = p.env || {}
+let isColorSupported =
+	!(!!env.NO_COLOR || argv.includes("--no-color")) &&
+	(!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI)
+
+let formatter = (open, close, replace = open) =>
+	input => {
+		let string = "" + input, index = string.indexOf(close, open.length)
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close
+	}
+
+let replaceClose = (string, close, replace, index) => {
+	let result = "", cursor = 0
+	do {
+		result += string.substring(cursor, index) + replace
+		cursor = index + close.length
+		index = string.indexOf(close, cursor)
+	} while (~index)
+	return result + string.substring(cursor)
+}
+
+let createColors = (enabled = isColorSupported) => {
+	let f = enabled ? formatter : () => String
+	return {
+		isColorSupported: enabled,
+		reset: f("\x1b[0m", "\x1b[0m"),
+		bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+		dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+		italic: f("\x1b[3m", "\x1b[23m"),
+		underline: f("\x1b[4m", "\x1b[24m"),
+		inverse: f("\x1b[7m", "\x1b[27m"),
+		hidden: f("\x1b[8m", "\x1b[28m"),
+		strikethrough: f("\x1b[9m", "\x1b[29m"),
+
+		black: f("\x1b[30m", "\x1b[39m"),
+		red: f("\x1b[31m", "\x1b[39m"),
+		green: f("\x1b[32m", "\x1b[39m"),
+		yellow: f("\x1b[33m", "\x1b[39m"),
+		blue: f("\x1b[34m", "\x1b[39m"),
+		magenta: f("\x1b[35m", "\x1b[39m"),
+		cyan: f("\x1b[36m", "\x1b[39m"),
+		white: f("\x1b[37m", "\x1b[39m"),
+		gray: f("\x1b[90m", "\x1b[39m"),
+
+		bgBlack: f("\x1b[40m", "\x1b[49m"),
+		bgRed: f("\x1b[41m", "\x1b[49m"),
+		bgGreen: f("\x1b[42m", "\x1b[49m"),
+		bgYellow: f("\x1b[43m", "\x1b[49m"),
+		bgBlue: f("\x1b[44m", "\x1b[49m"),
+		bgMagenta: f("\x1b[45m", "\x1b[49m"),
+		bgCyan: f("\x1b[46m", "\x1b[49m"),
+		bgWhite: f("\x1b[47m", "\x1b[49m"),
+
+		blackBright: f("\x1b[90m", "\x1b[39m"),
+		redBright: f("\x1b[91m", "\x1b[39m"),
+		greenBright: f("\x1b[92m", "\x1b[39m"),
+		yellowBright: f("\x1b[93m", "\x1b[39m"),
+		blueBright: f("\x1b[94m", "\x1b[39m"),
+		magentaBright: f("\x1b[95m", "\x1b[39m"),
+		cyanBright: f("\x1b[96m", "\x1b[39m"),
+		whiteBright: f("\x1b[97m", "\x1b[39m"),
+
+		bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+		bgRedBright: f("\x1b[101m", "\x1b[49m"),
+		bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+		bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+		bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+		bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+		bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+		bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
+	}
+}
+
+module.exports = createColors()
+module.exports.createColors = createColors
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/types.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/types.d.ts
new file mode 100644
index 0000000..cd1aec4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picocolors/types.d.ts
@@ -0,0 +1,51 @@
+export type Formatter = (input: string | number | null | undefined) => string
+
+export interface Colors {
+	isColorSupported: boolean
+
+	reset: Formatter
+	bold: Formatter
+	dim: Formatter
+	italic: Formatter
+	underline: Formatter
+	inverse: Formatter
+	hidden: Formatter
+	strikethrough: Formatter
+
+	black: Formatter
+	red: Formatter
+	green: Formatter
+	yellow: Formatter
+	blue: Formatter
+	magenta: Formatter
+	cyan: Formatter
+	white: Formatter
+	gray: Formatter
+
+	bgBlack: Formatter
+	bgRed: Formatter
+	bgGreen: Formatter
+	bgYellow: Formatter
+	bgBlue: Formatter
+	bgMagenta: Formatter
+	bgCyan: Formatter
+	bgWhite: Formatter
+
+	blackBright: Formatter
+	redBright: Formatter
+	greenBright: Formatter
+	yellowBright: Formatter
+	blueBright: Formatter
+	magentaBright: Formatter
+	cyanBright: Formatter
+	whiteBright: Formatter
+
+	bgBlackBright: Formatter
+	bgRedBright: Formatter
+	bgGreenBright: Formatter
+	bgYellowBright: Formatter
+	bgBlueBright: Formatter
+	bgMagentaBright: Formatter
+	bgCyanBright: Formatter
+	bgWhiteBright: Formatter
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/LICENSE
new file mode 100644
index 0000000..3608dca
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present, Jon Schlinkert.
+
+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.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/README.md
new file mode 100644
index 0000000..14805d6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/README.md
@@ -0,0 +1,749 @@
+<h1 align="center">Picomatch</h1>
+
+<p align="center">
+<a href="https://npmjs.org/package/picomatch">
+<img src="https://img.shields.io/npm/v/picomatch.svg" alt="version">
+</a>
+<a href="https://github.com/micromatch/picomatch/actions?workflow=Tests">
+<img src="https://github.com/micromatch/picomatch/workflows/Tests/badge.svg" alt="test status">
+</a>
+<a href="https://coveralls.io/github/micromatch/picomatch">
+<img src="https://img.shields.io/coveralls/github/micromatch/picomatch/master.svg" alt="coverage status">
+</a>
+<a href="https://npmjs.org/package/picomatch">
+<img src="https://img.shields.io/npm/dm/picomatch.svg" alt="downloads">
+</a>
+</p>
+
+<br>
+<br>
+
+<p align="center">
+<strong>Blazing fast and accurate glob matcher written in JavaScript.</strong></br>
+<em>No dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.</em>
+</p>
+
+<br>
+<br>
+
+## Why picomatch?
+
+* **Lightweight** - No dependencies
+* **Minimal** - Tiny API surface. Main export is a function that takes a glob pattern and returns a matcher function.
+* **Fast** - Loads in about 2ms (that's several times faster than a [single frame of a HD movie](http://www.endmemo.com/sconvert/framespersecondframespermillisecond.php) at 60fps)
+* **Performant** - Use the returned matcher function to speed up repeat matching (like when watching files)
+* **Accurate matching** - Using wildcards (`*` and `?`), globstars (`**`) for nested directories, [advanced globbing](#advanced-globbing) with extglobs, braces, and POSIX brackets, and support for escaping special characters with `\` or quotes.
+* **Well tested** - Thousands of unit tests
+
+See the [library comparison](#library-comparisons) to other libraries.
+
+<br>
+<br>
+
+## Table of Contents
+
+<details><summary> Click to expand </summary>
+
+- [Install](#install)
+- [Usage](#usage)
+- [API](#api)
+  * [picomatch](#picomatch)
+  * [.test](#test)
+  * [.matchBase](#matchbase)
+  * [.isMatch](#ismatch)
+  * [.parse](#parse)
+  * [.scan](#scan)
+  * [.compileRe](#compilere)
+  * [.makeRe](#makere)
+  * [.toRegex](#toregex)
+- [Options](#options)
+  * [Picomatch options](#picomatch-options)
+  * [Scan Options](#scan-options)
+  * [Options Examples](#options-examples)
+- [Globbing features](#globbing-features)
+  * [Basic globbing](#basic-globbing)
+  * [Advanced globbing](#advanced-globbing)
+  * [Braces](#braces)
+  * [Matching special characters as literals](#matching-special-characters-as-literals)
+- [Library Comparisons](#library-comparisons)
+- [Benchmarks](#benchmarks)
+- [Philosophies](#philosophies)
+- [About](#about)
+  * [Author](#author)
+  * [License](#license)
+
+_(TOC generated by [verb](https://github.com/verbose/verb) using [markdown-toc](https://github.com/jonschlinkert/markdown-toc))_
+
+</details>
+
+<br>
+<br>
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+npm install --save picomatch
+```
+
+<br>
+
+## Usage
+
+The main export is a function that takes a glob pattern and an options object and returns a function for matching strings.
+
+```js
+const pm = require('picomatch');
+const isMatch = pm('*.js');
+
+console.log(isMatch('abcd')); //=> false
+console.log(isMatch('a.js')); //=> true
+console.log(isMatch('a.md')); //=> false
+console.log(isMatch('a/b.js')); //=> false
+```
+
+<br>
+
+## API
+
+### [picomatch](lib/picomatch.js#L31)
+
+Creates a matcher function from one or more glob patterns. The returned function takes a string to match as its first argument, and returns true if the string is a match. The returned matcher function also takes a boolean as the second argument that, when true, returns an object with additional information.
+
+**Params**
+
+* `globs` **{String|Array}**: One or more glob patterns.
+* `options` **{Object=}**
+* `returns` **{Function=}**: Returns a matcher function.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch(glob[, options]);
+
+const isMatch = picomatch('*.!(*a)');
+console.log(isMatch('a.a')); //=> false
+console.log(isMatch('a.b')); //=> true
+```
+
+**Example without node.js**
+
+For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection.
+
+```js
+const picomatch = require('picomatch/posix');
+// the same API, defaulting to posix paths
+const isMatch = picomatch('a/*');
+console.log(isMatch('a\\b')); //=> false
+console.log(isMatch('a/b')); //=> true
+
+// you can still configure the matcher function to accept windows paths
+const isMatch = picomatch('a/*', { options: windows });
+console.log(isMatch('a\\b')); //=> true
+console.log(isMatch('a/b')); //=> true
+```
+
+### [.test](lib/picomatch.js#L116)
+
+Test `input` with the given `regex`. This is used by the main `picomatch()` function to test the input string.
+
+**Params**
+
+* `input` **{String}**: String to test.
+* `regex` **{RegExp}**
+* `returns` **{Object}**: Returns an object with matching info.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.test(input, regex[, options]);
+
+console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+// { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+```
+
+### [.matchBase](lib/picomatch.js#L160)
+
+Match the basename of a filepath.
+
+**Params**
+
+* `input` **{String}**: String to test.
+* `glob` **{RegExp|String}**: Glob pattern or regex created by [.makeRe](#makeRe).
+* `returns` **{Boolean}**
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.matchBase(input, glob[, options]);
+console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+```
+
+### [.isMatch](lib/picomatch.js#L182)
+
+Returns true if **any** of the given glob `patterns` match the specified `string`.
+
+**Params**
+
+* **{String|Array}**: str The string to test.
+* **{String|Array}**: patterns One or more glob patterns to use for matching.
+* **{Object}**: See available [options](#options).
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.isMatch(string, patterns[, options]);
+
+console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+```
+
+### [.parse](lib/picomatch.js#L198)
+
+Parse a glob pattern to create the source string for a regular expression.
+
+**Params**
+
+* `pattern` **{String}**
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an object with useful properties and output to be used as a regex source string.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+const result = picomatch.parse(pattern[, options]);
+```
+
+### [.scan](lib/picomatch.js#L230)
+
+Scan a glob pattern to separate the pattern into segments.
+
+**Params**
+
+* `input` **{String}**: Glob pattern to scan.
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an object with
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.scan(input[, options]);
+
+const result = picomatch.scan('!./foo/*.js');
+console.log(result);
+{ prefix: '!./',
+  input: '!./foo/*.js',
+  start: 3,
+  base: 'foo',
+  glob: '*.js',
+  isBrace: false,
+  isBracket: false,
+  isGlob: true,
+  isExtglob: false,
+  isGlobstar: false,
+  negated: true }
+```
+
+### [.compileRe](lib/picomatch.js#L244)
+
+Compile a regular expression from the `state` object returned by the
+[parse()](#parse) method.
+
+**Params**
+
+* `state` **{Object}**
+* `options` **{Object}**
+* `returnOutput` **{Boolean}**: Intended for implementors, this argument allows you to return the raw output from the parser.
+* `returnState` **{Boolean}**: Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+* `returns` **{RegExp}**
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+const state = picomatch.parse('*.js');
+// picomatch.compileRe(state[, options]);
+
+console.log(picomatch.compileRe(state));
+//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+```
+
+### [.makeRe](lib/picomatch.js#L285)
+
+Create a regular expression from a parsed glob pattern.
+
+**Params**
+
+* `state` **{String}**: The object returned from the `.parse` method.
+* `options` **{Object}**
+* `returnOutput` **{Boolean}**: Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+* `returnState` **{Boolean}**: Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+* `returns` **{RegExp}**: Returns a regex created from the given pattern.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.makeRe(state[, options]);
+
+const result = picomatch.makeRe('*.js');
+console.log(result);
+//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+```
+
+### [.toRegex](lib/picomatch.js#L320)
+
+Create a regular expression from the given regex source string.
+
+**Params**
+
+* `source` **{String}**: Regular expression source string.
+* `options` **{Object}**
+* `returns` **{RegExp}**
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.toRegex(source[, options]);
+
+const { output } = picomatch.parse('*.js');
+console.log(picomatch.toRegex(output));
+//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+```
+
+<br>
+
+## Options
+
+### Picomatch options
+
+The following options may be used with the main `picomatch()` function or any of the methods on the picomatch API.
+
+| **Option** | **Type** | **Default value** | **Description** |
+| --- | --- | --- | --- |
+| `basename`            | `boolean`      | `false`     | If set, then patterns without slashes will be matched against the basename of the path if it contains slashes.  For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. |
+| `bash`                | `boolean`      | `false`     | Follow bash matching rules more strictly - disallows backslashes as escape characters, and treats single stars as globstars (`**`). |
+| `capture`             | `boolean`      | `undefined` | Return regex matches in supporting methods. |
+| `contains`            | `boolean`      | `undefined` | Allows glob to match any part of the given string(s). |
+| `debug`               | `boolean`      | `undefined` | Debug regular expressions when an error is thrown. |
+| `dot`                 | `boolean`      | `false`     | Enable dotfile matching. By default, dotfiles are ignored unless a `.` is explicitly defined in the pattern, or `options.dot` is true |
+| `expandRange`         | `function`     | `undefined` | Custom function for expanding ranges in brace patterns, such as `{a..z}`. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. |
+| `fastpaths`           | `boolean`      | `true`      | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to `false`. |
+| `flags`               | `string`      | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. |
+| [format](#optionsformat) | `function` | `undefined` | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. |
+| `ignore`              | `array\|string` | `undefined` | One or more glob patterns for excluding strings that should not be matched from the result. |
+| `keepQuotes`          | `boolean`      | `false`     | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes.  |
+| `literalBrackets`     | `boolean`      | `undefined` | When `true`, brackets in the glob pattern will be escaped so that only literal brackets will be matched. |
+| `matchBase`           | `boolean`      | `false`     | Alias for `basename` |
+| `maxLength`           | `number`      | `65536`     | Limit the max length of the input string. An error is thrown if the input string is longer than this value. |
+| `maxExtglobRecursion` | `number\|boolean` | `0` | Limit nested quantified extglobs and other risky repeated extglob forms. When the limit is exceeded, the extglob is treated as a literal string instead of being compiled to regex. Set to `false` to disable this safeguard. |
+| `nobrace`             | `boolean`      | `false`     | Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters. |
+| `nobracket`           | `boolean`      | `undefined` | Disable matching with regex brackets. |
+| `nocase`              | `boolean`      | `false`     | Make matching case-insensitive. Equivalent to the regex `i` flag. Note that this option is overridden by the `flags` option. |
+| `noext`               | `boolean`      | `false`     | Alias for `noextglob` |
+| `noextglob`           | `boolean`      | `false`     | Disable support for matching with extglobs (like `+(a\|b)`) |
+| `noglobstar`          | `boolean`      | `false`     | Disable support for matching nested directories with globstars (`**`) |
+| `nonegate`            | `boolean`      | `false`     | Disable support for negating with leading `!` |
+| [onIgnore](#optionsonIgnore) | `function` | `undefined` | Function to be called on ignored items. |
+| [onMatch](#optionsonMatch) | `function` | `undefined` | Function to be called on matched items. |
+| [onResult](#optionsonResult) | `function` | `undefined` | Function to be called on all items, regardless of whether or not they are matched or ignored. |
+| `posix`               | `boolean`      | `false`     | Support POSIX character classes ("posix brackets"). |
+| `prepend`             | `boolean`      | `undefined` | String to prepend to the generated regex used for matching. |
+| `regex`               | `boolean`      | `false`     | Use regular expression rules for `+` (instead of matching literal `+`), and for stars that follow closing parentheses or brackets (as in `)*` and `]*`). |
+| `strictBrackets`      | `boolean`      | `undefined` | Throw an error if brackets, braces, or parens are imbalanced. |
+| `strictSlashes`       | `boolean`      | `undefined` | When true, picomatch won't match trailing slashes with single stars. |
+| `unescape`            | `boolean`      | `undefined` | Remove backslashes preceding escaped characters in the glob pattern. By default, backslashes are retained. |
+| `windows`             | `boolean`      | `false`     | Also accept backslashes as the path separator. |
+
+### Scan Options
+
+In addition to the main [picomatch options](#picomatch-options), the following options may also be used with the [.scan](#scan) method.
+
+| **Option** | **Type** | **Default value** | **Description** |
+| --- | --- | --- | --- |
+| `tokens` | `boolean` | `false` | When `true`, the returned object will include an array of tokens (objects), representing each path "segment" in the scanned glob pattern |
+| `parts` | `boolean` | `false` | When `true`, the returned object will include an array of strings representing each path "segment" in the scanned glob pattern. This is automatically enabled when `options.tokens` is true |
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+const result = picomatch.scan('!./foo/*.js', { tokens: true });
+console.log(result);
+// {
+//   prefix: '!./',
+//   input: '!./foo/*.js',
+//   start: 3,
+//   base: 'foo',
+//   glob: '*.js',
+//   isBrace: false,
+//   isBracket: false,
+//   isGlob: true,
+//   isExtglob: false,
+//   isGlobstar: false,
+//   negated: true,
+//   maxDepth: 2,
+//   tokens: [
+//     { value: '!./', depth: 0, isGlob: false, negated: true, isPrefix: true },
+//     { value: 'foo', depth: 1, isGlob: false },
+//     { value: '*.js', depth: 1, isGlob: true }
+//   ],
+//   slashes: [ 2, 6 ],
+//   parts: [ 'foo', '*.js' ]
+// }
+```
+
+<br>
+
+### Options Examples
+
+#### options.expandRange
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+Custom function for expanding ranges in brace patterns. The [fill-range](https://github.com/jonschlinkert/fill-range) library is ideal for this purpose, or you can use custom code to do whatever you need.
+
+**Example**
+
+The following example shows how to create a glob that matches a folder
+
+```js
+const fill = require('fill-range');
+const regex = pm.makeRe('foo/{01..25}/bar', {
+  expandRange(a, b) {
+    return `(${fill(a, b, { toRegex: true })})`;
+  }
+});
+
+console.log(regex);
+//=> /^(?:foo\/((?:0[1-9]|1[0-9]|2[0-5]))\/bar)$/
+
+console.log(regex.test('foo/00/bar'))  // false
+console.log(regex.test('foo/01/bar'))  // true
+console.log(regex.test('foo/10/bar')) // true
+console.log(regex.test('foo/22/bar')) // true
+console.log(regex.test('foo/25/bar')) // true
+console.log(regex.test('foo/26/bar')) // false
+```
+
+#### options.format
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+Custom function for formatting strings before they're matched.
+
+**Example**
+
+```js
+// strip leading './' from strings
+const format = str => str.replace(/^\.\//, '');
+const isMatch = picomatch('foo/*.js', { format });
+console.log(isMatch('./foo/bar.js')); //=> true
+```
+
+#### options.onMatch
+
+```js
+const onMatch = ({ glob, regex, input, output }) => {
+  console.log({ glob, regex, input, output });
+};
+
+const isMatch = picomatch('*', { onMatch });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+#### options.onIgnore
+
+```js
+const onIgnore = ({ glob, regex, input, output }) => {
+  console.log({ glob, regex, input, output });
+};
+
+const isMatch = picomatch('*', { onIgnore, ignore: 'f*' });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+#### options.onResult
+
+```js
+const onResult = ({ glob, regex, input, output }) => {
+  console.log({ glob, regex, input, output });
+};
+
+const isMatch = picomatch('*', { onResult, ignore: 'f*' });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+<br>
+<br>
+
+## Globbing features
+
+* [Basic globbing](#basic-globbing) (Wildcard matching)
+* [Advanced globbing](#advanced-globbing) (extglobs, posix brackets, brace matching)
+
+### Basic globbing
+
+| **Character** | **Description** |
+| --- | --- |
+| `*` | Matches any character zero or more times, excluding path separators. Does _not match_ path separators or hidden files or directories ("dotfiles"), unless explicitly enabled by setting the `dot` option to `true`. |
+| `**` | Matches any character zero or more times, including path separators. Note that `**` will only match path separators (`/`, and `\\` with the `windows` option) when they are the only characters in a path segment. Thus, `foo**/bar` is equivalent to `foo*/bar`, and `foo/a**b/bar` is equivalent to `foo/a*b/bar`, and _more than two_ consecutive stars in a glob path segment are regarded as _a single star_. Thus, `foo/***/bar` is equivalent to `foo/*/bar`. |
+| `?` | Matches any character excluding path separators one time. Does _not match_ path separators or leading dots.  |
+| `[abc]` | Matches any characters inside the brackets. For example, `[abc]` would match the characters `a`, `b` or `c`, and nothing else. |
+
+#### Matching behavior vs. Bash
+
+Picomatch's matching features and expected results in unit tests are based on Bash's unit tests and the Bash 4.3 specification, with the following exceptions:
+
+* Bash will match `foo/bar/baz` with `*`. Picomatch only matches nested directories with `**`.
+* Bash greedily matches with negated extglobs. For example, Bash 4.3 says that `!(foo)*` should match `foo` and `foobar`, since the trailing `*` bracktracks to match the preceding pattern. This is very memory-inefficient, and IMHO, also incorrect. Picomatch would return `false` for both `foo` and `foobar`.
+
+<br>
+
+### Advanced globbing
+
+* [extglobs](#extglobs)
+* [POSIX brackets](#posix-brackets)
+* [Braces](#brace-expansion)
+
+#### Extglobs
+
+| **Pattern** | **Description** |
+| --- | --- |
+| `@(pattern)` | Match _only one_ consecutive occurrence of `pattern` |
+| `*(pattern)` | Match _zero or more_ consecutive occurrences of `pattern` |
+| `+(pattern)` | Match _one or more_ consecutive occurrences of `pattern` |
+| `?(pattern)` | Match _zero or **one**_ consecutive occurrences of `pattern` |
+| `!(pattern)` | Match _anything but_ `pattern` |
+
+**Examples**
+
+```js
+const pm = require('picomatch');
+
+// *(pattern) matches ZERO or more of "pattern"
+console.log(pm.isMatch('a', 'a*(z)')); // true
+console.log(pm.isMatch('az', 'a*(z)')); // true
+console.log(pm.isMatch('azzz', 'a*(z)')); // true
+
+// +(pattern) matches ONE or more of "pattern"
+console.log(pm.isMatch('a', 'a+(z)')); // false
+console.log(pm.isMatch('az', 'a+(z)')); // true
+console.log(pm.isMatch('azzz', 'a+(z)')); // true
+
+// supports multiple extglobs
+console.log(pm.isMatch('foo.bar', '!(foo).!(bar)')); // false
+
+// supports nested extglobs
+console.log(pm.isMatch('foo.bar', '!(!(foo)).!(!(bar))')); // true
+
+// risky quantified extglobs are treated literally by default
+console.log(pm.makeRe('+(a|aa)'));
+//=> /^(?:\+\(a\|aa\))$/
+
+// increase the limit to allow a small amount of nested quantified extglobs
+console.log(pm.isMatch('aaa', '+(+(a))', { maxExtglobRecursion: 1 })); // true
+```
+
+#### POSIX brackets
+
+POSIX classes are disabled by default. Enable this feature by setting the `posix` option to true.
+
+**Enable POSIX bracket support**
+
+```js
+console.log(pm.makeRe('[[:word:]]+', { posix: true }));
+//=> /^(?:(?=.)[A-Za-z0-9_]+\/?)$/
+```
+
+**Supported POSIX classes**
+
+The following named POSIX bracket expressions are supported:
+
+* `[:alnum:]` - Alphanumeric characters, equ `[a-zA-Z0-9]`
+* `[:alpha:]` - Alphabetical characters, equivalent to `[a-zA-Z]`.
+* `[:ascii:]` - ASCII characters, equivalent to `[\\x00-\\x7F]`.
+* `[:blank:]` - Space and tab characters, equivalent to `[ \\t]`.
+* `[:cntrl:]` - Control characters, equivalent to `[\\x00-\\x1F\\x7F]`.
+* `[:digit:]` - Numerical digits, equivalent to `[0-9]`.
+* `[:graph:]` - Graph characters, equivalent to `[\\x21-\\x7E]`.
+* `[:lower:]` - Lowercase letters, equivalent to `[a-z]`.
+* `[:print:]` - Print characters, equivalent to `[\\x20-\\x7E ]`.
+* `[:punct:]` - Punctuation and symbols, equivalent to `[\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~]`.
+* `[:space:]` - Extended space characters, equivalent to `[ \\t\\r\\n\\v\\f]`.
+* `[:upper:]` - Uppercase letters, equivalent to `[A-Z]`.
+* `[:word:]` -  Word characters (letters, numbers and underscores), equivalent to `[A-Za-z0-9_]`.
+* `[:xdigit:]` - Hexadecimal digits, equivalent to `[A-Fa-f0-9]`.
+
+See the [Bash Reference Manual](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html) for more information.
+
+### Braces
+
+Picomatch only does [brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html) of comma-delimited lists (e.g. `a/{b,c}/d`). For advanced matching with braces, use [micromatch](https://github.com/micromatch/micromatch), which supports advanced syntax such as ranges (e.g. `{01..03}`) and increments (e.g. `{2..10..2}`).
+
+### Matching special characters as literals
+
+If you wish to match the following special characters in a filepath, and you want to use these characters in your glob pattern, they must be escaped with backslashes or quotes:
+
+**Special Characters**
+
+Some characters that are used for matching in regular expressions are also regarded as valid file path characters on some platforms.
+
+To match any of the following characters as literals: `$^*+?()[]
+
+Examples:
+
+```js
+console.log(pm.makeRe('foo/bar \\(1\\)'));
+console.log(pm.makeRe('foo/bar \\(1\\)'));
+```
+
+<br>
+<br>
+
+## Library Comparisons
+
+The following table shows which features are supported by [minimatch](https://github.com/isaacs/minimatch), [micromatch](https://github.com/micromatch/micromatch), [picomatch](https://github.com/micromatch/picomatch), [nanomatch](https://github.com/micromatch/nanomatch), [extglob](https://github.com/micromatch/extglob), [braces](https://github.com/micromatch/braces), and [expand-brackets](https://github.com/micromatch/expand-brackets).
+
+| **Feature** | `minimatch` | `micromatch` | `picomatch` | `nanomatch` | `extglob` | `braces` | `expand-brackets` |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| Wildcard matching (`*?+`) | ✔ | ✔ | ✔ | ✔ | - | - | - |
+| Advancing globbing        | ✔ | ✔ | ✔ | - | - | - | - |
+| Brace _matching_          | ✔ | ✔ | ✔ | - | - | ✔ | - |
+| Brace _expansion_         | ✔ | ✔ | - | - | - | ✔ | - |
+| Extglobs                  | partial | ✔ | ✔ | - | ✔ | - | - |
+| Posix brackets            | - | ✔ | ✔ | - | - | - | ✔ |
+| Regular expression syntax | - | ✔ | ✔ | ✔ | ✔ | - | ✔ |
+| File system operations    | - | - | - | - | - | - | - |
+
+<br>
+<br>
+
+## Benchmarks
+
+Performance comparison of picomatch and minimatch.
+
+```
+# .makeRe star (*)
+  picomatch x 3,251,247 ops/sec ±0.25% (95 runs sampled)
+  minimatch x 497,224 ops/sec ±0.11% (100 runs sampled)
+
+# .makeRe star; dot=true (*)
+  picomatch x 2,624,035 ops/sec ±0.16% (98 runs sampled)
+  minimatch x 446,244 ops/sec ±0.63% (99 runs sampled)
+
+# .makeRe globstar (**)
+  picomatch x 2,524,465 ops/sec ±0.13% (99 runs sampled)
+  minimatch x 1,396,257 ops/sec ±0.58% (96 runs sampled)
+
+# .makeRe globstars (**/**/**)
+  picomatch x 2,545,674 ops/sec ±0.10% (99 runs sampled)
+  minimatch x 1,196,835 ops/sec ±0.63% (98 runs sampled)
+
+# .makeRe with leading star (*.txt)
+  picomatch x 2,537,708 ops/sec ±0.11% (100 runs sampled)
+  minimatch x 345,284 ops/sec ±0.64% (96 runs sampled)
+
+# .makeRe - basic braces ({a,b,c}*.txt)
+  picomatch x 505,430 ops/sec ±1.04% (94 runs sampled)
+  minimatch x 107,991 ops/sec ±0.54% (99 runs sampled)
+
+# .makeRe - short ranges ({a..z}*.txt)
+  picomatch x 371,179 ops/sec ±2.91% (77 runs sampled)
+  minimatch x 14,104 ops/sec ±0.61% (99 runs sampled)
+
+# .makeRe - medium ranges ({1..100000}*.txt)
+  picomatch x 384,958 ops/sec ±1.70% (82 runs sampled)
+  minimatch x 2.55 ops/sec ±3.22% (11 runs sampled)
+
+# .makeRe - long ranges ({1..10000000}*.txt)
+  picomatch x 382,552 ops/sec ±1.52% (71 runs sampled)
+  minimatch x 0.83 ops/sec ±5.67% (7 runs sampled))
+```
+
+<br>
+<br>
+
+## Philosophies
+
+The goal of this library is to be blazing fast, without compromising on accuracy.
+
+**Accuracy**
+
+The number one of goal of this library is accuracy. However, it's not unusual for different glob implementations to have different rules for matching behavior, even with simple wildcard matching. It gets increasingly more complicated when combinations of different features are combined, like when extglobs are combined with globstars, braces, slashes, and so on: `!(**/{a,b,*/c})`.
+
+Thus, given that there is no canonical glob specification to use as a single source of truth when differences of opinion arise regarding behavior, sometimes we have to implement our best judgement and rely on feedback from users to make improvements.
+
+**Performance**
+
+Although this library performs well in benchmarks, and in most cases it's faster than other popular libraries we benchmarked against, we will always choose accuracy over performance. It's not helpful to anyone if our library is faster at returning the wrong answer.
+
+<br>
+<br>
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2017-present, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/index.js b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/index.js
new file mode 100644
index 0000000..a753b1d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/index.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const pico = require('./lib/picomatch');
+const utils = require('./lib/utils');
+
+function picomatch(glob, options, returnState = false) {
+  // default to os.platform()
+  if (options && (options.windows === null || options.windows === undefined)) {
+    // don't mutate the original options object
+    options = { ...options, windows: utils.isWindows() };
+  }
+
+  return pico(glob, options, returnState);
+}
+
+Object.assign(picomatch, pico);
+module.exports = picomatch;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/constants.js b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/constants.js
new file mode 100644
index 0000000..f0aeda7
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/constants.js
@@ -0,0 +1,184 @@
+'use strict';
+
+const WIN_SLASH = '\\\\/';
+const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
+
+/**
+ * Posix glob regex
+ */
+
+const DOT_LITERAL = '\\.';
+const PLUS_LITERAL = '\\+';
+const QMARK_LITERAL = '\\?';
+const SLASH_LITERAL = '\\/';
+const ONE_CHAR = '(?=.)';
+const QMARK = '[^/]';
+const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+const NO_DOT = `(?!${DOT_LITERAL})`;
+const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+const STAR = `${QMARK}*?`;
+const SEP = '/';
+
+const POSIX_CHARS = {
+  DOT_LITERAL,
+  PLUS_LITERAL,
+  QMARK_LITERAL,
+  SLASH_LITERAL,
+  ONE_CHAR,
+  QMARK,
+  END_ANCHOR,
+  DOTS_SLASH,
+  NO_DOT,
+  NO_DOTS,
+  NO_DOT_SLASH,
+  NO_DOTS_SLASH,
+  QMARK_NO_DOT,
+  STAR,
+  START_ANCHOR,
+  SEP
+};
+
+/**
+ * Windows glob regex
+ */
+
+const WINDOWS_CHARS = {
+  ...POSIX_CHARS,
+
+  SLASH_LITERAL: `[${WIN_SLASH}]`,
+  QMARK: WIN_NO_SLASH,
+  STAR: `${WIN_NO_SLASH}*?`,
+  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+  NO_DOT: `(?!${DOT_LITERAL})`,
+  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+  SEP: '\\'
+};
+
+/**
+ * POSIX Bracket Regex
+ */
+
+const POSIX_REGEX_SOURCE = {
+  __proto__: null,
+  alnum: 'a-zA-Z0-9',
+  alpha: 'a-zA-Z',
+  ascii: '\\x00-\\x7F',
+  blank: ' \\t',
+  cntrl: '\\x00-\\x1F\\x7F',
+  digit: '0-9',
+  graph: '\\x21-\\x7E',
+  lower: 'a-z',
+  print: '\\x20-\\x7E ',
+  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+  space: ' \\t\\r\\n\\v\\f',
+  upper: 'A-Z',
+  word: 'A-Za-z0-9_',
+  xdigit: 'A-Fa-f0-9'
+};
+
+module.exports = {
+  DEFAULT_MAX_EXTGLOB_RECURSION,
+  MAX_LENGTH: 1024 * 64,
+  POSIX_REGEX_SOURCE,
+
+  // regular expressions
+  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+  // Replace globs with equivalent patterns to reduce parsing time.
+  REPLACEMENTS: {
+    __proto__: null,
+    '***': '*',
+    '**/**': '**',
+    '**/**/**': '**'
+  },
+
+  // Digits
+  CHAR_0: 48, /* 0 */
+  CHAR_9: 57, /* 9 */
+
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 65, /* A */
+  CHAR_LOWERCASE_A: 97, /* a */
+  CHAR_UPPERCASE_Z: 90, /* Z */
+  CHAR_LOWERCASE_Z: 122, /* z */
+
+  CHAR_LEFT_PARENTHESES: 40, /* ( */
+  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+  CHAR_ASTERISK: 42, /* * */
+
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: 38, /* & */
+  CHAR_AT: 64, /* @ */
+  CHAR_BACKWARD_SLASH: 92, /* \ */
+  CHAR_CARRIAGE_RETURN: 13, /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+  CHAR_COLON: 58, /* : */
+  CHAR_COMMA: 44, /* , */
+  CHAR_DOT: 46, /* . */
+  CHAR_DOUBLE_QUOTE: 34, /* " */
+  CHAR_EQUAL: 61, /* = */
+  CHAR_EXCLAMATION_MARK: 33, /* ! */
+  CHAR_FORM_FEED: 12, /* \f */
+  CHAR_FORWARD_SLASH: 47, /* / */
+  CHAR_GRAVE_ACCENT: 96, /* ` */
+  CHAR_HASH: 35, /* # */
+  CHAR_HYPHEN_MINUS: 45, /* - */
+  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+  CHAR_LINE_FEED: 10, /* \n */
+  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+  CHAR_PERCENT: 37, /* % */
+  CHAR_PLUS: 43, /* + */
+  CHAR_QUESTION_MARK: 63, /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+  CHAR_SEMICOLON: 59, /* ; */
+  CHAR_SINGLE_QUOTE: 39, /* ' */
+  CHAR_SPACE: 32, /*   */
+  CHAR_TAB: 9, /* \t */
+  CHAR_UNDERSCORE: 95, /* _ */
+  CHAR_VERTICAL_LINE: 124, /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+  /**
+   * Create EXTGLOB_CHARS
+   */
+
+  extglobChars(chars) {
+    return {
+      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+      '?': { type: 'qmark', open: '(?:', close: ')?' },
+      '+': { type: 'plus', open: '(?:', close: ')+' },
+      '*': { type: 'star', open: '(?:', close: ')*' },
+      '@': { type: 'at', open: '(?:', close: ')' }
+    };
+  },
+
+  /**
+   * Create GLOB_CHARS
+   */
+
+  globChars(win32) {
+    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+  }
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/parse.js b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/parse.js
new file mode 100644
index 0000000..57d994a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/parse.js
@@ -0,0 +1,1386 @@
+'use strict';
+
+const constants = require('./constants');
+const utils = require('./utils');
+
+/**
+ * Constants
+ */
+
+const {
+  MAX_LENGTH,
+  POSIX_REGEX_SOURCE,
+  REGEX_NON_SPECIAL_CHARS,
+  REGEX_SPECIAL_CHARS_BACKREF,
+  REPLACEMENTS
+} = constants;
+
+/**
+ * Helpers
+ */
+
+const expandRange = (args, options) => {
+  if (typeof options.expandRange === 'function') {
+    return options.expandRange(...args, options);
+  }
+
+  args.sort();
+  const value = `[${args.join('-')}]`;
+
+  try {
+    /* eslint-disable-next-line no-new */
+    new RegExp(value);
+  } catch (ex) {
+    return args.map(v => utils.escapeRegex(v)).join('..');
+  }
+
+  return value;
+};
+
+/**
+ * Create the message for a syntax error
+ */
+
+const syntaxError = (type, char) => {
+  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+};
+
+const splitTopLevel = input => {
+  const parts = [];
+  let bracket = 0;
+  let paren = 0;
+  let quote = 0;
+  let value = '';
+  let escaped = false;
+
+  for (const ch of input) {
+    if (escaped === true) {
+      value += ch;
+      escaped = false;
+      continue;
+    }
+
+    if (ch === '\\') {
+      value += ch;
+      escaped = true;
+      continue;
+    }
+
+    if (ch === '"') {
+      quote = quote === 1 ? 0 : 1;
+      value += ch;
+      continue;
+    }
+
+    if (quote === 0) {
+      if (ch === '[') {
+        bracket++;
+      } else if (ch === ']' && bracket > 0) {
+        bracket--;
+      } else if (bracket === 0) {
+        if (ch === '(') {
+          paren++;
+        } else if (ch === ')' && paren > 0) {
+          paren--;
+        } else if (ch === '|' && paren === 0) {
+          parts.push(value);
+          value = '';
+          continue;
+        }
+      }
+    }
+
+    value += ch;
+  }
+
+  parts.push(value);
+  return parts;
+};
+
+const isPlainBranch = branch => {
+  let escaped = false;
+
+  for (const ch of branch) {
+    if (escaped === true) {
+      escaped = false;
+      continue;
+    }
+
+    if (ch === '\\') {
+      escaped = true;
+      continue;
+    }
+
+    if (/[?*+@!()[\]{}]/.test(ch)) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+const normalizeSimpleBranch = branch => {
+  let value = branch.trim();
+  let changed = true;
+
+  while (changed === true) {
+    changed = false;
+
+    if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+      value = value.slice(2, -1);
+      changed = true;
+    }
+  }
+
+  if (!isPlainBranch(value)) {
+    return;
+  }
+
+  return value.replace(/\\(.)/g, '$1');
+};
+
+const hasRepeatedCharPrefixOverlap = branches => {
+  const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+
+  for (let i = 0; i < values.length; i++) {
+    for (let j = i + 1; j < values.length; j++) {
+      const a = values[i];
+      const b = values[j];
+      const char = a[0];
+
+      if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+        continue;
+      }
+
+      if (a === b || a.startsWith(b) || b.startsWith(a)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+const parseRepeatedExtglob = (pattern, requireEnd = true) => {
+  if ((pattern[0] !== '+' && pattern[0] !== '*') || pattern[1] !== '(') {
+    return;
+  }
+
+  let bracket = 0;
+  let paren = 0;
+  let quote = 0;
+  let escaped = false;
+
+  for (let i = 1; i < pattern.length; i++) {
+    const ch = pattern[i];
+
+    if (escaped === true) {
+      escaped = false;
+      continue;
+    }
+
+    if (ch === '\\') {
+      escaped = true;
+      continue;
+    }
+
+    if (ch === '"') {
+      quote = quote === 1 ? 0 : 1;
+      continue;
+    }
+
+    if (quote === 1) {
+      continue;
+    }
+
+    if (ch === '[') {
+      bracket++;
+      continue;
+    }
+
+    if (ch === ']' && bracket > 0) {
+      bracket--;
+      continue;
+    }
+
+    if (bracket > 0) {
+      continue;
+    }
+
+    if (ch === '(') {
+      paren++;
+      continue;
+    }
+
+    if (ch === ')') {
+      paren--;
+
+      if (paren === 0) {
+        if (requireEnd === true && i !== pattern.length - 1) {
+          return;
+        }
+
+        return {
+          type: pattern[0],
+          body: pattern.slice(2, i),
+          end: i
+        };
+      }
+    }
+  }
+};
+
+const getStarExtglobSequenceOutput = pattern => {
+  let index = 0;
+  const chars = [];
+
+  while (index < pattern.length) {
+    const match = parseRepeatedExtglob(pattern.slice(index), false);
+
+    if (!match || match.type !== '*') {
+      return;
+    }
+
+    const branches = splitTopLevel(match.body).map(branch => branch.trim());
+    if (branches.length !== 1) {
+      return;
+    }
+
+    const branch = normalizeSimpleBranch(branches[0]);
+    if (!branch || branch.length !== 1) {
+      return;
+    }
+
+    chars.push(branch);
+    index += match.end + 1;
+  }
+
+  if (chars.length < 1) {
+    return;
+  }
+
+  const source = chars.length === 1
+    ? utils.escapeRegex(chars[0])
+    : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`;
+
+  return `${source}*`;
+};
+
+const repeatedExtglobRecursion = pattern => {
+  let depth = 0;
+  let value = pattern.trim();
+  let match = parseRepeatedExtglob(value);
+
+  while (match) {
+    depth++;
+    value = match.body.trim();
+    match = parseRepeatedExtglob(value);
+  }
+
+  return depth;
+};
+
+const analyzeRepeatedExtglob = (body, options) => {
+  if (options.maxExtglobRecursion === false) {
+    return { risky: false };
+  }
+
+  const max =
+    typeof options.maxExtglobRecursion === 'number'
+      ? options.maxExtglobRecursion
+      : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+
+  const branches = splitTopLevel(body).map(branch => branch.trim());
+
+  if (branches.length > 1) {
+    if (
+      branches.some(branch => branch === '') ||
+      branches.some(branch => /^[*?]+$/.test(branch)) ||
+      hasRepeatedCharPrefixOverlap(branches)
+    ) {
+      return { risky: true };
+    }
+  }
+
+  for (const branch of branches) {
+    const safeOutput = getStarExtglobSequenceOutput(branch);
+    if (safeOutput) {
+      return { risky: true, safeOutput };
+    }
+
+    if (repeatedExtglobRecursion(branch) > max) {
+      return { risky: true };
+    }
+  }
+
+  return { risky: false };
+};
+
+/**
+ * Parse the given input string.
+ * @param {String} input
+ * @param {Object} options
+ * @return {Object}
+ */
+
+const parse = (input, options) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+
+  input = REPLACEMENTS[input] || input;
+
+  const opts = { ...options };
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+
+  let len = input.length;
+  if (len > max) {
+    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+  }
+
+  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+  const tokens = [bos];
+
+  const capture = opts.capture ? '' : '?:';
+
+  // create constants based on platform, for windows or posix
+  const PLATFORM_CHARS = constants.globChars(opts.windows);
+  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+
+  const {
+    DOT_LITERAL,
+    PLUS_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOT_SLASH,
+    NO_DOTS_SLASH,
+    QMARK,
+    QMARK_NO_DOT,
+    STAR,
+    START_ANCHOR
+  } = PLATFORM_CHARS;
+
+  const globstar = opts => {
+    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+  };
+
+  const nodot = opts.dot ? '' : NO_DOT;
+  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+  let star = opts.bash === true ? globstar(opts) : STAR;
+
+  if (opts.capture) {
+    star = `(${star})`;
+  }
+
+  // minimatch options support
+  if (typeof opts.noext === 'boolean') {
+    opts.noextglob = opts.noext;
+  }
+
+  const state = {
+    input,
+    index: -1,
+    start: 0,
+    dot: opts.dot === true,
+    consumed: '',
+    output: '',
+    prefix: '',
+    backtrack: false,
+    negated: false,
+    brackets: 0,
+    braces: 0,
+    parens: 0,
+    quotes: 0,
+    globstar: false,
+    tokens
+  };
+
+  input = utils.removePrefix(input, state);
+  len = input.length;
+
+  const extglobs = [];
+  const braces = [];
+  const stack = [];
+  let prev = bos;
+  let value;
+
+  /**
+   * Tokenizing helpers
+   */
+
+  const eos = () => state.index === len - 1;
+  const peek = state.peek = (n = 1) => input[state.index + n];
+  const advance = state.advance = () => input[++state.index] || '';
+  const remaining = () => input.slice(state.index + 1);
+  const consume = (value = '', num = 0) => {
+    state.consumed += value;
+    state.index += num;
+  };
+
+  const append = token => {
+    state.output += token.output != null ? token.output : token.value;
+    consume(token.value);
+  };
+
+  const negate = () => {
+    let count = 1;
+
+    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+      advance();
+      state.start++;
+      count++;
+    }
+
+    if (count % 2 === 0) {
+      return false;
+    }
+
+    state.negated = true;
+    state.start++;
+    return true;
+  };
+
+  const increment = type => {
+    state[type]++;
+    stack.push(type);
+  };
+
+  const decrement = type => {
+    state[type]--;
+    stack.pop();
+  };
+
+  /**
+   * Push tokens onto the tokens array. This helper speeds up
+   * tokenizing by 1) helping us avoid backtracking as much as possible,
+   * and 2) helping us avoid creating extra tokens when consecutive
+   * characters are plain text. This improves performance and simplifies
+   * lookbehinds.
+   */
+
+  const push = tok => {
+    if (prev.type === 'globstar') {
+      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+        state.output = state.output.slice(0, -prev.output.length);
+        prev.type = 'star';
+        prev.value = '*';
+        prev.output = star;
+        state.output += prev.output;
+      }
+    }
+
+    if (extglobs.length && tok.type !== 'paren') {
+      extglobs[extglobs.length - 1].inner += tok.value;
+    }
+
+    if (tok.value || tok.output) append(tok);
+    if (prev && prev.type === 'text' && tok.type === 'text') {
+      prev.output = (prev.output || prev.value) + tok.value;
+      prev.value += tok.value;
+      return;
+    }
+
+    tok.prev = prev;
+    tokens.push(tok);
+    prev = tok;
+  };
+
+  const extglobOpen = (type, value) => {
+    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+    token.prev = prev;
+    token.parens = state.parens;
+    token.output = state.output;
+    token.startIndex = state.index;
+    token.tokensIndex = tokens.length;
+    const output = (opts.capture ? '(' : '') + token.open;
+
+    increment('parens');
+    push({ type, value, output: state.output ? '' : ONE_CHAR });
+    push({ type: 'paren', extglob: true, value: advance(), output });
+    extglobs.push(token);
+  };
+
+  const extglobClose = token => {
+    const literal = input.slice(token.startIndex, state.index + 1);
+    const body = input.slice(token.startIndex + 2, state.index);
+    const analysis = analyzeRepeatedExtglob(body, opts);
+
+    if ((token.type === 'plus' || token.type === 'star') && analysis.risky) {
+      const safeOutput = analysis.safeOutput
+        ? (token.output ? '' : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput)
+        : undefined;
+      const open = tokens[token.tokensIndex];
+
+      open.type = 'text';
+      open.value = literal;
+      open.output = safeOutput || utils.escapeRegex(literal);
+
+      for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
+        tokens[i].value = '';
+        tokens[i].output = '';
+        delete tokens[i].suffix;
+      }
+
+      state.output = token.output + open.output;
+      state.backtrack = true;
+
+      push({ type: 'paren', extglob: true, value, output: '' });
+      decrement('parens');
+      return;
+    }
+
+    let output = token.close + (opts.capture ? ')' : '');
+    let rest;
+
+    if (token.type === 'negate') {
+      let extglobStar = star;
+
+      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+        extglobStar = globstar(opts);
+      }
+
+      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+        output = token.close = `)$))${extglobStar}`;
+      }
+
+      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+        // In this case, we need to parse the string and use it in the output of the original pattern.
+        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+        //
+        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+        const expression = parse(rest, { ...options, fastpaths: false }).output;
+
+        output = token.close = `)${expression})${extglobStar})`;
+      }
+
+      if (token.prev.type === 'bos') {
+        state.negatedExtglob = true;
+      }
+    }
+
+    push({ type: 'paren', extglob: true, value, output });
+    decrement('parens');
+  };
+
+  /**
+   * Fast paths
+   */
+
+  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+    let backslashes = false;
+
+    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+      if (first === '\\') {
+        backslashes = true;
+        return m;
+      }
+
+      if (first === '?') {
+        if (esc) {
+          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+        }
+        if (index === 0) {
+          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+        }
+        return QMARK.repeat(chars.length);
+      }
+
+      if (first === '.') {
+        return DOT_LITERAL.repeat(chars.length);
+      }
+
+      if (first === '*') {
+        if (esc) {
+          return esc + first + (rest ? star : '');
+        }
+        return star;
+      }
+      return esc ? m : `\\${m}`;
+    });
+
+    if (backslashes === true) {
+      if (opts.unescape === true) {
+        output = output.replace(/\\/g, '');
+      } else {
+        output = output.replace(/\\+/g, m => {
+          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+        });
+      }
+    }
+
+    if (output === input && opts.contains === true) {
+      state.output = input;
+      return state;
+    }
+
+    state.output = utils.wrapOutput(output, state, options);
+    return state;
+  }
+
+  /**
+   * Tokenize input until we reach end-of-string
+   */
+
+  while (!eos()) {
+    value = advance();
+
+    if (value === '\u0000') {
+      continue;
+    }
+
+    /**
+     * Escaped characters
+     */
+
+    if (value === '\\') {
+      const next = peek();
+
+      if (next === '/' && opts.bash !== true) {
+        continue;
+      }
+
+      if (next === '.' || next === ';') {
+        continue;
+      }
+
+      if (!next) {
+        value += '\\';
+        push({ type: 'text', value });
+        continue;
+      }
+
+      // collapse slashes to reduce potential for exploits
+      const match = /^\\+/.exec(remaining());
+      let slashes = 0;
+
+      if (match && match[0].length > 2) {
+        slashes = match[0].length;
+        state.index += slashes;
+        if (slashes % 2 !== 0) {
+          value += '\\';
+        }
+      }
+
+      if (opts.unescape === true) {
+        value = advance();
+      } else {
+        value += advance();
+      }
+
+      if (state.brackets === 0) {
+        push({ type: 'text', value });
+        continue;
+      }
+    }
+
+    /**
+     * If we're inside a regex character class, continue
+     * until we reach the closing bracket.
+     */
+
+    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+      if (opts.posix !== false && value === ':') {
+        const inner = prev.value.slice(1);
+        if (inner.includes('[')) {
+          prev.posix = true;
+
+          if (inner.includes(':')) {
+            const idx = prev.value.lastIndexOf('[');
+            const pre = prev.value.slice(0, idx);
+            const rest = prev.value.slice(idx + 2);
+            const posix = POSIX_REGEX_SOURCE[rest];
+            if (posix) {
+              prev.value = pre + posix;
+              state.backtrack = true;
+              advance();
+
+              if (!bos.output && tokens.indexOf(prev) === 1) {
+                bos.output = ONE_CHAR;
+              }
+              continue;
+            }
+          }
+        }
+      }
+
+      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+        value = `\\${value}`;
+      }
+
+      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+        value = `\\${value}`;
+      }
+
+      if (opts.posix === true && value === '!' && prev.value === '[') {
+        value = '^';
+      }
+
+      prev.value += value;
+      append({ value });
+      continue;
+    }
+
+    /**
+     * If we're inside a quoted string, continue
+     * until we reach the closing double quote.
+     */
+
+    if (state.quotes === 1 && value !== '"') {
+      value = utils.escapeRegex(value);
+      prev.value += value;
+      append({ value });
+      continue;
+    }
+
+    /**
+     * Double quotes
+     */
+
+    if (value === '"') {
+      state.quotes = state.quotes === 1 ? 0 : 1;
+      if (opts.keepQuotes === true) {
+        push({ type: 'text', value });
+      }
+      continue;
+    }
+
+    /**
+     * Parentheses
+     */
+
+    if (value === '(') {
+      increment('parens');
+      push({ type: 'paren', value });
+      continue;
+    }
+
+    if (value === ')') {
+      if (state.parens === 0 && opts.strictBrackets === true) {
+        throw new SyntaxError(syntaxError('opening', '('));
+      }
+
+      const extglob = extglobs[extglobs.length - 1];
+      if (extglob && state.parens === extglob.parens + 1) {
+        extglobClose(extglobs.pop());
+        continue;
+      }
+
+      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+      decrement('parens');
+      continue;
+    }
+
+    /**
+     * Square brackets
+     */
+
+    if (value === '[') {
+      if (opts.nobracket === true || !remaining().includes(']')) {
+        if (opts.nobracket !== true && opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError('closing', ']'));
+        }
+
+        value = `\\${value}`;
+      } else {
+        increment('brackets');
+      }
+
+      push({ type: 'bracket', value });
+      continue;
+    }
+
+    if (value === ']') {
+      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+        push({ type: 'text', value, output: `\\${value}` });
+        continue;
+      }
+
+      if (state.brackets === 0) {
+        if (opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError('opening', '['));
+        }
+
+        push({ type: 'text', value, output: `\\${value}` });
+        continue;
+      }
+
+      decrement('brackets');
+
+      const prevValue = prev.value.slice(1);
+      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+        value = `/${value}`;
+      }
+
+      prev.value += value;
+      append({ value });
+
+      // when literal brackets are explicitly disabled
+      // assume we should match with a regex character class
+      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+        continue;
+      }
+
+      const escaped = utils.escapeRegex(prev.value);
+      state.output = state.output.slice(0, -prev.value.length);
+
+      // when literal brackets are explicitly enabled
+      // assume we should escape the brackets to match literal characters
+      if (opts.literalBrackets === true) {
+        state.output += escaped;
+        prev.value = escaped;
+        continue;
+      }
+
+      // when the user specifies nothing, try to match both
+      prev.value = `(${capture}${escaped}|${prev.value})`;
+      state.output += prev.value;
+      continue;
+    }
+
+    /**
+     * Braces
+     */
+
+    if (value === '{' && opts.nobrace !== true) {
+      increment('braces');
+
+      const open = {
+        type: 'brace',
+        value,
+        output: '(',
+        outputIndex: state.output.length,
+        tokensIndex: state.tokens.length
+      };
+
+      braces.push(open);
+      push(open);
+      continue;
+    }
+
+    if (value === '}') {
+      const brace = braces[braces.length - 1];
+
+      if (opts.nobrace === true || !brace) {
+        push({ type: 'text', value, output: value });
+        continue;
+      }
+
+      let output = ')';
+
+      if (brace.dots === true) {
+        const arr = tokens.slice();
+        const range = [];
+
+        for (let i = arr.length - 1; i >= 0; i--) {
+          tokens.pop();
+          if (arr[i].type === 'brace') {
+            break;
+          }
+          if (arr[i].type !== 'dots') {
+            range.unshift(arr[i].value);
+          }
+        }
+
+        output = expandRange(range, opts);
+        state.backtrack = true;
+      }
+
+      if (brace.comma !== true && brace.dots !== true) {
+        const out = state.output.slice(0, brace.outputIndex);
+        const toks = state.tokens.slice(brace.tokensIndex);
+        brace.value = brace.output = '\\{';
+        value = output = '\\}';
+        state.output = out;
+        for (const t of toks) {
+          state.output += (t.output || t.value);
+        }
+      }
+
+      push({ type: 'brace', value, output });
+      decrement('braces');
+      braces.pop();
+      continue;
+    }
+
+    /**
+     * Pipes
+     */
+
+    if (value === '|') {
+      if (extglobs.length > 0) {
+        extglobs[extglobs.length - 1].conditions++;
+      }
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Commas
+     */
+
+    if (value === ',') {
+      let output = value;
+
+      const brace = braces[braces.length - 1];
+      if (brace && stack[stack.length - 1] === 'braces') {
+        brace.comma = true;
+        output = '|';
+      }
+
+      push({ type: 'comma', value, output });
+      continue;
+    }
+
+    /**
+     * Slashes
+     */
+
+    if (value === '/') {
+      // if the beginning of the glob is "./", advance the start
+      // to the current index, and don't add the "./" characters
+      // to the state. This greatly simplifies lookbehinds when
+      // checking for BOS characters like "!" and "." (not "./")
+      if (prev.type === 'dot' && state.index === state.start + 1) {
+        state.start = state.index + 1;
+        state.consumed = '';
+        state.output = '';
+        tokens.pop();
+        prev = bos; // reset "prev" to the first token
+        continue;
+      }
+
+      push({ type: 'slash', value, output: SLASH_LITERAL });
+      continue;
+    }
+
+    /**
+     * Dots
+     */
+
+    if (value === '.') {
+      if (state.braces > 0 && prev.type === 'dot') {
+        if (prev.value === '.') prev.output = DOT_LITERAL;
+        const brace = braces[braces.length - 1];
+        prev.type = 'dots';
+        prev.output += value;
+        prev.value += value;
+        brace.dots = true;
+        continue;
+      }
+
+      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+        push({ type: 'text', value, output: DOT_LITERAL });
+        continue;
+      }
+
+      push({ type: 'dot', value, output: DOT_LITERAL });
+      continue;
+    }
+
+    /**
+     * Question marks
+     */
+
+    if (value === '?') {
+      const isGroup = prev && prev.value === '(';
+      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        extglobOpen('qmark', value);
+        continue;
+      }
+
+      if (prev && prev.type === 'paren') {
+        const next = peek();
+        let output = value;
+
+        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+          output = `\\${value}`;
+        }
+
+        push({ type: 'text', value, output });
+        continue;
+      }
+
+      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+        continue;
+      }
+
+      push({ type: 'qmark', value, output: QMARK });
+      continue;
+    }
+
+    /**
+     * Exclamation
+     */
+
+    if (value === '!') {
+      if (opts.noextglob !== true && peek() === '(') {
+        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+          extglobOpen('negate', value);
+          continue;
+        }
+      }
+
+      if (opts.nonegate !== true && state.index === 0) {
+        negate();
+        continue;
+      }
+    }
+
+    /**
+     * Plus
+     */
+
+    if (value === '+') {
+      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        extglobOpen('plus', value);
+        continue;
+      }
+
+      if ((prev && prev.value === '(') || opts.regex === false) {
+        push({ type: 'plus', value, output: PLUS_LITERAL });
+        continue;
+      }
+
+      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+        push({ type: 'plus', value });
+        continue;
+      }
+
+      push({ type: 'plus', value: PLUS_LITERAL });
+      continue;
+    }
+
+    /**
+     * Plain text
+     */
+
+    if (value === '@') {
+      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        push({ type: 'at', extglob: true, value, output: '' });
+        continue;
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Plain text
+     */
+
+    if (value !== '*') {
+      if (value === '$' || value === '^') {
+        value = `\\${value}`;
+      }
+
+      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+      if (match) {
+        value += match[0];
+        state.index += match[0].length;
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Stars
+     */
+
+    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+      prev.type = 'star';
+      prev.star = true;
+      prev.value += value;
+      prev.output = star;
+      state.backtrack = true;
+      state.globstar = true;
+      consume(value);
+      continue;
+    }
+
+    let rest = remaining();
+    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+      extglobOpen('star', value);
+      continue;
+    }
+
+    if (prev.type === 'star') {
+      if (opts.noglobstar === true) {
+        consume(value);
+        continue;
+      }
+
+      const prior = prev.prev;
+      const before = prior.prev;
+      const isStart = prior.type === 'slash' || prior.type === 'bos';
+      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+        push({ type: 'star', value, output: '' });
+        continue;
+      }
+
+      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+        push({ type: 'star', value, output: '' });
+        continue;
+      }
+
+      // strip consecutive `/**/`
+      while (rest.slice(0, 3) === '/**') {
+        const after = input[state.index + 4];
+        if (after && after !== '/') {
+          break;
+        }
+        rest = rest.slice(3);
+        consume('/**', 3);
+      }
+
+      if (prior.type === 'bos' && eos()) {
+        prev.type = 'globstar';
+        prev.value += value;
+        prev.output = globstar(opts);
+        state.output = prev.output;
+        state.globstar = true;
+        consume(value);
+        continue;
+      }
+
+      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+        prior.output = `(?:${prior.output}`;
+
+        prev.type = 'globstar';
+        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+        prev.value += value;
+        state.globstar = true;
+        state.output += prior.output + prev.output;
+        consume(value);
+        continue;
+      }
+
+      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+        const end = rest[1] !== void 0 ? '|$' : '';
+
+        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+        prior.output = `(?:${prior.output}`;
+
+        prev.type = 'globstar';
+        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+        prev.value += value;
+
+        state.output += prior.output + prev.output;
+        state.globstar = true;
+
+        consume(value + advance());
+
+        push({ type: 'slash', value: '/', output: '' });
+        continue;
+      }
+
+      if (prior.type === 'bos' && rest[0] === '/') {
+        prev.type = 'globstar';
+        prev.value += value;
+        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+        state.output = prev.output;
+        state.globstar = true;
+        consume(value + advance());
+        push({ type: 'slash', value: '/', output: '' });
+        continue;
+      }
+
+      // remove single star from output
+      state.output = state.output.slice(0, -prev.output.length);
+
+      // reset previous token to globstar
+      prev.type = 'globstar';
+      prev.output = globstar(opts);
+      prev.value += value;
+
+      // reset output with globstar
+      state.output += prev.output;
+      state.globstar = true;
+      consume(value);
+      continue;
+    }
+
+    const token = { type: 'star', value, output: star };
+
+    if (opts.bash === true) {
+      token.output = '.*?';
+      if (prev.type === 'bos' || prev.type === 'slash') {
+        token.output = nodot + token.output;
+      }
+      push(token);
+      continue;
+    }
+
+    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+      token.output = value;
+      push(token);
+      continue;
+    }
+
+    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+      if (prev.type === 'dot') {
+        state.output += NO_DOT_SLASH;
+        prev.output += NO_DOT_SLASH;
+
+      } else if (opts.dot === true) {
+        state.output += NO_DOTS_SLASH;
+        prev.output += NO_DOTS_SLASH;
+
+      } else {
+        state.output += nodot;
+        prev.output += nodot;
+      }
+
+      if (peek() !== '*') {
+        state.output += ONE_CHAR;
+        prev.output += ONE_CHAR;
+      }
+    }
+
+    push(token);
+  }
+
+  while (state.brackets > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+    state.output = utils.escapeLast(state.output, '[');
+    decrement('brackets');
+  }
+
+  while (state.parens > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+    state.output = utils.escapeLast(state.output, '(');
+    decrement('parens');
+  }
+
+  while (state.braces > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+    state.output = utils.escapeLast(state.output, '{');
+    decrement('braces');
+  }
+
+  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+  }
+
+  // rebuild the output if we had to backtrack at any point
+  if (state.backtrack === true) {
+    state.output = '';
+
+    for (const token of state.tokens) {
+      state.output += token.output != null ? token.output : token.value;
+
+      if (token.suffix) {
+        state.output += token.suffix;
+      }
+    }
+  }
+
+  return state;
+};
+
+/**
+ * Fast paths for creating regular expressions for common glob patterns.
+ * This can significantly speed up processing and has very little downside
+ * impact when none of the fast paths match.
+ */
+
+parse.fastpaths = (input, options) => {
+  const opts = { ...options };
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+  const len = input.length;
+  if (len > max) {
+    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+  }
+
+  input = REPLACEMENTS[input] || input;
+
+  // create constants based on platform, for windows or posix
+  const {
+    DOT_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOTS,
+    NO_DOTS_SLASH,
+    STAR,
+    START_ANCHOR
+  } = constants.globChars(opts.windows);
+
+  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+  const capture = opts.capture ? '' : '?:';
+  const state = { negated: false, prefix: '' };
+  let star = opts.bash === true ? '.*?' : STAR;
+
+  if (opts.capture) {
+    star = `(${star})`;
+  }
+
+  const globstar = opts => {
+    if (opts.noglobstar === true) return star;
+    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+  };
+
+  const create = str => {
+    switch (str) {
+      case '*':
+        return `${nodot}${ONE_CHAR}${star}`;
+
+      case '.*':
+        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      case '*.*':
+        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      case '*/*':
+        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+      case '**':
+        return nodot + globstar(opts);
+
+      case '**/*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+      case '**/*.*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      case '**/.*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      default: {
+        const match = /^(.*?)\.(\w+)$/.exec(str);
+        if (!match) return;
+
+        const source = create(match[1]);
+        if (!source) return;
+
+        return source + DOT_LITERAL + match[2];
+      }
+    }
+  };
+
+  const output = utils.removePrefix(input, state);
+  let source = create(output);
+
+  if (source && opts.strictSlashes !== true) {
+    source += `${SLASH_LITERAL}?`;
+  }
+
+  return source;
+};
+
+module.exports = parse;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/picomatch.js b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/picomatch.js
new file mode 100644
index 0000000..fbb8b1c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/picomatch.js
@@ -0,0 +1,349 @@
+'use strict';
+
+const scan = require('./scan');
+const parse = require('./parse');
+const utils = require('./utils');
+const constants = require('./constants');
+const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+
+/**
+ * Creates a matcher function from one or more glob patterns. The
+ * returned function takes a string to match as its first argument,
+ * and returns true if the string is a match. The returned matcher
+ * function also takes a boolean as the second argument that, when true,
+ * returns an object with additional information.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch(glob[, options]);
+ *
+ * const isMatch = picomatch('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @name picomatch
+ * @param {String|Array} `globs` One or more glob patterns.
+ * @param {Object=} `options`
+ * @return {Function=} Returns a matcher function.
+ * @api public
+ */
+
+const picomatch = (glob, options, returnState = false) => {
+  if (Array.isArray(glob)) {
+    const fns = glob.map(input => picomatch(input, options, returnState));
+    const arrayMatcher = str => {
+      for (const isMatch of fns) {
+        const state = isMatch(str);
+        if (state) return state;
+      }
+      return false;
+    };
+    return arrayMatcher;
+  }
+
+  const isState = isObject(glob) && glob.tokens && glob.input;
+
+  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+    throw new TypeError('Expected pattern to be a non-empty string');
+  }
+
+  const opts = options || {};
+  const posix = opts.windows;
+  const regex = isState
+    ? picomatch.compileRe(glob, options)
+    : picomatch.makeRe(glob, options, false, true);
+
+  const state = regex.state;
+  delete regex.state;
+
+  let isIgnored = () => false;
+  if (opts.ignore) {
+    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+  }
+
+  const matcher = (input, returnObject = false) => {
+    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+    if (typeof opts.onResult === 'function') {
+      opts.onResult(result);
+    }
+
+    if (isMatch === false) {
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
+
+    if (isIgnored(input)) {
+      if (typeof opts.onIgnore === 'function') {
+        opts.onIgnore(result);
+      }
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
+
+    if (typeof opts.onMatch === 'function') {
+      opts.onMatch(result);
+    }
+    return returnObject ? result : true;
+  };
+
+  if (returnState) {
+    matcher.state = state;
+  }
+
+  return matcher;
+};
+
+/**
+ * Test `input` with the given `regex`. This is used by the main
+ * `picomatch()` function to test the input string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.test(input, regex[, options]);
+ *
+ * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+ * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp} `regex`
+ * @return {Object} Returns an object with matching info.
+ * @api public
+ */
+
+picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected input to be a string');
+  }
+
+  if (input === '') {
+    return { isMatch: false, output: '' };
+  }
+
+  const opts = options || {};
+  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+  let match = input === glob;
+  let output = (match && format) ? format(input) : input;
+
+  if (match === false) {
+    output = format ? format(input) : input;
+    match = output === glob;
+  }
+
+  if (match === false || opts.capture === true) {
+    if (opts.matchBase === true || opts.basename === true) {
+      match = picomatch.matchBase(input, regex, options, posix);
+    } else {
+      match = regex.exec(output);
+    }
+  }
+
+  return { isMatch: Boolean(match), match, output };
+};
+
+/**
+ * Match the basename of a filepath.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.matchBase(input, glob[, options]);
+ * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+ * @return {Boolean}
+ * @api public
+ */
+
+picomatch.matchBase = (input, glob, options) => {
+  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+  return regex.test(utils.basename(input));
+};
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.isMatch(string, patterns[, options]);
+ *
+ * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String|Array} str The string to test.
+ * @param {String|Array} patterns One or more glob patterns to use for matching.
+ * @param {Object} [options] See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const result = picomatch.parse(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+ * @api public
+ */
+
+picomatch.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+  return parse(pattern, { ...options, fastpaths: false });
+};
+
+/**
+ * Scan a glob pattern to separate the pattern into segments.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.scan(input[, options]);
+ *
+ * const result = picomatch.scan('!./foo/*.js');
+ * console.log(result);
+ * { prefix: '!./',
+ *   input: '!./foo/*.js',
+ *   start: 3,
+ *   base: 'foo',
+ *   glob: '*.js',
+ *   isBrace: false,
+ *   isBracket: false,
+ *   isGlob: true,
+ *   isExtglob: false,
+ *   isGlobstar: false,
+ *   negated: true }
+ * ```
+ * @param {String} `input` Glob pattern to scan.
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+picomatch.scan = (input, options) => scan(input, options);
+
+/**
+ * Compile a regular expression from the `state` object returned by the
+ * [parse()](#parse) method.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const state = picomatch.parse('*.js');
+ * // picomatch.compileRe(state[, options]);
+ *
+ * console.log(picomatch.compileRe(state));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {Object} `state`
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+ * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+  if (returnOutput === true) {
+    return state.output;
+  }
+
+  const opts = options || {};
+  const prepend = opts.contains ? '' : '^';
+  const append = opts.contains ? '' : '$';
+
+  let source = `${prepend}(?:${state.output})${append}`;
+  if (state && state.negated === true) {
+    source = `^(?!${source}).*$`;
+  }
+
+  const regex = picomatch.toRegex(source, options);
+  if (returnState === true) {
+    regex.state = state;
+  }
+
+  return regex;
+};
+
+/**
+ * Create a regular expression from a parsed glob pattern.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.makeRe(state[, options]);
+ *
+ * const result = picomatch.makeRe('*.js');
+ * console.log(result);
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `state` The object returned from the `.parse` method.
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+ * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+  if (!input || typeof input !== 'string') {
+    throw new TypeError('Expected a non-empty string');
+  }
+
+  let parsed = { negated: false, fastpaths: true };
+
+  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+    parsed.output = parse.fastpaths(input, options);
+  }
+
+  if (!parsed.output) {
+    parsed = parse(input, options);
+  }
+
+  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+};
+
+/**
+ * Create a regular expression from the given regex source string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.toRegex(source[, options]);
+ *
+ * const { output } = picomatch.parse('*.js');
+ * console.log(picomatch.toRegex(output));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `source` Regular expression source string.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch.toRegex = (source, options) => {
+  try {
+    const opts = options || {};
+    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+  } catch (err) {
+    if (options && options.debug === true) throw err;
+    return /$^/;
+  }
+};
+
+/**
+ * Picomatch constants.
+ * @return {Object}
+ */
+
+picomatch.constants = constants;
+
+/**
+ * Expose "picomatch"
+ */
+
+module.exports = picomatch;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/scan.js b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/scan.js
new file mode 100644
index 0000000..e59cd7a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/scan.js
@@ -0,0 +1,391 @@
+'use strict';
+
+const utils = require('./utils');
+const {
+  CHAR_ASTERISK,             /* * */
+  CHAR_AT,                   /* @ */
+  CHAR_BACKWARD_SLASH,       /* \ */
+  CHAR_COMMA,                /* , */
+  CHAR_DOT,                  /* . */
+  CHAR_EXCLAMATION_MARK,     /* ! */
+  CHAR_FORWARD_SLASH,        /* / */
+  CHAR_LEFT_CURLY_BRACE,     /* { */
+  CHAR_LEFT_PARENTHESES,     /* ( */
+  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+  CHAR_PLUS,                 /* + */
+  CHAR_QUESTION_MARK,        /* ? */
+  CHAR_RIGHT_CURLY_BRACE,    /* } */
+  CHAR_RIGHT_PARENTHESES,    /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+} = require('./constants');
+
+const isPathSeparator = code => {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+};
+
+const depth = token => {
+  if (token.isPrefix !== true) {
+    token.depth = token.isGlobstar ? Infinity : 1;
+  }
+};
+
+/**
+ * Quickly scans a glob pattern and returns an object with a handful of
+ * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+ * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+ * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+ *
+ * ```js
+ * const pm = require('picomatch');
+ * console.log(pm.scan('foo/bar/*.js'));
+ * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with tokens and regex source string.
+ * @api public
+ */
+
+const scan = (input, options) => {
+  const opts = options || {};
+
+  const length = input.length - 1;
+  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+  const slashes = [];
+  const tokens = [];
+  const parts = [];
+
+  let str = input;
+  let index = -1;
+  let start = 0;
+  let lastIndex = 0;
+  let isBrace = false;
+  let isBracket = false;
+  let isGlob = false;
+  let isExtglob = false;
+  let isGlobstar = false;
+  let braceEscaped = false;
+  let backslashes = false;
+  let negated = false;
+  let negatedExtglob = false;
+  let finished = false;
+  let braces = 0;
+  let prev;
+  let code;
+  let token = { value: '', depth: 0, isGlob: false };
+
+  const eos = () => index >= length;
+  const peek = () => str.charCodeAt(index + 1);
+  const advance = () => {
+    prev = code;
+    return str.charCodeAt(++index);
+  };
+
+  while (index < length) {
+    code = advance();
+    let next;
+
+    if (code === CHAR_BACKWARD_SLASH) {
+      backslashes = token.backslashes = true;
+      code = advance();
+
+      if (code === CHAR_LEFT_CURLY_BRACE) {
+        braceEscaped = true;
+      }
+      continue;
+    }
+
+    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+      braces++;
+
+      while (eos() !== true && (code = advance())) {
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
+
+        if (code === CHAR_LEFT_CURLY_BRACE) {
+          braces++;
+          continue;
+        }
+
+        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+
+          if (scanToEnd === true) {
+            continue;
+          }
+
+          break;
+        }
+
+        if (braceEscaped !== true && code === CHAR_COMMA) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+
+          if (scanToEnd === true) {
+            continue;
+          }
+
+          break;
+        }
+
+        if (code === CHAR_RIGHT_CURLY_BRACE) {
+          braces--;
+
+          if (braces === 0) {
+            braceEscaped = false;
+            isBrace = token.isBrace = true;
+            finished = true;
+            break;
+          }
+        }
+      }
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+
+    if (code === CHAR_FORWARD_SLASH) {
+      slashes.push(index);
+      tokens.push(token);
+      token = { value: '', depth: 0, isGlob: false };
+
+      if (finished === true) continue;
+      if (prev === CHAR_DOT && index === (start + 1)) {
+        start += 2;
+        continue;
+      }
+
+      lastIndex = index + 1;
+      continue;
+    }
+
+    if (opts.noext !== true) {
+      const isExtglobChar = code === CHAR_PLUS
+        || code === CHAR_AT
+        || code === CHAR_ASTERISK
+        || code === CHAR_QUESTION_MARK
+        || code === CHAR_EXCLAMATION_MARK;
+
+      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+        isGlob = token.isGlob = true;
+        isExtglob = token.isExtglob = true;
+        finished = true;
+        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+          negatedExtglob = true;
+        }
+
+        if (scanToEnd === true) {
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              code = advance();
+              continue;
+            }
+
+            if (code === CHAR_RIGHT_PARENTHESES) {
+              isGlob = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+    }
+
+    if (code === CHAR_ASTERISK) {
+      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+      isGlob = token.isGlob = true;
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
+
+    if (code === CHAR_QUESTION_MARK) {
+      isGlob = token.isGlob = true;
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
+
+    if (code === CHAR_LEFT_SQUARE_BRACKET) {
+      while (eos() !== true && (next = advance())) {
+        if (next === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
+
+        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+          isBracket = token.isBracket = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+          break;
+        }
+      }
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+
+    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+      negated = token.negated = true;
+      start++;
+      continue;
+    }
+
+    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+      isGlob = token.isGlob = true;
+
+      if (scanToEnd === true) {
+        while (eos() !== true && (code = advance())) {
+          if (code === CHAR_LEFT_PARENTHESES) {
+            backslashes = token.backslashes = true;
+            code = advance();
+            continue;
+          }
+
+          if (code === CHAR_RIGHT_PARENTHESES) {
+            finished = true;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+
+    if (isGlob === true) {
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+  }
+
+  if (opts.noext === true) {
+    isExtglob = false;
+    isGlob = false;
+  }
+
+  let base = str;
+  let prefix = '';
+  let glob = '';
+
+  if (start > 0) {
+    prefix = str.slice(0, start);
+    str = str.slice(start);
+    lastIndex -= start;
+  }
+
+  if (base && isGlob === true && lastIndex > 0) {
+    base = str.slice(0, lastIndex);
+    glob = str.slice(lastIndex);
+  } else if (isGlob === true) {
+    base = '';
+    glob = str;
+  } else {
+    base = str;
+  }
+
+  if (base && base !== '' && base !== '/' && base !== str) {
+    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+      base = base.slice(0, -1);
+    }
+  }
+
+  if (opts.unescape === true) {
+    if (glob) glob = utils.removeBackslashes(glob);
+
+    if (base && backslashes === true) {
+      base = utils.removeBackslashes(base);
+    }
+  }
+
+  const state = {
+    prefix,
+    input,
+    start,
+    base,
+    glob,
+    isBrace,
+    isBracket,
+    isGlob,
+    isExtglob,
+    isGlobstar,
+    negated,
+    negatedExtglob
+  };
+
+  if (opts.tokens === true) {
+    state.maxDepth = 0;
+    if (!isPathSeparator(code)) {
+      tokens.push(token);
+    }
+    state.tokens = tokens;
+  }
+
+  if (opts.parts === true || opts.tokens === true) {
+    let prevIndex;
+
+    for (let idx = 0; idx < slashes.length; idx++) {
+      const n = prevIndex ? prevIndex + 1 : start;
+      const i = slashes[idx];
+      const value = input.slice(n, i);
+      if (opts.tokens) {
+        if (idx === 0 && start !== 0) {
+          tokens[idx].isPrefix = true;
+          tokens[idx].value = prefix;
+        } else {
+          tokens[idx].value = value;
+        }
+        depth(tokens[idx]);
+        state.maxDepth += tokens[idx].depth;
+      }
+      if (idx !== 0 || value !== '') {
+        parts.push(value);
+      }
+      prevIndex = i;
+    }
+
+    if (prevIndex && prevIndex + 1 < input.length) {
+      const value = input.slice(prevIndex + 1);
+      parts.push(value);
+
+      if (opts.tokens) {
+        tokens[tokens.length - 1].value = value;
+        depth(tokens[tokens.length - 1]);
+        state.maxDepth += tokens[tokens.length - 1].depth;
+      }
+    }
+
+    state.slashes = slashes;
+    state.parts = parts;
+  }
+
+  return state;
+};
+
+module.exports = scan;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/utils.js b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/utils.js
new file mode 100644
index 0000000..9c97cae
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/lib/utils.js
@@ -0,0 +1,72 @@
+/*global navigator*/
+'use strict';
+
+const {
+  REGEX_BACKSLASH,
+  REGEX_REMOVE_BACKSLASH,
+  REGEX_SPECIAL_CHARS,
+  REGEX_SPECIAL_CHARS_GLOBAL
+} = require('./constants');
+
+exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+exports.isWindows = () => {
+  if (typeof navigator !== 'undefined' && navigator.platform) {
+    const platform = navigator.platform.toLowerCase();
+    return platform === 'win32' || platform === 'windows';
+  }
+
+  if (typeof process !== 'undefined' && process.platform) {
+    return process.platform === 'win32';
+  }
+
+  return false;
+};
+
+exports.removeBackslashes = str => {
+  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+    return match === '\\' ? '' : match;
+  });
+};
+
+exports.escapeLast = (input, char, lastIdx) => {
+  const idx = input.lastIndexOf(char, lastIdx);
+  if (idx === -1) return input;
+  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+};
+
+exports.removePrefix = (input, state = {}) => {
+  let output = input;
+  if (output.startsWith('./')) {
+    output = output.slice(2);
+    state.prefix = './';
+  }
+  return output;
+};
+
+exports.wrapOutput = (input, state = {}, options = {}) => {
+  const prepend = options.contains ? '' : '^';
+  const append = options.contains ? '' : '$';
+
+  let output = `${prepend}(?:${input})${append}`;
+  if (state.negated === true) {
+    output = `(?:^(?!${output}).*$)`;
+  }
+  return output;
+};
+
+exports.basename = (path, { windows } = {}) => {
+  const segs = path.split(windows ? /[\\/]/ : '/');
+  const last = segs[segs.length - 1];
+
+  if (last === '') {
+    return segs[segs.length - 2];
+  }
+
+  return last;
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/package.json
new file mode 100644
index 0000000..9151f1d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/package.json
@@ -0,0 +1,82 @@
+{
+  "name": "picomatch",
+  "description": "Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.",
+  "version": "4.0.4",
+  "homepage": "https://github.com/micromatch/picomatch",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "funding": "https://github.com/sponsors/jonschlinkert",
+  "repository": "micromatch/picomatch",
+  "bugs": {
+    "url": "https://github.com/micromatch/picomatch/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js",
+    "posix.js",
+    "lib"
+  ],
+  "sideEffects": false,
+  "main": "index.js",
+  "engines": {
+    "node": ">=12"
+  },
+  "scripts": {
+    "lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .",
+    "mocha": "mocha --reporter dot",
+    "test": "npm run lint && npm run mocha",
+    "test:ci": "npm run test:cover",
+    "test:cover": "nyc npm run mocha"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.0",
+    "fill-range": "^7.0.1",
+    "gulp-format-md": "^2.0.0",
+    "mocha": "^10.4.0",
+    "nyc": "^15.1.0"
+  },
+  "keywords": [
+    "glob",
+    "match",
+    "picomatch"
+  ],
+  "nyc": {
+    "reporter": [
+      "html",
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "verb": {
+    "toc": {
+      "render": true,
+      "method": "preWrite",
+      "maxdepth": 3
+    },
+    "layout": "empty",
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "lint": {
+      "reflinks": true
+    },
+    "related": {
+      "list": [
+        "braces",
+        "micromatch"
+      ]
+    },
+    "reflinks": [
+      "braces",
+      "expand-brackets",
+      "extglob",
+      "fill-range",
+      "micromatch",
+      "minimatch",
+      "nanomatch",
+      "picomatch"
+    ]
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/posix.js b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/posix.js
new file mode 100644
index 0000000..d2f2bc5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/picomatch/posix.js
@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/picomatch');
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/LICENSE
new file mode 100644
index 0000000..c2314d5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2013 Andrey Sitnik <andrey@sitnik.es>
+
+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.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/README.md
new file mode 100644
index 0000000..b74ceee
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/README.md
@@ -0,0 +1,28 @@
+# PostCSS
+
+<img align="right" width="95" height="95"
+     alt="Philosopher’s stone, logo of PostCSS"
+     src="https://postcss.org/logo.svg">
+
+PostCSS is a tool for transforming styles with JS plugins.
+These plugins can lint your CSS, support variables and mixins,
+transpile future CSS syntax, inline images, and more.
+
+PostCSS is used by industry leaders including Wikipedia, Twitter, Alibaba,
+and JetBrains. The [Autoprefixer] and [Stylelint] PostCSS plugins are some of the most popular CSS tools.
+
+---
+
+<img src="https://cdn.evilmartians.com/badges/logo-no-label.svg" alt="" width="22" height="16" />  Built by
+<b><a href="https://evilmartians.com/devtools?utm_source=postcss&utm_campaign=devtools-button&utm_medium=github">Evil Martians</a></b>, go-to agency for <b>developer tools</b>.
+
+---
+
+[Abstract Syntax Tree]: https://en.wikipedia.org/wiki/Abstract_syntax_tree
+[Evil Martians]: https://evilmartians.com/?utm_source=postcss
+[Autoprefixer]: https://github.com/postcss/autoprefixer
+[Stylelint]: https://stylelint.io/
+[plugins]: https://github.com/postcss/postcss#plugins
+
+## Docs
+Read full docs **[here](https://postcss.org/)**.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/at-rule.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/at-rule.d.ts
new file mode 100644
index 0000000..703e399
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/at-rule.d.ts
@@ -0,0 +1,139 @@
+import Container, {
+  ContainerProps,
+  ContainerWithChildren
+} from './container.js'
+
+declare namespace AtRule {
+  export interface AtRuleRaws extends Record<string, unknown> {
+    /**
+     * The space symbols after the last child of the node to the end of the node.
+     */
+    after?: string
+
+    /**
+     * The space between the at-rule name and its parameters.
+     */
+    afterName?: string
+
+    /**
+     * The space symbols before the node. It also stores `*`
+     * and `_` symbols before the declaration (IE hack).
+     */
+    before?: string
+
+    /**
+     * The symbols between the last parameter and `{` for rules.
+     */
+    between?: string
+
+    /**
+     * The rule’s selector with comments.
+     */
+    params?: {
+      raw: string
+      value: string
+    }
+
+    /**
+     * Contains `true` if the last child has an (optional) semicolon.
+     */
+    semicolon?: boolean
+  }
+
+  export interface AtRuleProps extends ContainerProps {
+    /** Name of the at-rule. */
+    name: string
+    /** Parameters following the name of the at-rule. */
+    params?: number | string
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: AtRuleRaws
+  }
+
+  export { AtRule_ as default }
+}
+
+/**
+ * Represents an at-rule.
+ *
+ * ```js
+ * Once (root, { AtRule }) {
+ *   let media = new AtRule({ name: 'media', params: 'print' })
+ *   media.append(…)
+ *   root.append(media)
+ * }
+ * ```
+ *
+ * If it’s followed in the CSS by a `{}` block, this node will have
+ * a nodes property representing its children.
+ *
+ * ```js
+ * const root = postcss.parse('@charset "UTF-8"; @media print {}')
+ *
+ * const charset = root.first
+ * charset.type  //=> 'atrule'
+ * charset.nodes //=> undefined
+ *
+ * const media = root.last
+ * media.nodes   //=> []
+ * ```
+ */
+declare class AtRule_ extends Container {
+  /**
+   * An array containing the layer’s children.
+   *
+   * ```js
+   * const root = postcss.parse('@layer example { a { color: black } }')
+   * const layer = root.first
+   * layer.nodes.length           //=> 1
+   * layer.nodes[0].selector      //=> 'a'
+   * ```
+   *
+   * Can be `undefinded` if the at-rule has no body.
+   *
+   * ```js
+   * const root = postcss.parse('@layer a, b, c;')
+   * const layer = root.first
+   * layer.nodes //=> undefined
+   * ```
+   */
+  nodes: Container['nodes'] | undefined
+  parent: ContainerWithChildren | undefined
+
+  raws: AtRule.AtRuleRaws
+  type: 'atrule'
+  /**
+   * The at-rule’s name immediately follows the `@`.
+   *
+   * ```js
+   * const root  = postcss.parse('@media print {}')
+   * const media = root.first
+   * media.name //=> 'media'
+   * ```
+   */
+  get name(): string
+  set name(value: string)
+
+  /**
+   * The at-rule’s parameters, the values that follow the at-rule’s name
+   * but precede any `{}` block.
+   *
+   * ```js
+   * const root  = postcss.parse('@media print, screen {}')
+   * const media = root.first
+   * media.params //=> 'print, screen'
+   * ```
+   */
+  get params(): string
+
+  set params(value: string)
+
+  constructor(defaults?: AtRule.AtRuleProps)
+  assign(overrides: AtRule.AtRuleProps | object): this
+  clone(overrides?: Partial<AtRule.AtRuleProps>): this
+  cloneAfter(overrides?: Partial<AtRule.AtRuleProps>): this
+  cloneBefore(overrides?: Partial<AtRule.AtRuleProps>): this
+}
+
+declare class AtRule extends AtRule_ {}
+
+export = AtRule
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/at-rule.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/at-rule.js
new file mode 100644
index 0000000..9486447
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/at-rule.js
@@ -0,0 +1,25 @@
+'use strict'
+
+let Container = require('./container')
+
+class AtRule extends Container {
+  constructor(defaults) {
+    super(defaults)
+    this.type = 'atrule'
+  }
+
+  append(...children) {
+    if (!this.proxyOf.nodes) this.nodes = []
+    return super.append(...children)
+  }
+
+  prepend(...children) {
+    if (!this.proxyOf.nodes) this.nodes = []
+    return super.prepend(...children)
+  }
+}
+
+module.exports = AtRule
+AtRule.default = AtRule
+
+Container.registerAtRule(AtRule)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/comment.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/comment.d.ts
new file mode 100644
index 0000000..f764109
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/comment.d.ts
@@ -0,0 +1,67 @@
+import Container from './container.js'
+import Node, { NodeProps } from './node.js'
+
+declare namespace Comment {
+  export interface CommentRaws extends Record<string, unknown> {
+    /**
+     * The space symbols before the node.
+     */
+    before?: string
+
+    /**
+     * The space symbols between `/*` and the comment’s text.
+     */
+    left?: string
+
+    /**
+     * The space symbols between the comment’s text.
+     */
+    right?: string
+  }
+
+  export interface CommentProps extends NodeProps {
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: CommentRaws
+    /** Content of the comment. */
+    text: string
+  }
+
+  export { Comment_ as default }
+}
+
+/**
+ * It represents a class that handles
+ * [CSS comments](https://developer.mozilla.org/en-US/docs/Web/CSS/Comments)
+ *
+ * ```js
+ * Once (root, { Comment }) {
+ *   const note = new Comment({ text: 'Note: …' })
+ *   root.append(note)
+ * }
+ * ```
+ *
+ * Remember that CSS comments inside selectors, at-rule parameters,
+ * or declaration values will be stored in the `raws` properties
+ * explained above.
+ */
+declare class Comment_ extends Node {
+  parent: Container | undefined
+  raws: Comment.CommentRaws
+  type: 'comment'
+  /**
+   * The comment's text.
+   */
+  get text(): string
+
+  set text(value: string)
+
+  constructor(defaults?: Comment.CommentProps)
+  assign(overrides: Comment.CommentProps | object): this
+  clone(overrides?: Partial<Comment.CommentProps>): this
+  cloneAfter(overrides?: Partial<Comment.CommentProps>): this
+  cloneBefore(overrides?: Partial<Comment.CommentProps>): this
+}
+
+declare class Comment extends Comment_ {}
+
+export = Comment
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/comment.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/comment.js
new file mode 100644
index 0000000..c566506
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/comment.js
@@ -0,0 +1,13 @@
+'use strict'
+
+let Node = require('./node')
+
+class Comment extends Node {
+  constructor(defaults) {
+    super(defaults)
+    this.type = 'comment'
+  }
+}
+
+module.exports = Comment
+Comment.default = Comment
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/container.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/container.d.ts
new file mode 100644
index 0000000..82b24d0
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/container.d.ts
@@ -0,0 +1,478 @@
+import AtRule from './at-rule.js'
+import Comment from './comment.js'
+import Declaration from './declaration.js'
+import Node, { ChildNode, ChildProps, NodeProps } from './node.js'
+import { Root } from './postcss.js'
+import Rule from './rule.js'
+
+declare namespace Container {
+  export type ContainerWithChildren<Child extends Node = ChildNode> = {
+    nodes: Child[]
+  } & (AtRule | Root | Rule)
+
+  export interface ValueOptions {
+    /**
+     * String that’s used to narrow down values and speed up the regexp search.
+     */
+    fast?: string
+
+    /**
+     * An array of property names.
+     */
+    props?: readonly string[]
+  }
+
+  export interface ContainerProps extends NodeProps {
+    nodes?: readonly (ChildProps | Node)[]
+  }
+
+  /**
+   * All types that can be passed into container methods to create or add a new
+   * child node.
+   */
+  export type NewChild =
+    | ChildProps
+    | Node
+    | readonly ChildProps[]
+    | readonly Node[]
+    | readonly string[]
+    | string
+    | undefined
+
+  export { Container_ as default }
+}
+
+/**
+ * The `Root`, `AtRule`, and `Rule` container nodes
+ * inherit some common methods to help work with their children.
+ *
+ * Note that all containers can store any content. If you write a rule inside
+ * a rule, PostCSS will parse it.
+ */
+declare abstract class Container_<Child extends Node = ChildNode> extends Node {
+  /**
+   * An array containing the container’s children.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black }')
+   * root.nodes.length           //=> 1
+   * root.nodes[0].selector      //=> 'a'
+   * root.nodes[0].nodes[0].prop //=> 'color'
+   * ```
+   */
+  nodes: Child[] | undefined
+
+  /**
+   * The container’s first child.
+   *
+   * ```js
+   * rule.first === rules.nodes[0]
+   * ```
+   */
+  get first(): Child | undefined
+
+  /**
+   * The container’s last child.
+   *
+   * ```js
+   * rule.last === rule.nodes[rule.nodes.length - 1]
+   * ```
+   */
+  get last(): Child | undefined
+  /**
+   * Inserts new nodes to the end of the container.
+   *
+   * ```js
+   * const decl1 = new Declaration({ prop: 'color', value: 'black' })
+   * const decl2 = new Declaration({ prop: 'background-color', value: 'white' })
+   * rule.append(decl1, decl2)
+   *
+   * root.append({ name: 'charset', params: '"UTF-8"' })  // at-rule
+   * root.append({ selector: 'a' })                       // rule
+   * rule.append({ prop: 'color', value: 'black' })       // declaration
+   * rule.append({ text: 'Comment' })                     // comment
+   *
+   * root.append('a {}')
+   * root.first.append('color: black; z-index: 1')
+   * ```
+   *
+   * @param nodes New nodes.
+   * @return This node for methods chain.
+   */
+  append(...nodes: Container.NewChild[]): this
+  assign(overrides: Container.ContainerProps | object): this
+  clone(overrides?: Partial<Container.ContainerProps>): this
+
+  cloneAfter(overrides?: Partial<Container.ContainerProps>): this
+
+  cloneBefore(overrides?: Partial<Container.ContainerProps>): this
+  /**
+   * Iterates through the container’s immediate children,
+   * calling `callback` for each child.
+   *
+   * Returning `false` in the callback will break iteration.
+   *
+   * This method only iterates through the container’s immediate children.
+   * If you need to recursively iterate through all the container’s descendant
+   * nodes, use `Container#walk`.
+   *
+   * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe
+   * if you are mutating the array of child nodes during iteration.
+   * PostCSS will adjust the current index to match the mutations.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black; z-index: 1 }')
+   * const rule = root.first
+   *
+   * for (const decl of rule.nodes) {
+   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })
+   *   // Cycle will be infinite, because cloneBefore moves the current node
+   *   // to the next index
+   * }
+   *
+   * rule.each(decl => {
+   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })
+   *   // Will be executed only for color and z-index
+   * })
+   * ```
+   *
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+  each(
+    callback: (node: Child, index: number) => false | void
+  ): false | undefined
+
+  /**
+   * Returns `true` if callback returns `true`
+   * for all of the container’s children.
+   *
+   * ```js
+   * const noPrefixes = rule.every(i => i.prop[0] !== '-')
+   * ```
+   *
+   * @param condition Iterator returns true or false.
+   * @return Is every child pass condition.
+   */
+  every(
+    condition: (node: Child, index: number, nodes: Child[]) => boolean
+  ): boolean
+  /**
+   * Returns a `child`’s index within the `Container#nodes` array.
+   *
+   * ```js
+   * rule.index( rule.nodes[2] ) //=> 2
+   * ```
+   *
+   * @param child Child of the current container.
+   * @return Child index.
+   */
+  index(child: Child | number): number
+
+  /**
+   * Insert new node after old node within the container.
+   *
+   * @param oldNode Child or child’s index.
+   * @param newNode New node.
+   * @return This node for methods chain.
+   */
+  insertAfter(oldNode: Child | number, newNode: Container.NewChild): this
+
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each comment node.
+   *
+   * Like `Container#each`, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * ```js
+   * root.walkComments(comment => {
+   *   comment.remove()
+   * })
+   * ```
+   *
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+
+  /**
+   * Insert new node before old node within the container.
+   *
+   * ```js
+   * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }))
+   * ```
+   *
+   * @param oldNode Child or child’s index.
+   * @param newNode New node.
+   * @return This node for methods chain.
+   */
+  insertBefore(oldNode: Child | number, newNode: Container.NewChild): this
+  /**
+   * Inserts new nodes to the start of the container.
+   *
+   * ```js
+   * const decl1 = new Declaration({ prop: 'color', value: 'black' })
+   * const decl2 = new Declaration({ prop: 'background-color', value: 'white' })
+   * rule.prepend(decl1, decl2)
+   *
+   * root.append({ name: 'charset', params: '"UTF-8"' })  // at-rule
+   * root.append({ selector: 'a' })                       // rule
+   * rule.append({ prop: 'color', value: 'black' })       // declaration
+   * rule.append({ text: 'Comment' })                     // comment
+   *
+   * root.append('a {}')
+   * root.first.append('color: black; z-index: 1')
+   * ```
+   *
+   * @param nodes New nodes.
+   * @return This node for methods chain.
+   */
+  prepend(...nodes: Container.NewChild[]): this
+
+  /**
+   * Add child to the end of the node.
+   *
+   * ```js
+   * rule.push(new Declaration({ prop: 'color', value: 'black' }))
+   * ```
+   *
+   * @param child New node.
+   * @return This node for methods chain.
+   */
+  push(child: Child): this
+
+  /**
+   * Removes all children from the container
+   * and cleans their parent properties.
+   *
+   * ```js
+   * rule.removeAll()
+   * rule.nodes.length //=> 0
+   * ```
+   *
+   * @return This node for methods chain.
+   */
+  removeAll(): this
+
+  /**
+   * Removes node from the container and cleans the parent properties
+   * from the node and its children.
+   *
+   * ```js
+   * rule.nodes.length  //=> 5
+   * rule.removeChild(decl)
+   * rule.nodes.length  //=> 4
+   * decl.parent        //=> undefined
+   * ```
+   *
+   * @param child Child or child’s index.
+   * @return This node for methods chain.
+   */
+  removeChild(child: Child | number): this
+
+  replaceValues(
+    pattern: RegExp | string,
+    replaced: { (substring: string, ...args: any[]): string } | string
+  ): this
+  /**
+   * Passes all declaration values within the container that match pattern
+   * through callback, replacing those values with the returned result
+   * of callback.
+   *
+   * This method is useful if you are using a custom unit or function
+   * and need to iterate through all values.
+   *
+   * ```js
+   * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => {
+   *   return 15 * parseInt(string) + 'px'
+   * })
+   * ```
+   *
+   * @param pattern      Replace pattern.
+   * @param {object} options             Options to speed up the search.
+   * @param replaced   String to replace pattern or callback
+   *                                     that returns a new value. The callback
+   *                                     will receive the same arguments
+   *                                     as those passed to a function parameter
+   *                                     of `String#replace`.
+   * @return This node for methods chain.
+   */
+  replaceValues(
+    pattern: RegExp | string,
+    options: Container.ValueOptions,
+    replaced: { (substring: string, ...args: any[]): string } | string
+  ): this
+
+  /**
+   * Returns `true` if callback returns `true` for (at least) one
+   * of the container’s children.
+   *
+   * ```js
+   * const hasPrefix = rule.some(i => i.prop[0] === '-')
+   * ```
+   *
+   * @param condition Iterator returns true or false.
+   * @return Is some child pass condition.
+   */
+  some(
+    condition: (node: Child, index: number, nodes: Child[]) => boolean
+  ): boolean
+
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each node.
+   *
+   * Like container.each(), this method is safe to use
+   * if you are mutating arrays during iteration.
+   *
+   * If you only need to iterate through the container’s immediate children,
+   * use `Container#each`.
+   *
+   * ```js
+   * root.walk(node => {
+   *   // Traverses all descendant nodes.
+   * })
+   * ```
+   *
+   * @param callback Iterator receives each node and index.
+   * @return  Returns `false` if iteration was broke.
+   */
+  walk(
+    callback: (node: ChildNode, index: number) => false | void
+  ): false | undefined
+
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each at-rule node.
+   *
+   * If you pass a filter, iteration will only happen over at-rules
+   * that have matching names.
+   *
+   * Like `Container#each`, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * ```js
+   * root.walkAtRules(rule => {
+   *   if (isOld(rule.name)) rule.remove()
+   * })
+   *
+   * let first = false
+   * root.walkAtRules('charset', rule => {
+   *   if (!first) {
+   *     first = true
+   *   } else {
+   *     rule.remove()
+   *   }
+   * })
+   * ```
+   *
+   * @param name     String or regular expression to filter at-rules by name.
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+  walkAtRules(
+    nameFilter: RegExp | string,
+    callback: (atRule: AtRule, index: number) => false | void
+  ): false | undefined
+  walkAtRules(
+    callback: (atRule: AtRule, index: number) => false | void
+  ): false | undefined
+
+  walkComments(
+    callback: (comment: Comment, indexed: number) => false | void
+  ): false | undefined
+  walkComments(
+    callback: (comment: Comment, indexed: number) => false | void
+  ): false | undefined
+
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each declaration node.
+   *
+   * If you pass a filter, iteration will only happen over declarations
+   * with matching properties.
+   *
+   * ```js
+   * root.walkDecls(decl => {
+   *   checkPropertySupport(decl.prop)
+   * })
+   *
+   * root.walkDecls('border-radius', decl => {
+   *   decl.remove()
+   * })
+   *
+   * root.walkDecls(/^background/, decl => {
+   *   decl.value = takeFirstColorFromGradient(decl.value)
+   * })
+   * ```
+   *
+   * Like `Container#each`, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * @param prop     String or regular expression to filter declarations
+   *                 by property name.
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+  walkDecls(
+    propFilter: RegExp | string,
+    callback: (decl: Declaration, index: number) => false | void
+  ): false | undefined
+  walkDecls(
+    callback: (decl: Declaration, index: number) => false | void
+  ): false | undefined
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each rule node.
+   *
+   * If you pass a filter, iteration will only happen over rules
+   * with matching selectors.
+   *
+   * Like `Container#each`, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * ```js
+   * const selectors = []
+   * root.walkRules(rule => {
+   *   selectors.push(rule.selector)
+   * })
+   * console.log(`Your CSS uses ${ selectors.length } selectors`)
+   * ```
+   *
+   * @param selector String or regular expression to filter rules by selector.
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+  walkRules(
+    selectorFilter: RegExp | string,
+    callback: (rule: Rule, index: number) => false | void
+  ): false | undefined
+  walkRules(
+    callback: (rule: Rule, index: number) => false | void
+  ): false | undefined
+  /**
+   * An internal method that converts a {@link NewChild} into a list of actual
+   * child nodes that can then be added to this container.
+   *
+   * This ensures that the nodes' parent is set to this container, that they use
+   * the correct prototype chain, and that they're marked as dirty.
+   *
+   * @param mnodes The new node or nodes to add.
+   * @param sample A node from whose raws the new node's `before` raw should be
+   *               taken.
+   * @param type   This should be set to `'prepend'` if the new nodes will be
+   *               inserted at the beginning of the container.
+   * @hidden
+   */
+  protected normalize(
+    nodes: Container.NewChild,
+    sample: Node | undefined,
+    type?: 'prepend' | false
+  ): Child[]
+}
+
+declare class Container<
+  Child extends Node = ChildNode
+> extends Container_<Child> {}
+
+export = Container
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/container.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/container.js
new file mode 100644
index 0000000..edb07cc
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/container.js
@@ -0,0 +1,447 @@
+'use strict'
+
+let Comment = require('./comment')
+let Declaration = require('./declaration')
+let Node = require('./node')
+let { isClean, my } = require('./symbols')
+
+let AtRule, parse, Root, Rule
+
+function cleanSource(nodes) {
+  return nodes.map(i => {
+    if (i.nodes) i.nodes = cleanSource(i.nodes)
+    delete i.source
+    return i
+  })
+}
+
+function markTreeDirty(node) {
+  node[isClean] = false
+  if (node.proxyOf.nodes) {
+    for (let i of node.proxyOf.nodes) {
+      markTreeDirty(i)
+    }
+  }
+}
+
+class Container extends Node {
+  get first() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[0]
+  }
+
+  get last() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
+  }
+
+  append(...children) {
+    for (let child of children) {
+      let nodes = this.normalize(child, this.last)
+      for (let node of nodes) this.proxyOf.nodes.push(node)
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  cleanRaws(keepBetween) {
+    super.cleanRaws(keepBetween)
+    if (this.nodes) {
+      for (let node of this.nodes) node.cleanRaws(keepBetween)
+    }
+  }
+
+  each(callback) {
+    if (!this.proxyOf.nodes) return undefined
+    let iterator = this.getIterator()
+
+    let index, result
+    while (this.indexes[iterator] < this.proxyOf.nodes.length) {
+      index = this.indexes[iterator]
+      result = callback(this.proxyOf.nodes[index], index)
+      if (result === false) break
+
+      this.indexes[iterator] += 1
+    }
+
+    delete this.indexes[iterator]
+    return result
+  }
+
+  every(condition) {
+    return this.nodes.every(condition)
+  }
+
+  getIterator() {
+    if (!this.lastEach) this.lastEach = 0
+    if (!this.indexes) this.indexes = {}
+
+    this.lastEach += 1
+    let iterator = this.lastEach
+    this.indexes[iterator] = 0
+
+    return iterator
+  }
+
+  getProxyProcessor() {
+    return {
+      get(node, prop) {
+        if (prop === 'proxyOf') {
+          return node
+        } else if (!node[prop]) {
+          return node[prop]
+        } else if (
+          prop === 'each' ||
+          (typeof prop === 'string' && prop.startsWith('walk'))
+        ) {
+          return (...args) => {
+            return node[prop](
+              ...args.map(i => {
+                if (typeof i === 'function') {
+                  return (child, index) => i(child.toProxy(), index)
+                } else {
+                  return i
+                }
+              })
+            )
+          }
+        } else if (prop === 'every' || prop === 'some') {
+          return cb => {
+            return node[prop]((child, ...other) =>
+              cb(child.toProxy(), ...other)
+            )
+          }
+        } else if (prop === 'root') {
+          return () => node.root().toProxy()
+        } else if (prop === 'nodes') {
+          return node.nodes.map(i => i.toProxy())
+        } else if (prop === 'first' || prop === 'last') {
+          return node[prop].toProxy()
+        } else {
+          return node[prop]
+        }
+      },
+
+      set(node, prop, value) {
+        if (node[prop] === value) return true
+        node[prop] = value
+        if (prop === 'name' || prop === 'params' || prop === 'selector') {
+          node.markDirty()
+        }
+        return true
+      }
+    }
+  }
+
+  index(child) {
+    if (typeof child === 'number') return child
+    if (child.proxyOf) child = child.proxyOf
+    return this.proxyOf.nodes.indexOf(child)
+  }
+
+  insertAfter(exist, add) {
+    let existIndex = this.index(exist)
+    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse()
+    existIndex = this.index(exist)
+    for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node)
+
+    let index
+    for (let id in this.indexes) {
+      index = this.indexes[id]
+      if (existIndex < index) {
+        this.indexes[id] = index + nodes.length
+      }
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  insertBefore(exist, add) {
+    let existIndex = this.index(exist)
+    let type = existIndex === 0 ? 'prepend' : false
+    let nodes = this.normalize(
+      add,
+      this.proxyOf.nodes[existIndex],
+      type
+    ).reverse()
+    existIndex = this.index(exist)
+    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node)
+
+    let index
+    for (let id in this.indexes) {
+      index = this.indexes[id]
+      if (existIndex <= index) {
+        this.indexes[id] = index + nodes.length
+      }
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  normalize(nodes, sample) {
+    if (typeof nodes === 'string') {
+      nodes = cleanSource(parse(nodes).nodes)
+    } else if (typeof nodes === 'undefined') {
+      nodes = []
+    } else if (Array.isArray(nodes)) {
+      nodes = nodes.slice(0)
+      for (let i of nodes) {
+        if (i.parent) i.parent.removeChild(i, 'ignore')
+      }
+    } else if (nodes.type === 'root' && this.type !== 'document') {
+      nodes = nodes.nodes.slice(0)
+      for (let i of nodes) {
+        if (i.parent) i.parent.removeChild(i, 'ignore')
+      }
+    } else if (nodes.type) {
+      nodes = [nodes]
+    } else if (nodes.prop) {
+      if (typeof nodes.value === 'undefined') {
+        throw new Error('Value field is missed in node creation')
+      } else if (typeof nodes.value !== 'string') {
+        nodes.value = String(nodes.value)
+      }
+      nodes = [new Declaration(nodes)]
+    } else if (nodes.selector || nodes.selectors) {
+      nodes = [new Rule(nodes)]
+    } else if (nodes.name) {
+      nodes = [new AtRule(nodes)]
+    } else if (nodes.text) {
+      nodes = [new Comment(nodes)]
+    } else {
+      throw new Error('Unknown node type in node creation')
+    }
+
+    let processed = nodes.map(i => {
+      /* c8 ignore next */
+      if (!i[my]) Container.rebuild(i)
+      i = i.proxyOf
+      if (i.parent) i.parent.removeChild(i)
+      if (i[isClean]) markTreeDirty(i)
+
+      if (!i.raws) i.raws = {}
+      if (typeof i.raws.before === 'undefined') {
+        if (sample && typeof sample.raws.before !== 'undefined') {
+          i.raws.before = sample.raws.before.replace(/\S/g, '')
+        }
+      }
+      i.parent = this.proxyOf
+      return i
+    })
+
+    return processed
+  }
+
+  prepend(...children) {
+    children = children.reverse()
+    for (let child of children) {
+      let nodes = this.normalize(child, this.first, 'prepend').reverse()
+      for (let node of nodes) this.proxyOf.nodes.unshift(node)
+      for (let id in this.indexes) {
+        this.indexes[id] = this.indexes[id] + nodes.length
+      }
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  push(child) {
+    child.parent = this
+    this.proxyOf.nodes.push(child)
+    return this
+  }
+
+  removeAll() {
+    for (let node of this.proxyOf.nodes) node.parent = undefined
+    this.proxyOf.nodes = []
+
+    this.markDirty()
+
+    return this
+  }
+
+  removeChild(child) {
+    child = this.index(child)
+    this.proxyOf.nodes[child].parent = undefined
+    this.proxyOf.nodes.splice(child, 1)
+
+    let index
+    for (let id in this.indexes) {
+      index = this.indexes[id]
+      if (index >= child) {
+        this.indexes[id] = index - 1
+      }
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  replaceValues(pattern, opts, callback) {
+    if (!callback) {
+      callback = opts
+      opts = {}
+    }
+
+    this.walkDecls(decl => {
+      if (opts.props && !opts.props.includes(decl.prop)) return
+      if (opts.fast && !decl.value.includes(opts.fast)) return
+
+      decl.value = decl.value.replace(pattern, callback)
+    })
+
+    this.markDirty()
+
+    return this
+  }
+
+  some(condition) {
+    return this.nodes.some(condition)
+  }
+
+  walk(callback) {
+    return this.each((child, i) => {
+      let result
+      try {
+        result = callback(child, i)
+      } catch (e) {
+        throw child.addToError(e)
+      }
+      if (result !== false && child.walk) {
+        result = child.walk(callback)
+      }
+
+      return result
+    })
+  }
+
+  walkAtRules(name, callback) {
+    if (!callback) {
+      callback = name
+      return this.walk((child, i) => {
+        if (child.type === 'atrule') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (name instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'atrule' && name.test(child.name)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'atrule' && child.name === name) {
+        return callback(child, i)
+      }
+    })
+  }
+
+  walkComments(callback) {
+    return this.walk((child, i) => {
+      if (child.type === 'comment') {
+        return callback(child, i)
+      }
+    })
+  }
+
+  walkDecls(prop, callback) {
+    if (!callback) {
+      callback = prop
+      return this.walk((child, i) => {
+        if (child.type === 'decl') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (prop instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'decl' && prop.test(child.prop)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'decl' && child.prop === prop) {
+        return callback(child, i)
+      }
+    })
+  }
+
+  walkRules(selector, callback) {
+    if (!callback) {
+      callback = selector
+
+      return this.walk((child, i) => {
+        if (child.type === 'rule') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (selector instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'rule' && selector.test(child.selector)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'rule' && child.selector === selector) {
+        return callback(child, i)
+      }
+    })
+  }
+}
+
+Container.registerParse = dependant => {
+  parse = dependant
+}
+
+Container.registerRule = dependant => {
+  Rule = dependant
+}
+
+Container.registerAtRule = dependant => {
+  AtRule = dependant
+}
+
+Container.registerRoot = dependant => {
+  Root = dependant
+}
+
+module.exports = Container
+Container.default = Container
+
+/* c8 ignore start */
+Container.rebuild = node => {
+  if (node.type === 'atrule') {
+    Object.setPrototypeOf(node, AtRule.prototype)
+  } else if (node.type === 'rule') {
+    Object.setPrototypeOf(node, Rule.prototype)
+  } else if (node.type === 'decl') {
+    Object.setPrototypeOf(node, Declaration.prototype)
+  } else if (node.type === 'comment') {
+    Object.setPrototypeOf(node, Comment.prototype)
+  } else if (node.type === 'root') {
+    Object.setPrototypeOf(node, Root.prototype)
+  }
+
+  node[my] = true
+
+  if (node.nodes) {
+    node.nodes.forEach(child => {
+      Container.rebuild(child)
+    })
+  }
+}
+/* c8 ignore stop */
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/css-syntax-error.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/css-syntax-error.d.ts
new file mode 100644
index 0000000..03d9ed1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/css-syntax-error.d.ts
@@ -0,0 +1,247 @@
+import { FilePosition } from './input.js'
+
+declare namespace CssSyntaxError {
+  /**
+   * A position that is part of a range.
+   */
+  export interface RangePosition {
+    /**
+     * The column number in the input.
+     */
+    column: number
+
+    /**
+     * The line number in the input.
+     */
+    line: number
+  }
+
+  export { CssSyntaxError_ as default }
+}
+
+/**
+ * The CSS parser throws this error for broken CSS.
+ *
+ * Custom parsers can throw this error for broken custom syntax using
+ * the `Node#error` method.
+ *
+ * PostCSS will use the input source map to detect the original error location.
+ * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,
+ * PostCSS will show the original position in the Sass file.
+ *
+ * If you need the position in the PostCSS input
+ * (e.g., to debug the previous compiler), use `error.input.file`.
+ *
+ * ```js
+ * // Raising error from plugin
+ * throw node.error('Unknown variable', { plugin: 'postcss-vars' })
+ * ```
+ *
+ * ```js
+ * // Catching and checking syntax error
+ * try {
+ *   postcss.parse('a{')
+ * } catch (error) {
+ *   if (error.name === 'CssSyntaxError') {
+ *     error //=> CssSyntaxError
+ *   }
+ * }
+ * ```
+ */
+declare class CssSyntaxError_ extends Error {
+  /**
+   * Source column of the error.
+   *
+   * ```js
+   * error.column       //=> 1
+   * error.input.column //=> 4
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.column`.
+   */
+  column?: number
+
+  /**
+   * Source column of the error's end, exclusive. Provided if the error pertains
+   * to a range.
+   *
+   * ```js
+   * error.endColumn       //=> 1
+   * error.input.endColumn //=> 4
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.endColumn`.
+   */
+  endColumn?: number
+
+  /**
+   * Source line of the error's end, exclusive. Provided if the error pertains
+   * to a range.
+   *
+   * ```js
+   * error.endLine       //=> 3
+   * error.input.endLine //=> 4
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.endLine`.
+   */
+  endLine?: number
+
+  /**
+   * Absolute path to the broken file.
+   *
+   * ```js
+   * error.file       //=> 'a.sass'
+   * error.input.file //=> 'a.css'
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.file`.
+   */
+  file?: string
+
+  /**
+   * Input object with PostCSS internal information
+   * about input file. If input has source map
+   * from previous tool, PostCSS will use origin
+   * (for example, Sass) source. You can use this
+   * object to get PostCSS input source.
+   *
+   * ```js
+   * error.input.file //=> 'a.css'
+   * error.file       //=> 'a.sass'
+   * ```
+   */
+  input?: FilePosition
+
+  /**
+   * Source line of the error.
+   *
+   * ```js
+   * error.line       //=> 2
+   * error.input.line //=> 4
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.line`.
+   */
+  line?: number
+
+  /**
+   * Full error text in the GNU error format
+   * with plugin, file, line and column.
+   *
+   * ```js
+   * error.message //=> 'a.css:1:1: Unclosed block'
+   * ```
+   */
+  message: string
+
+  /**
+   * Always equal to `'CssSyntaxError'`. You should always check error type
+   * by `error.name === 'CssSyntaxError'`
+   * instead of `error instanceof CssSyntaxError`,
+   * because npm could have several PostCSS versions.
+   *
+   * ```js
+   * if (error.name === 'CssSyntaxError') {
+   *   error //=> CssSyntaxError
+   * }
+   * ```
+   */
+  name: 'CssSyntaxError'
+
+  /**
+   * Plugin name, if error came from plugin.
+   *
+   * ```js
+   * error.plugin //=> 'postcss-vars'
+   * ```
+   */
+  plugin?: string
+
+  /**
+   * Error message.
+   *
+   * ```js
+   * error.message //=> 'Unclosed block'
+   * ```
+   */
+  reason: string
+
+  /**
+   * Source code of the broken file.
+   *
+   * ```js
+   * error.source       //=> 'a { b {} }'
+   * error.input.source //=> 'a b { }'
+   * ```
+   */
+  source?: string
+
+  stack: string
+
+  /**
+   * Instantiates a CSS syntax error. Can be instantiated for a single position
+   * or for a range.
+   * @param message        Error message.
+   * @param lineOrStartPos If for a single position, the line number, or if for
+   *                       a range, the inclusive start position of the error.
+   * @param columnOrEndPos If for a single position, the column number, or if for
+   *                       a range, the exclusive end position of the error.
+   * @param source         Source code of the broken file.
+   * @param file           Absolute path to the broken file.
+   * @param plugin         PostCSS plugin name, if error came from plugin.
+   */
+  constructor(
+    message: string,
+    lineOrStartPos?: CssSyntaxError.RangePosition | number,
+    columnOrEndPos?: CssSyntaxError.RangePosition | number,
+    source?: string,
+    file?: string,
+    plugin?: string
+  )
+
+  /**
+   * Returns a few lines of CSS source that caused the error.
+   *
+   * If the CSS has an input source map without `sourceContent`,
+   * this method will return an empty string.
+   *
+   * ```js
+   * error.showSourceCode() //=> "  4 | }
+   *                        //      5 | a {
+   *                        //    > 6 |   bad
+   *                        //        |   ^
+   *                        //      7 | }
+   *                        //      8 | b {"
+   * ```
+   *
+   * @param color Whether arrow will be colored red by terminal
+   *              color codes. By default, PostCSS will detect
+   *              color support by `process.stdout.isTTY`
+   *              and `process.env.NODE_DISABLE_COLORS`.
+   * @return Few lines of CSS source that caused the error.
+   */
+  showSourceCode(color?: boolean): string
+
+  /**
+   * Returns error position, message and source code of the broken part.
+   *
+   * ```js
+   * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block
+   *                  //    > 1 | a {
+   *                  //        | ^"
+   * ```
+   *
+   * @return Error position, message and source code.
+   */
+  toString(): string
+}
+
+declare class CssSyntaxError extends CssSyntaxError_ {}
+
+export = CssSyntaxError
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/css-syntax-error.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/css-syntax-error.js
new file mode 100644
index 0000000..275a4f6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/css-syntax-error.js
@@ -0,0 +1,133 @@
+'use strict'
+
+let pico = require('picocolors')
+
+let terminalHighlight = require('./terminal-highlight')
+
+class CssSyntaxError extends Error {
+  constructor(message, line, column, source, file, plugin) {
+    super(message)
+    this.name = 'CssSyntaxError'
+    this.reason = message
+
+    if (file) {
+      this.file = file
+    }
+    if (source) {
+      this.source = source
+    }
+    if (plugin) {
+      this.plugin = plugin
+    }
+    if (typeof line !== 'undefined' && typeof column !== 'undefined') {
+      if (typeof line === 'number') {
+        this.line = line
+        this.column = column
+      } else {
+        this.line = line.line
+        this.column = line.column
+        this.endLine = column.line
+        this.endColumn = column.column
+      }
+    }
+
+    this.setMessage()
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, CssSyntaxError)
+    }
+  }
+
+  setMessage() {
+    this.message = this.plugin ? this.plugin + ': ' : ''
+    this.message += this.file ? this.file : '<css input>'
+    if (typeof this.line !== 'undefined') {
+      this.message += ':' + this.line + ':' + this.column
+    }
+    this.message += ': ' + this.reason
+  }
+
+  showSourceCode(color) {
+    if (!this.source) return ''
+
+    let css = this.source
+    if (color == null) color = pico.isColorSupported
+
+    let aside = text => text
+    let mark = text => text
+    let highlight = text => text
+    if (color) {
+      let { bold, gray, red } = pico.createColors(true)
+      mark = text => bold(red(text))
+      aside = text => gray(text)
+      if (terminalHighlight) {
+        highlight = text => terminalHighlight(text)
+      }
+    }
+
+    let lines = css.split(/\r?\n/)
+    let start = Math.max(this.line - 3, 0)
+    let end = Math.min(this.line + 2, lines.length)
+    let maxWidth = String(end).length
+
+    return lines
+      .slice(start, end)
+      .map((line, index) => {
+        let number = start + 1 + index
+        let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '
+        if (number === this.line) {
+          if (line.length > 160) {
+            let padding = 20
+            let subLineStart = Math.max(0, this.column - padding)
+            let subLineEnd = Math.max(
+              this.column + padding,
+              this.endColumn + padding
+            )
+            let subLine = line.slice(subLineStart, subLineEnd)
+
+            let spacing =
+              aside(gutter.replace(/\d/g, ' ')) +
+              line
+                .slice(0, Math.min(this.column - 1, padding - 1))
+                .replace(/[^\t]/g, ' ')
+
+            return (
+              mark('>') +
+              aside(gutter) +
+              highlight(subLine) +
+              '\n ' +
+              spacing +
+              mark('^')
+            )
+          }
+
+          let spacing =
+            aside(gutter.replace(/\d/g, ' ')) +
+            line.slice(0, this.column - 1).replace(/[^\t]/g, ' ')
+
+          return (
+            mark('>') +
+            aside(gutter) +
+            highlight(line) +
+            '\n ' +
+            spacing +
+            mark('^')
+          )
+        }
+
+        return ' ' + aside(gutter) + highlight(line)
+      })
+      .join('\n')
+  }
+
+  toString() {
+    let code = this.showSourceCode()
+    if (code) {
+      code = '\n\n' + code + '\n'
+    }
+    return this.name + ': ' + this.message + code
+  }
+}
+
+module.exports = CssSyntaxError
+CssSyntaxError.default = CssSyntaxError
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/declaration.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/declaration.d.ts
new file mode 100644
index 0000000..55dec7f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/declaration.d.ts
@@ -0,0 +1,150 @@
+import { ContainerWithChildren } from './container.js'
+import Node from './node.js'
+
+declare namespace Declaration {
+  export interface DeclarationRaws extends Record<string, unknown> {
+    /**
+     * The space symbols before the node. It also stores `*`
+     * and `_` symbols before the declaration (IE hack).
+     */
+    before?: string
+
+    /**
+     * The symbols between the property and value for declarations.
+     */
+    between?: string
+
+    /**
+     * The content of the important statement, if it is not just `!important`.
+     */
+    important?: string
+
+    /**
+     * Declaration value with comments.
+     */
+    value?: {
+      raw: string
+      value: string
+    }
+  }
+
+  export interface DeclarationProps {
+    /** Whether the declaration has an `!important` annotation. */
+    important?: boolean
+    /** Name of the declaration. */
+    prop: string
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: DeclarationRaws
+    /** Value of the declaration. */
+    value: string
+  }
+
+  export { Declaration_ as default }
+}
+
+/**
+ * It represents a class that handles
+ * [CSS declarations](https://developer.mozilla.org/en-US/docs/Web/CSS/Syntax#css_declarations)
+ *
+ * ```js
+ * Once (root, { Declaration }) {
+ *   const color = new Declaration({ prop: 'color', value: 'black' })
+ *   root.append(color)
+ * }
+ * ```
+ *
+ * ```js
+ * const root = postcss.parse('a { color: black }')
+ * const decl = root.first?.first
+ *
+ * decl.type       //=> 'decl'
+ * decl.toString() //=> ' color: black'
+ * ```
+ */
+declare class Declaration_ extends Node {
+  parent: ContainerWithChildren | undefined
+  raws: Declaration.DeclarationRaws
+
+  type: 'decl'
+
+  /**
+   * It represents a specificity of the declaration.
+   *
+   * If true, the CSS declaration will have an
+   * [important](https://developer.mozilla.org/en-US/docs/Web/CSS/important)
+   * specifier.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black !important; color: red }')
+   *
+   * root.first.first.important //=> true
+   * root.first.last.important  //=> undefined
+   * ```
+   */
+  get important(): boolean
+  set important(value: boolean)
+
+  /**
+   * The property name for a CSS declaration.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black }')
+   * const decl = root.first.first
+   *
+   * decl.prop //=> 'color'
+   * ```
+   */
+  get prop(): string
+
+  set prop(value: string)
+
+  /**
+   * The property value for a CSS declaration.
+   *
+   * Any CSS comments inside the value string will be filtered out.
+   * CSS comments present in the source value will be available in
+   * the `raws` property.
+   *
+   * Assigning new `value` would ignore the comments in `raws`
+   * property while compiling node to string.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black }')
+   * const decl = root.first.first
+   *
+   * decl.value //=> 'black'
+   * ```
+   */
+  get value(): string
+  set value(value: string)
+
+  /**
+   * It represents a getter that returns `true` if a declaration starts with
+   * `--` or `$`, which are used to declare variables in CSS and SASS/SCSS.
+   *
+   * ```js
+   * const root = postcss.parse(':root { --one: 1 }')
+   * const one = root.first.first
+   *
+   * one.variable //=> true
+   * ```
+   *
+   * ```js
+   * const root = postcss.parse('$one: 1')
+   * const one = root.first
+   *
+   * one.variable //=> true
+   * ```
+   */
+  get variable(): boolean
+  constructor(defaults?: Declaration.DeclarationProps)
+
+  assign(overrides: Declaration.DeclarationProps | object): this
+  clone(overrides?: Partial<Declaration.DeclarationProps>): this
+  cloneAfter(overrides?: Partial<Declaration.DeclarationProps>): this
+  cloneBefore(overrides?: Partial<Declaration.DeclarationProps>): this
+}
+
+declare class Declaration extends Declaration_ {}
+
+export = Declaration
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/declaration.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/declaration.js
new file mode 100644
index 0000000..65a03aa
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/declaration.js
@@ -0,0 +1,24 @@
+'use strict'
+
+let Node = require('./node')
+
+class Declaration extends Node {
+  get variable() {
+    return this.prop.startsWith('--') || this.prop[0] === '$'
+  }
+
+  constructor(defaults) {
+    if (
+      defaults &&
+      typeof defaults.value !== 'undefined' &&
+      typeof defaults.value !== 'string'
+    ) {
+      defaults = { ...defaults, value: String(defaults.value) }
+    }
+    super(defaults)
+    this.type = 'decl'
+  }
+}
+
+module.exports = Declaration
+Declaration.default = Declaration
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/document.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/document.d.ts
new file mode 100644
index 0000000..67194dd
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/document.d.ts
@@ -0,0 +1,68 @@
+import Container, { ContainerProps } from './container.js'
+import { ProcessOptions } from './postcss.js'
+import Result from './result.js'
+import Root from './root.js'
+
+declare namespace Document {
+  export interface DocumentProps extends ContainerProps {
+    nodes?: readonly Root[]
+
+    /**
+     * Information to generate byte-to-byte equal node string as it was
+     * in the origin input.
+     *
+     * Every parser saves its own properties.
+     */
+    raws?: Record<string, any>
+  }
+
+  export { Document_ as default }
+}
+
+/**
+ * Represents a file and contains all its parsed nodes.
+ *
+ * **Experimental:** some aspects of this node could change within minor
+ * or patch version releases.
+ *
+ * ```js
+ * const document = htmlParser(
+ *   '<html><style>a{color:black}</style><style>b{z-index:2}</style>'
+ * )
+ * document.type         //=> 'document'
+ * document.nodes.length //=> 2
+ * ```
+ */
+declare class Document_ extends Container<Root> {
+  nodes: Root[]
+  parent: undefined
+  type: 'document'
+
+  constructor(defaults?: Document.DocumentProps)
+
+  assign(overrides: Document.DocumentProps | object): this
+  clone(overrides?: Partial<Document.DocumentProps>): this
+  cloneAfter(overrides?: Partial<Document.DocumentProps>): this
+  cloneBefore(overrides?: Partial<Document.DocumentProps>): this
+
+  /**
+   * Returns a `Result` instance representing the document’s CSS roots.
+   *
+   * ```js
+   * const root1 = postcss.parse(css1, { from: 'a.css' })
+   * const root2 = postcss.parse(css2, { from: 'b.css' })
+   * const document = postcss.document()
+   * document.append(root1)
+   * document.append(root2)
+   * const result = document.toResult({ to: 'all.css', map: true })
+   * ```
+   *
+   * @param opts Options.
+   * @return Result with current document’s CSS.
+   */
+  toResult(options?: ProcessOptions): Result
+}
+
+declare class Document extends Document_ {}
+
+export = Document
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/document.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/document.js
new file mode 100644
index 0000000..4468991
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/document.js
@@ -0,0 +1,33 @@
+'use strict'
+
+let Container = require('./container')
+
+let LazyResult, Processor
+
+class Document extends Container {
+  constructor(defaults) {
+    // type needs to be passed to super, otherwise child roots won't be normalized correctly
+    super({ type: 'document', ...defaults })
+
+    if (!this.nodes) {
+      this.nodes = []
+    }
+  }
+
+  toResult(opts = {}) {
+    let lazy = new LazyResult(new Processor(), this, opts)
+
+    return lazy.stringify()
+  }
+}
+
+Document.registerLazyResult = dependant => {
+  LazyResult = dependant
+}
+
+Document.registerProcessor = dependant => {
+  Processor = dependant
+}
+
+module.exports = Document
+Document.default = Document
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/fromJSON.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/fromJSON.d.ts
new file mode 100644
index 0000000..3a0c5b8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/fromJSON.d.ts
@@ -0,0 +1,9 @@
+import { JSONHydrator } from './postcss.js'
+
+interface FromJSON extends JSONHydrator {
+  default: FromJSON
+}
+
+declare let fromJSON: FromJSON
+
+export = fromJSON
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/fromJSON.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/fromJSON.js
new file mode 100644
index 0000000..c9ac1a8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/fromJSON.js
@@ -0,0 +1,54 @@
+'use strict'
+
+let AtRule = require('./at-rule')
+let Comment = require('./comment')
+let Declaration = require('./declaration')
+let Input = require('./input')
+let PreviousMap = require('./previous-map')
+let Root = require('./root')
+let Rule = require('./rule')
+
+function fromJSON(json, inputs) {
+  if (Array.isArray(json)) return json.map(n => fromJSON(n))
+
+  let { inputs: ownInputs, ...defaults } = json
+  if (ownInputs) {
+    inputs = []
+    for (let input of ownInputs) {
+      let inputHydrated = { ...input, __proto__: Input.prototype }
+      if (inputHydrated.map) {
+        inputHydrated.map = {
+          ...inputHydrated.map,
+          __proto__: PreviousMap.prototype
+        }
+      }
+      inputs.push(inputHydrated)
+    }
+  }
+  if (defaults.nodes) {
+    defaults.nodes = json.nodes.map(n => fromJSON(n, inputs))
+  }
+  if (defaults.source) {
+    let { inputId, ...source } = defaults.source
+    defaults.source = source
+    if (inputId != null) {
+      defaults.source.input = inputs[inputId]
+    }
+  }
+  if (defaults.type === 'root') {
+    return new Root(defaults)
+  } else if (defaults.type === 'decl') {
+    return new Declaration(defaults)
+  } else if (defaults.type === 'rule') {
+    return new Rule(defaults)
+  } else if (defaults.type === 'comment') {
+    return new Comment(defaults)
+  } else if (defaults.type === 'atrule') {
+    return new AtRule(defaults)
+  } else {
+    throw new Error('Unknown node type: ' + json.type)
+  }
+}
+
+module.exports = fromJSON
+fromJSON.default = fromJSON
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/input.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/input.d.ts
new file mode 100644
index 0000000..ca2d26b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/input.d.ts
@@ -0,0 +1,226 @@
+import { CssSyntaxError, ProcessOptions } from './postcss.js'
+import PreviousMap from './previous-map.js'
+
+declare namespace Input {
+  export interface FilePosition {
+    /**
+     * Column of inclusive start position in source file.
+     */
+    column: number
+
+    /**
+     * Column of exclusive end position in source file.
+     */
+    endColumn?: number
+
+    /**
+     * Line of exclusive end position in source file.
+     */
+    endLine?: number
+
+    /**
+     * Offset of exclusive end position in source file.
+     */
+    endOffset?: number
+
+    /**
+     * Absolute path to the source file.
+     */
+    file?: string
+
+    /**
+     * Line of inclusive start position in source file.
+     */
+    line: number
+
+    /**
+     * Offset of inclusive start position in source file.
+     */
+    offset: number
+
+    /**
+     * Source code.
+     */
+    source?: string
+
+    /**
+     * URL for the source file.
+     */
+    url: string
+  }
+
+  export { Input_ as default }
+}
+
+/**
+ * Represents the source CSS.
+ *
+ * ```js
+ * const root  = postcss.parse(css, { from: file })
+ * const input = root.source.input
+ * ```
+ */
+declare class Input_ {
+  /**
+   * Input CSS source.
+   *
+   * ```js
+   * const input = postcss.parse('a{}', { from: file }).input
+   * input.css //=> "a{}"
+   * ```
+   */
+  css: string
+
+  /**
+   * Input source with support for non-CSS documents.
+   *
+   * ```js
+   * const input = postcss.parse('a{}', { from: file, document: '<style>a {}</style>' }).input
+   * input.document //=> "<style>a {}</style>"
+   * input.css //=> "a{}"
+   * ```
+   */
+  document: string
+
+  /**
+   * The absolute path to the CSS source file defined
+   * with the `from` option.
+   *
+   * ```js
+   * const root = postcss.parse(css, { from: 'a.css' })
+   * root.source.input.file //=> '/home/ai/a.css'
+   * ```
+   */
+  file?: string
+
+  /**
+   * The flag to indicate whether or not the source code has Unicode BOM.
+   */
+  hasBOM: boolean
+
+  /**
+   * The unique ID of the CSS source. It will be created if `from` option
+   * is not provided (because PostCSS does not know the file path).
+   *
+   * ```js
+   * const root = postcss.parse(css)
+   * root.source.input.file //=> undefined
+   * root.source.input.id   //=> "<input css 8LZeVF>"
+   * ```
+   */
+  id?: string
+
+  /**
+   * The input source map passed from a compilation step before PostCSS
+   * (for example, from Sass compiler).
+   *
+   * ```js
+   * root.source.input.map.consumer().sources //=> ['a.sass']
+   * ```
+   */
+  map: PreviousMap
+
+  /**
+   * The CSS source identifier. Contains `Input#file` if the user
+   * set the `from` option, or `Input#id` if they did not.
+   *
+   * ```js
+   * const root = postcss.parse(css, { from: 'a.css' })
+   * root.source.input.from //=> "/home/ai/a.css"
+   *
+   * const root = postcss.parse(css)
+   * root.source.input.from //=> "<input css 1>"
+   * ```
+   */
+  get from(): string
+
+  /**
+   * @param css  Input CSS source.
+   * @param opts Process options.
+   */
+  constructor(css: string, opts?: ProcessOptions)
+
+  /**
+   * Returns `CssSyntaxError` with information about the error and its position.
+   */
+  error(
+    message: string,
+    start:
+      | {
+          column: number
+          line: number
+        }
+      | {
+          offset: number
+        },
+    end:
+      | {
+          column: number
+          line: number
+        }
+      | {
+          offset: number
+        },
+    opts?: { plugin?: CssSyntaxError['plugin'] }
+  ): CssSyntaxError
+  error(
+    message: string,
+    line: number,
+    column: number,
+    opts?: { plugin?: CssSyntaxError['plugin'] }
+  ): CssSyntaxError
+  error(
+    message: string,
+    offset: number,
+    opts?: { plugin?: CssSyntaxError['plugin'] }
+  ): CssSyntaxError
+
+  /**
+   * Converts source line and column to offset.
+   *
+   * @param line   Source line.
+   * @param column Source column.
+   * @return Source offset.
+   */
+  fromLineAndColumn(line: number, column: number): number
+
+  /**
+   * Converts source offset to line and column.
+   *
+   * @param offset Source offset.
+   */
+  fromOffset(offset: number): { col: number; line: number } | null
+
+  /**
+   * Reads the input source map and returns a symbol position
+   * in the input source (e.g., in a Sass file that was compiled
+   * to CSS before being passed to PostCSS). Optionally takes an
+   * end position, exclusive.
+   *
+   * ```js
+   * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }
+   * root.source.input.origin(1, 1, 1, 4)
+   * //=> { file: 'a.css', line: 3, column: 1, endLine: 3, endColumn: 4 }
+   * ```
+   *
+   * @param line      Line for inclusive start position in input CSS.
+   * @param column    Column for inclusive start position in input CSS.
+   * @param endLine   Line for exclusive end position in input CSS.
+   * @param endColumn Column for exclusive end position in input CSS.
+   *
+   * @return Position in input source.
+   */
+  origin(
+    line: number,
+    column: number,
+    endLine?: number,
+    endColumn?: number
+  ): false | Input.FilePosition
+
+  /** Converts this to a JSON-friendly object representation. */
+  toJSON(): object
+}
+
+declare class Input extends Input_ {}
+
+export = Input
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/input.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/input.js
new file mode 100644
index 0000000..1dab928
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/input.js
@@ -0,0 +1,273 @@
+'use strict'
+
+let { nanoid } = require('nanoid/non-secure')
+let { isAbsolute, resolve } = require('path')
+let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
+let { fileURLToPath, pathToFileURL } = require('url')
+
+let CssSyntaxError = require('./css-syntax-error')
+let PreviousMap = require('./previous-map')
+let terminalHighlight = require('./terminal-highlight')
+
+let lineToIndexCache = Symbol('lineToIndexCache')
+
+let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)
+let pathAvailable = Boolean(resolve && isAbsolute)
+
+function getLineToIndex(input) {
+  if (input[lineToIndexCache]) return input[lineToIndexCache]
+  let lines = input.css.split('\n')
+  let lineToIndex = new Array(lines.length)
+  let prevIndex = 0
+
+  for (let i = 0, l = lines.length; i < l; i++) {
+    lineToIndex[i] = prevIndex
+    prevIndex += lines[i].length + 1
+  }
+
+  input[lineToIndexCache] = lineToIndex
+  return lineToIndex
+}
+
+class Input {
+  get from() {
+    return this.file || this.id
+  }
+
+  constructor(css, opts = {}) {
+    if (
+      css === null ||
+      typeof css === 'undefined' ||
+      (typeof css === 'object' && !css.toString)
+    ) {
+      throw new Error(`PostCSS received ${css} instead of CSS string`)
+    }
+
+    this.css = css.toString()
+
+    if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') {
+      this.hasBOM = true
+      this.css = this.css.slice(1)
+    } else {
+      this.hasBOM = false
+    }
+
+    this.document = this.css
+    if (opts.document) this.document = opts.document.toString()
+
+    if (opts.from) {
+      if (
+        !pathAvailable ||
+        /^\w+:\/\//.test(opts.from) ||
+        isAbsolute(opts.from)
+      ) {
+        this.file = opts.from
+      } else {
+        this.file = resolve(opts.from)
+      }
+    }
+
+    if (pathAvailable && sourceMapAvailable) {
+      let map = new PreviousMap(this.css, opts)
+      if (map.text) {
+        this.map = map
+        let file = map.consumer().file
+        if (!this.file && file) this.file = this.mapResolve(file)
+      }
+    }
+
+    if (!this.file) {
+      this.id = '<input css ' + nanoid(6) + '>'
+    }
+    if (this.map) this.map.file = this.from
+  }
+
+  error(message, line, column, opts = {}) {
+    let endColumn, endLine, endOffset, offset, result
+
+    if (line && typeof line === 'object') {
+      let start = line
+      let end = column
+      if (typeof start.offset === 'number') {
+        offset = start.offset
+        let pos = this.fromOffset(offset)
+        line = pos.line
+        column = pos.col
+      } else {
+        line = start.line
+        column = start.column
+        offset = this.fromLineAndColumn(line, column)
+      }
+      if (typeof end.offset === 'number') {
+        endOffset = end.offset
+        let pos = this.fromOffset(endOffset)
+        endLine = pos.line
+        endColumn = pos.col
+      } else {
+        endLine = end.line
+        endColumn = end.column
+        endOffset = this.fromLineAndColumn(end.line, end.column)
+      }
+    } else if (!column) {
+      offset = line
+      let pos = this.fromOffset(offset)
+      line = pos.line
+      column = pos.col
+    } else {
+      offset = this.fromLineAndColumn(line, column)
+    }
+
+    let origin = this.origin(line, column, endLine, endColumn)
+    if (origin) {
+      result = new CssSyntaxError(
+        message,
+        origin.endLine === undefined
+          ? origin.line
+          : { column: origin.column, line: origin.line },
+        origin.endLine === undefined
+          ? origin.column
+          : { column: origin.endColumn, line: origin.endLine },
+        origin.source,
+        origin.file,
+        opts.plugin
+      )
+    } else {
+      result = new CssSyntaxError(
+        message,
+        endLine === undefined ? line : { column, line },
+        endLine === undefined ? column : { column: endColumn, line: endLine },
+        this.css,
+        this.file,
+        opts.plugin
+      )
+    }
+
+    result.input = {
+      column,
+      endColumn,
+      endLine,
+      endOffset,
+      line,
+      offset,
+      source: this.css
+    }
+    if (this.file) {
+      if (pathToFileURL) {
+        result.input.url = pathToFileURL(this.file).toString()
+      }
+      result.input.file = this.file
+    }
+
+    return result
+  }
+
+  fromLineAndColumn(line, column) {
+    let lineToIndex = getLineToIndex(this)
+    let index = lineToIndex[line - 1]
+    return index + column - 1
+  }
+
+  fromOffset(offset) {
+    let lineToIndex = getLineToIndex(this)
+    let lastLine = lineToIndex[lineToIndex.length - 1]
+
+    let min = 0
+    if (offset >= lastLine) {
+      min = lineToIndex.length - 1
+    } else {
+      let max = lineToIndex.length - 2
+      let mid
+      while (min < max) {
+        mid = min + ((max - min) >> 1)
+        if (offset < lineToIndex[mid]) {
+          max = mid - 1
+        } else if (offset >= lineToIndex[mid + 1]) {
+          min = mid + 1
+        } else {
+          min = mid
+          break
+        }
+      }
+    }
+    return {
+      col: offset - lineToIndex[min] + 1,
+      line: min + 1
+    }
+  }
+
+  mapResolve(file) {
+    if (/^\w+:\/\//.test(file)) {
+      return file
+    }
+    return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file)
+  }
+
+  origin(line, column, endLine, endColumn) {
+    if (!this.map) return false
+    let consumer = this.map.consumer()
+
+    let from = consumer.originalPositionFor({ column, line })
+    if (!from.source) return false
+
+    let to
+    if (typeof endLine === 'number') {
+      to = consumer.originalPositionFor({ column: endColumn, line: endLine })
+    }
+
+    let fromUrl
+
+    if (isAbsolute(from.source)) {
+      fromUrl = pathToFileURL(from.source)
+    } else {
+      fromUrl = new URL(
+        from.source,
+        this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile)
+      )
+    }
+
+    let result = {
+      column: from.column,
+      endColumn: to && to.column,
+      endLine: to && to.line,
+      line: from.line,
+      url: fromUrl.toString()
+    }
+
+    if (fromUrl.protocol === 'file:') {
+      if (fileURLToPath) {
+        result.file = fileURLToPath(fromUrl)
+      } else {
+        /* c8 ignore next 2 */
+        throw new Error(`file: protocol is not available in this PostCSS build`)
+      }
+    }
+
+    let source = consumer.sourceContentFor(from.source)
+    if (source) result.source = source
+
+    return result
+  }
+
+  toJSON() {
+    let json = {}
+    for (let name of ['hasBOM', 'css', 'file', 'id']) {
+      if (this[name] != null) {
+        json[name] = this[name]
+      }
+    }
+    if (this.map) {
+      json.map = { ...this.map }
+      if (json.map.consumerCache) {
+        json.map.consumerCache = undefined
+      }
+    }
+    return json
+  }
+}
+
+module.exports = Input
+Input.default = Input
+
+if (terminalHighlight && terminalHighlight.registerInput) {
+  terminalHighlight.registerInput(Input)
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/lazy-result.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/lazy-result.d.ts
new file mode 100644
index 0000000..599a614
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/lazy-result.d.ts
@@ -0,0 +1,189 @@
+import Document from './document.js'
+import { SourceMap } from './postcss.js'
+import Processor from './processor.js'
+import Result, { Message, ResultOptions } from './result.js'
+import Root from './root.js'
+import Warning from './warning.js'
+
+declare namespace LazyResult {
+  export { LazyResult_ as default }
+}
+
+/**
+ * A Promise proxy for the result of PostCSS transformations.
+ *
+ * A `LazyResult` instance is returned by `Processor#process`.
+ *
+ * ```js
+ * const lazy = postcss([autoprefixer]).process(css)
+ * ```
+ */
+declare class LazyResult_<RootNode = Document | Root> implements PromiseLike<
+  Result<RootNode>
+> {
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls onRejected for each error thrown in any plugin.
+   *
+   * It implements standard Promise API.
+   *
+   * ```js
+   * postcss([autoprefixer]).process(css).then(result => {
+   *   console.log(result.css)
+   * }).catch(error => {
+   *   console.error(error)
+   * })
+   * ```
+   */
+  catch: Promise<Result<RootNode>>['catch']
+
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls onFinally on any error or when all plugins will finish work.
+   *
+   * It implements standard Promise API.
+   *
+   * ```js
+   * postcss([autoprefixer]).process(css).finally(() => {
+   *   console.log('processing ended')
+   * })
+   * ```
+   */
+  finally: Promise<Result<RootNode>>['finally']
+
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls `onFulfilled` with a Result instance. If a plugin throws
+   * an error, the `onRejected` callback will be executed.
+   *
+   * It implements standard Promise API.
+   *
+   * ```js
+   * postcss([autoprefixer]).process(css, { from: cssPath }).then(result => {
+   *   console.log(result.css)
+   * })
+   * ```
+   */
+  then: Promise<Result<RootNode>>['then']
+
+  /**
+   * An alias for the `css` property. Use it with syntaxes
+   * that generate non-CSS output.
+   *
+   * This property will only work with synchronous plugins.
+   * If the processor contains any asynchronous plugins
+   * it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get content(): string
+
+  /**
+   * Processes input CSS through synchronous plugins, converts `Root`
+   * to a CSS string and returns `Result#css`.
+   *
+   * This property will only work with synchronous plugins.
+   * If the processor contains any asynchronous plugins
+   * it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get css(): string
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and returns `Result#map`.
+   *
+   * This property will only work with synchronous plugins.
+   * If the processor contains any asynchronous plugins
+   * it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get map(): SourceMap
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and returns `Result#messages`.
+   *
+   * This property will only work with synchronous plugins. If the processor
+   * contains any asynchronous plugins it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get messages(): Message[]
+
+  /**
+   * Options from the `Processor#process` call.
+   */
+  get opts(): ResultOptions
+
+  /**
+   * Returns a `Processor` instance, which will be used
+   * for CSS transformations.
+   */
+  get processor(): Processor
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and returns `Result#root`.
+   *
+   * This property will only work with synchronous plugins. If the processor
+   * contains any asynchronous plugins it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get root(): RootNode
+
+  /**
+   * Returns the default string description of an object.
+   * Required to implement the Promise interface.
+   */
+  get [Symbol.toStringTag](): string
+
+  /**
+   * @param processor Processor used for this transformation.
+   * @param css       CSS to parse and transform.
+   * @param opts      Options from the `Processor#process` or `Root#toResult`.
+   */
+  constructor(processor: Processor, css: string, opts: ResultOptions)
+
+  /**
+   * Run plugin in async way and return `Result`.
+   *
+   * @return Result with output content.
+   */
+  async(): Promise<Result<RootNode>>
+
+  /**
+   * Run plugin in sync way and return `Result`.
+   *
+   * @return Result with output content.
+   */
+  sync(): Result<RootNode>
+
+  /**
+   * Alias for the `LazyResult#css` property.
+   *
+   * ```js
+   * lazy + '' === lazy.css
+   * ```
+   *
+   * @return Output CSS.
+   */
+  toString(): string
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and calls `Result#warnings`.
+   *
+   * @return Warnings from plugins.
+   */
+  warnings(): Warning[]
+}
+
+declare class LazyResult<
+  RootNode = Document | Root
+> extends LazyResult_<RootNode> {}
+
+export = LazyResult
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/lazy-result.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/lazy-result.js
new file mode 100644
index 0000000..9026a7c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/lazy-result.js
@@ -0,0 +1,563 @@
+'use strict'
+
+let Container = require('./container')
+let Document = require('./document')
+let MapGenerator = require('./map-generator')
+let parse = require('./parse')
+let Result = require('./result')
+let Root = require('./root')
+let stringify = require('./stringify')
+let { isClean, my } = require('./symbols')
+let warnOnce = require('./warn-once')
+
+const TYPE_TO_CLASS_NAME = {
+  atrule: 'AtRule',
+  comment: 'Comment',
+  decl: 'Declaration',
+  document: 'Document',
+  root: 'Root',
+  rule: 'Rule'
+}
+
+const PLUGIN_PROPS = {
+  AtRule: true,
+  AtRuleExit: true,
+  Comment: true,
+  CommentExit: true,
+  Declaration: true,
+  DeclarationExit: true,
+  Document: true,
+  DocumentExit: true,
+  Once: true,
+  OnceExit: true,
+  postcssPlugin: true,
+  prepare: true,
+  Root: true,
+  RootExit: true,
+  Rule: true,
+  RuleExit: true
+}
+
+const NOT_VISITORS = {
+  Once: true,
+  postcssPlugin: true,
+  prepare: true
+}
+
+const CHILDREN = 0
+
+function isPromise(obj) {
+  return typeof obj === 'object' && typeof obj.then === 'function'
+}
+
+function getEvents(node) {
+  let key = false
+  let type = TYPE_TO_CLASS_NAME[node.type]
+  if (node.type === 'decl') {
+    key = node.prop.toLowerCase()
+  } else if (node.type === 'atrule') {
+    key = node.name.toLowerCase()
+  }
+
+  if (key && node.append) {
+    return [
+      type,
+      type + '-' + key,
+      CHILDREN,
+      type + 'Exit',
+      type + 'Exit-' + key
+    ]
+  } else if (key) {
+    return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key]
+  } else if (node.append) {
+    return [type, CHILDREN, type + 'Exit']
+  } else {
+    return [type, type + 'Exit']
+  }
+}
+
+function toStack(node) {
+  let events
+  if (node.type === 'document') {
+    events = ['Document', CHILDREN, 'DocumentExit']
+  } else if (node.type === 'root') {
+    events = ['Root', CHILDREN, 'RootExit']
+  } else {
+    events = getEvents(node)
+  }
+
+  return {
+    eventIndex: 0,
+    events,
+    iterator: 0,
+    node,
+    visitorIndex: 0,
+    visitors: []
+  }
+}
+
+function cleanMarks(node) {
+  node[isClean] = false
+  if (node.nodes) node.nodes.forEach(i => cleanMarks(i))
+  return node
+}
+
+let postcss = {}
+
+class LazyResult {
+  get content() {
+    return this.stringify().content
+  }
+
+  get css() {
+    return this.stringify().css
+  }
+
+  get map() {
+    return this.stringify().map
+  }
+
+  get messages() {
+    return this.sync().messages
+  }
+
+  get opts() {
+    return this.result.opts
+  }
+
+  get processor() {
+    return this.result.processor
+  }
+
+  get root() {
+    return this.sync().root
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'LazyResult'
+  }
+
+  constructor(processor, css, opts) {
+    this.stringified = false
+    this.processed = false
+
+    let root
+    if (
+      typeof css === 'object' &&
+      css !== null &&
+      (css.type === 'root' || css.type === 'document')
+    ) {
+      root = cleanMarks(css)
+    } else if (css instanceof LazyResult || css instanceof Result) {
+      root = cleanMarks(css.root)
+      if (css.map) {
+        if (typeof opts.map === 'undefined') opts.map = {}
+        if (!opts.map.inline) opts.map.inline = false
+        opts.map.prev = css.map
+      }
+    } else {
+      let parser = parse
+      if (opts.syntax) parser = opts.syntax.parse
+      if (opts.parser) parser = opts.parser
+      if (parser.parse) parser = parser.parse
+
+      try {
+        root = parser(css, opts)
+      } catch (error) {
+        this.processed = true
+        this.error = error
+      }
+
+      if (root && !root[my]) {
+        /* c8 ignore next 2 */
+        Container.rebuild(root)
+      }
+    }
+
+    this.result = new Result(processor, root, opts)
+    this.helpers = { ...postcss, postcss, result: this.result }
+    this.plugins = this.processor.plugins.map(plugin => {
+      if (typeof plugin === 'object' && plugin.prepare) {
+        return { ...plugin, ...plugin.prepare(this.result) }
+      } else {
+        return plugin
+      }
+    })
+  }
+
+  async() {
+    if (this.error) return Promise.reject(this.error)
+    if (this.processed) return Promise.resolve(this.result)
+    if (!this.processing) {
+      this.processing = this.runAsync()
+    }
+    return this.processing
+  }
+
+  catch(onRejected) {
+    return this.async().catch(onRejected)
+  }
+
+  finally(onFinally) {
+    return this.async().then(onFinally, onFinally)
+  }
+
+  getAsyncError() {
+    throw new Error('Use process(css).then(cb) to work with async plugins')
+  }
+
+  handleError(error, node) {
+    let plugin = this.result.lastPlugin
+    try {
+      if (node) node.addToError(error)
+      this.error = error
+      if (error.name === 'CssSyntaxError' && !error.plugin) {
+        error.plugin = plugin.postcssPlugin
+        error.setMessage()
+      } else if (plugin.postcssVersion) {
+        if (process.env.NODE_ENV !== 'production') {
+          let pluginName = plugin.postcssPlugin
+          let pluginVer = plugin.postcssVersion
+          let runtimeVer = this.result.processor.version
+          let a = pluginVer.split('.')
+          let b = runtimeVer.split('.')
+
+          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
+            // eslint-disable-next-line no-console
+            console.error(
+              'Unknown error from PostCSS plugin. Your current PostCSS ' +
+                'version is ' +
+                runtimeVer +
+                ', but ' +
+                pluginName +
+                ' uses ' +
+                pluginVer +
+                '. Perhaps this is the source of the error below.'
+            )
+          }
+        }
+      }
+    } catch (err) {
+      /* c8 ignore next 3 */
+      // eslint-disable-next-line no-console
+      if (console && console.error) console.error(err)
+    }
+    return error
+  }
+
+  prepareVisitors() {
+    this.listeners = {}
+    let add = (plugin, type, cb) => {
+      if (!this.listeners[type]) this.listeners[type] = []
+      this.listeners[type].push([plugin, cb])
+    }
+    for (let plugin of this.plugins) {
+      if (typeof plugin === 'object') {
+        for (let event in plugin) {
+          if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
+            throw new Error(
+              `Unknown event ${event} in ${plugin.postcssPlugin}. ` +
+                `Try to update PostCSS (${this.processor.version} now).`
+            )
+          }
+          if (!NOT_VISITORS[event]) {
+            if (typeof plugin[event] === 'object') {
+              for (let filter in plugin[event]) {
+                if (filter === '*') {
+                  add(plugin, event, plugin[event][filter])
+                } else {
+                  add(
+                    plugin,
+                    event + '-' + filter.toLowerCase(),
+                    plugin[event][filter]
+                  )
+                }
+              }
+            } else if (typeof plugin[event] === 'function') {
+              add(plugin, event, plugin[event])
+            }
+          }
+        }
+      }
+    }
+    this.hasListener = Object.keys(this.listeners).length > 0
+  }
+
+  async runAsync() {
+    this.plugin = 0
+    for (let i = 0; i < this.plugins.length; i++) {
+      let plugin = this.plugins[i]
+      let promise = this.runOnRoot(plugin)
+      if (isPromise(promise)) {
+        try {
+          await promise
+        } catch (error) {
+          throw this.handleError(error)
+        }
+      }
+    }
+
+    this.prepareVisitors()
+    if (this.hasListener) {
+      let root = this.result.root
+      while (!root[isClean]) {
+        root[isClean] = true
+        let stack = [toStack(root)]
+        while (stack.length > 0) {
+          let promise = this.visitTick(stack)
+          if (isPromise(promise)) {
+            try {
+              await promise
+            } catch (e) {
+              let node = stack[stack.length - 1].node
+              throw this.handleError(e, node)
+            }
+          }
+        }
+      }
+
+      if (this.listeners.OnceExit) {
+        for (let [plugin, visitor] of this.listeners.OnceExit) {
+          this.result.lastPlugin = plugin
+          try {
+            if (root.type === 'document') {
+              let roots = root.nodes.map(subRoot =>
+                visitor(subRoot, this.helpers)
+              )
+
+              await Promise.all(roots)
+            } else {
+              await visitor(root, this.helpers)
+            }
+          } catch (e) {
+            throw this.handleError(e)
+          }
+        }
+      }
+    }
+
+    this.processed = true
+    return this.stringify()
+  }
+
+  runOnRoot(plugin) {
+    this.result.lastPlugin = plugin
+    try {
+      if (typeof plugin === 'object' && plugin.Once) {
+        if (this.result.root.type === 'document') {
+          let roots = this.result.root.nodes.map(root =>
+            plugin.Once(root, this.helpers)
+          )
+
+          if (isPromise(roots[0])) {
+            return Promise.all(roots)
+          }
+
+          return roots
+        }
+
+        return plugin.Once(this.result.root, this.helpers)
+      } else if (typeof plugin === 'function') {
+        return plugin(this.result.root, this.result)
+      }
+    } catch (error) {
+      throw this.handleError(error)
+    }
+  }
+
+  stringify() {
+    if (this.error) throw this.error
+    if (this.stringified) return this.result
+    this.stringified = true
+
+    this.sync()
+
+    let opts = this.result.opts
+    let str = stringify
+    if (opts.syntax) str = opts.syntax.stringify
+    if (opts.stringifier) str = opts.stringifier
+    if (str.stringify) str = str.stringify
+
+    let rootSource = this.result.root.source
+    if (
+      opts.map === undefined &&
+      !(rootSource && rootSource.input && rootSource.input.map)
+    ) {
+      let result = ''
+      str(this.result.root, i => {
+        result += i
+      })
+      this.result.css = result
+      return this.result
+    }
+
+    let map = new MapGenerator(str, this.result.root, this.result.opts)
+    let data = map.generate()
+    this.result.css = data[0]
+    this.result.map = data[1]
+
+    return this.result
+  }
+
+  sync() {
+    if (this.error) throw this.error
+    if (this.processed) return this.result
+    this.processed = true
+
+    if (this.processing) {
+      throw this.getAsyncError()
+    }
+
+    for (let plugin of this.plugins) {
+      let promise = this.runOnRoot(plugin)
+      if (isPromise(promise)) {
+        throw this.getAsyncError()
+      }
+    }
+
+    this.prepareVisitors()
+    if (this.hasListener) {
+      let root = this.result.root
+      while (!root[isClean]) {
+        root[isClean] = true
+        this.walkSync(root)
+      }
+      if (this.listeners.OnceExit) {
+        if (root.type === 'document') {
+          for (let subRoot of root.nodes) {
+            this.visitSync(this.listeners.OnceExit, subRoot)
+          }
+        } else {
+          this.visitSync(this.listeners.OnceExit, root)
+        }
+      }
+    }
+
+    return this.result
+  }
+
+  then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!('from' in this.opts)) {
+        warnOnce(
+          'Without `from` option PostCSS could generate wrong source map ' +
+            'and will not find Browserslist config. Set it to CSS file path ' +
+            'or to `undefined` to prevent this warning.'
+        )
+      }
+    }
+    return this.async().then(onFulfilled, onRejected)
+  }
+
+  toString() {
+    return this.css
+  }
+
+  visitSync(visitors, node) {
+    for (let [plugin, visitor] of visitors) {
+      this.result.lastPlugin = plugin
+      let promise
+      try {
+        promise = visitor(node, this.helpers)
+      } catch (e) {
+        throw this.handleError(e, node.proxyOf)
+      }
+      if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
+        return true
+      }
+      if (isPromise(promise)) {
+        throw this.getAsyncError()
+      }
+    }
+  }
+
+  visitTick(stack) {
+    let visit = stack[stack.length - 1]
+    let { node, visitors } = visit
+
+    if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
+      stack.pop()
+      return
+    }
+
+    if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
+      let [plugin, visitor] = visitors[visit.visitorIndex]
+      visit.visitorIndex += 1
+      if (visit.visitorIndex === visitors.length) {
+        visit.visitors = []
+        visit.visitorIndex = 0
+      }
+      this.result.lastPlugin = plugin
+      try {
+        return visitor(node.toProxy(), this.helpers)
+      } catch (e) {
+        throw this.handleError(e, node)
+      }
+    }
+
+    if (visit.iterator !== 0) {
+      let iterator = visit.iterator
+      let child
+      while ((child = node.nodes[node.indexes[iterator]])) {
+        node.indexes[iterator] += 1
+        if (!child[isClean]) {
+          child[isClean] = true
+          stack.push(toStack(child))
+          return
+        }
+      }
+      visit.iterator = 0
+      delete node.indexes[iterator]
+    }
+
+    let events = visit.events
+    while (visit.eventIndex < events.length) {
+      let event = events[visit.eventIndex]
+      visit.eventIndex += 1
+      if (event === CHILDREN) {
+        if (node.nodes && node.nodes.length) {
+          node[isClean] = true
+          visit.iterator = node.getIterator()
+        }
+        return
+      } else if (this.listeners[event]) {
+        visit.visitors = this.listeners[event]
+        return
+      }
+    }
+    stack.pop()
+  }
+
+  walkSync(node) {
+    node[isClean] = true
+    let events = getEvents(node)
+    for (let event of events) {
+      if (event === CHILDREN) {
+        if (node.nodes) {
+          node.each(child => {
+            if (!child[isClean]) this.walkSync(child)
+          })
+        }
+      } else {
+        let visitors = this.listeners[event]
+        if (visitors) {
+          if (this.visitSync(visitors, node.toProxy())) return
+        }
+      }
+    }
+  }
+
+  warnings() {
+    return this.sync().warnings()
+  }
+}
+
+LazyResult.registerPostcss = dependant => {
+  postcss = dependant
+}
+
+module.exports = LazyResult
+LazyResult.default = LazyResult
+
+Root.registerLazyResult(LazyResult)
+Document.registerLazyResult(LazyResult)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/list.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/list.d.ts
new file mode 100644
index 0000000..119624e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/list.d.ts
@@ -0,0 +1,60 @@
+declare namespace list {
+  type List = {
+    /**
+     * Safely splits comma-separated values (such as those for `transition-*`
+     * and `background` properties).
+     *
+     * ```js
+     * Once (root, { list }) {
+     *   list.comma('black, linear-gradient(white, black)')
+     *   //=> ['black', 'linear-gradient(white, black)']
+     * }
+     * ```
+     *
+     * @param str Comma-separated values.
+     * @return Split values.
+     */
+    comma(str: string): string[]
+
+    default: List
+
+    /**
+     * Safely splits space-separated values (such as those for `background`,
+     * `border-radius`, and other shorthand properties).
+     *
+     * ```js
+     * Once (root, { list }) {
+     *   list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)']
+     * }
+     * ```
+     *
+     * @param str Space-separated values.
+     * @return Split values.
+     */
+    space(str: string): string[]
+
+    /**
+     * Safely splits values.
+     *
+     * ```js
+     * Once (root, { list }) {
+     *   list.split('1px calc(10% + 1px)', [' ', '\n', '\t']) //=> ['1px', 'calc(10% + 1px)']
+     * }
+     * ```
+     *
+     * @param string separated values.
+     * @param separators array of separators.
+     * @param last boolean indicator.
+     * @return Split values.
+     */
+    split(
+      string: string,
+      separators: readonly string[],
+      last: boolean
+    ): string[]
+  }
+}
+
+declare let list: list.List
+
+export = list
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/list.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/list.js
new file mode 100644
index 0000000..1b31f98
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/list.js
@@ -0,0 +1,58 @@
+'use strict'
+
+let list = {
+  comma(string) {
+    return list.split(string, [','], true)
+  },
+
+  space(string) {
+    let spaces = [' ', '\n', '\t']
+    return list.split(string, spaces)
+  },
+
+  split(string, separators, last) {
+    let array = []
+    let current = ''
+    let split = false
+
+    let func = 0
+    let inQuote = false
+    let prevQuote = ''
+    let escape = false
+
+    for (let letter of string) {
+      if (escape) {
+        escape = false
+      } else if (letter === '\\') {
+        escape = true
+      } else if (inQuote) {
+        if (letter === prevQuote) {
+          inQuote = false
+        }
+      } else if (letter === '"' || letter === "'") {
+        inQuote = true
+        prevQuote = letter
+      } else if (letter === '(') {
+        func += 1
+      } else if (letter === ')') {
+        if (func > 0) func -= 1
+      } else if (func === 0) {
+        if (separators.includes(letter)) split = true
+      }
+
+      if (split) {
+        if (current !== '') array.push(current.trim())
+        current = ''
+        split = false
+      } else {
+        current += letter
+      }
+    }
+
+    if (last || current !== '') array.push(current.trim())
+    return array
+  }
+}
+
+module.exports = list
+list.default = list
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/map-generator.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/map-generator.js
new file mode 100644
index 0000000..df880ac
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/map-generator.js
@@ -0,0 +1,376 @@
+'use strict'
+
+let { dirname, relative, resolve, sep } = require('path')
+let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
+let { pathToFileURL } = require('url')
+
+let Input = require('./input')
+
+let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)
+let pathAvailable = Boolean(dirname && resolve && relative && sep)
+
+class MapGenerator {
+  constructor(stringify, root, opts, cssString) {
+    this.stringify = stringify
+    this.mapOpts = opts.map || {}
+    this.root = root
+    this.opts = opts
+    this.css = cssString
+    this.originalCSS = cssString
+    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute
+
+    this.memoizedFileURLs = new Map()
+    this.memoizedPaths = new Map()
+    this.memoizedURLs = new Map()
+  }
+
+  addAnnotation() {
+    let content
+
+    if (this.isInline()) {
+      content =
+        'data:application/json;base64,' + this.toBase64(this.map.toString())
+    } else if (typeof this.mapOpts.annotation === 'string') {
+      content = this.mapOpts.annotation
+    } else if (typeof this.mapOpts.annotation === 'function') {
+      content = this.mapOpts.annotation(this.opts.to, this.root)
+    } else {
+      content = this.outputFile() + '.map'
+    }
+    let eol = '\n'
+    if (this.css.includes('\r\n')) eol = '\r\n'
+
+    this.css += eol + '/*# sourceMappingURL=' + content + ' */'
+  }
+
+  applyPrevMaps() {
+    for (let prev of this.previous()) {
+      let from = this.toUrl(this.path(prev.file))
+      let root = prev.root || dirname(prev.file)
+      let map
+
+      if (this.mapOpts.sourcesContent === false) {
+        map = new SourceMapConsumer(prev.text)
+        if (map.sourcesContent) {
+          map.sourcesContent = null
+        }
+      } else {
+        map = prev.consumer()
+      }
+
+      this.map.applySourceMap(map, from, this.toUrl(this.path(root)))
+    }
+  }
+
+  clearAnnotation() {
+    if (this.mapOpts.annotation === false) return
+
+    if (this.root) {
+      let node
+      for (let i = this.root.nodes.length - 1; i >= 0; i--) {
+        node = this.root.nodes[i]
+        if (node.type !== 'comment') continue
+        if (node.text.startsWith('# sourceMappingURL=')) {
+          this.root.removeChild(i)
+        }
+      }
+    } else if (this.css) {
+      let startIndex
+      while ((startIndex = this.css.lastIndexOf('/*#')) !== -1) {
+        let endIndex = this.css.indexOf('*/', startIndex + 3)
+        if (endIndex === -1) break
+        while (startIndex > 0 && this.css[startIndex - 1] === '\n') {
+          startIndex--
+        }
+        this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2)
+      }
+    }
+  }
+
+  generate() {
+    this.clearAnnotation()
+    if (pathAvailable && sourceMapAvailable && this.isMap()) {
+      return this.generateMap()
+    } else {
+      let result = ''
+      this.stringify(this.root, i => {
+        result += i
+      })
+      return [result]
+    }
+  }
+
+  generateMap() {
+    if (this.root) {
+      this.generateString()
+    } else if (this.previous().length === 1) {
+      let prev = this.previous()[0].consumer()
+      prev.file = this.outputFile()
+      this.map = SourceMapGenerator.fromSourceMap(prev, {
+        ignoreInvalidMapping: true
+      })
+    } else {
+      this.map = new SourceMapGenerator({
+        file: this.outputFile(),
+        ignoreInvalidMapping: true
+      })
+      this.map.addMapping({
+        generated: { column: 0, line: 1 },
+        original: { column: 0, line: 1 },
+        source: this.opts.from
+          ? this.toUrl(this.path(this.opts.from))
+          : '<no source>'
+      })
+    }
+
+    if (this.isSourcesContent()) this.setSourcesContent()
+    if (this.root && this.previous().length > 0) this.applyPrevMaps()
+    if (this.isAnnotation()) this.addAnnotation()
+
+    if (this.isInline()) {
+      return [this.css]
+    } else {
+      return [this.css, this.map]
+    }
+  }
+
+  generateString() {
+    this.css = ''
+    this.map = new SourceMapGenerator({
+      file: this.outputFile(),
+      ignoreInvalidMapping: true
+    })
+
+    let line = 1
+    let column = 1
+
+    let noSource = '<no source>'
+    let mapping = {
+      generated: { column: 0, line: 0 },
+      original: { column: 0, line: 0 },
+      source: ''
+    }
+
+    let last, lines
+    this.stringify(this.root, (str, node, type) => {
+      this.css += str
+
+      if (node && type !== 'end') {
+        mapping.generated.line = line
+        mapping.generated.column = column - 1
+        if (node.source && node.source.start) {
+          mapping.source = this.sourcePath(node)
+          mapping.original.line = node.source.start.line
+          mapping.original.column = node.source.start.column - 1
+          this.map.addMapping(mapping)
+        } else {
+          mapping.source = noSource
+          mapping.original.line = 1
+          mapping.original.column = 0
+          this.map.addMapping(mapping)
+        }
+      }
+
+      lines = str.match(/\n/g)
+      if (lines) {
+        line += lines.length
+        last = str.lastIndexOf('\n')
+        column = str.length - last
+      } else {
+        column += str.length
+      }
+
+      if (node && type !== 'start') {
+        let p = node.parent || { raws: {} }
+        let childless =
+          node.type === 'decl' || (node.type === 'atrule' && !node.nodes)
+        if (!childless || node !== p.last || p.raws.semicolon) {
+          if (node.source && node.source.end) {
+            mapping.source = this.sourcePath(node)
+            mapping.original.line = node.source.end.line
+            mapping.original.column = node.source.end.column - 1
+            mapping.generated.line = line
+            mapping.generated.column = column - 2
+            this.map.addMapping(mapping)
+          } else {
+            mapping.source = noSource
+            mapping.original.line = 1
+            mapping.original.column = 0
+            mapping.generated.line = line
+            mapping.generated.column = column - 1
+            this.map.addMapping(mapping)
+          }
+        }
+      }
+    })
+  }
+
+  isAnnotation() {
+    if (this.isInline()) {
+      return true
+    }
+    if (typeof this.mapOpts.annotation !== 'undefined') {
+      return this.mapOpts.annotation
+    }
+    if (this.previous().length) {
+      return this.previous().some(i => i.annotation)
+    }
+    return true
+  }
+
+  isInline() {
+    if (typeof this.mapOpts.inline !== 'undefined') {
+      return this.mapOpts.inline
+    }
+
+    let annotation = this.mapOpts.annotation
+    if (typeof annotation !== 'undefined' && annotation !== true) {
+      return false
+    }
+
+    if (this.previous().length) {
+      return this.previous().some(i => i.inline)
+    }
+    return true
+  }
+
+  isMap() {
+    if (typeof this.opts.map !== 'undefined') {
+      return !!this.opts.map
+    }
+    return this.previous().length > 0
+  }
+
+  isSourcesContent() {
+    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
+      return this.mapOpts.sourcesContent
+    }
+    if (this.previous().length) {
+      return this.previous().some(i => i.withContent())
+    }
+    return true
+  }
+
+  outputFile() {
+    if (this.opts.to) {
+      return this.path(this.opts.to)
+    } else if (this.opts.from) {
+      return this.path(this.opts.from)
+    } else {
+      return 'to.css'
+    }
+  }
+
+  path(file) {
+    if (this.mapOpts.absolute) return file
+    if (file.charCodeAt(0) === 60 /* `<` */) return file
+    if (/^\w+:\/\//.test(file)) return file
+    let cached = this.memoizedPaths.get(file)
+    if (cached) return cached
+
+    let from = this.opts.to ? dirname(this.opts.to) : '.'
+
+    if (typeof this.mapOpts.annotation === 'string') {
+      from = dirname(resolve(from, this.mapOpts.annotation))
+    }
+
+    let path = relative(from, file)
+    this.memoizedPaths.set(file, path)
+
+    return path
+  }
+
+  previous() {
+    if (!this.previousMaps) {
+      this.previousMaps = []
+      if (this.root) {
+        this.root.walk(node => {
+          if (node.source && node.source.input.map) {
+            let map = node.source.input.map
+            if (!this.previousMaps.includes(map)) {
+              this.previousMaps.push(map)
+            }
+          }
+        })
+      } else {
+        let input = new Input(this.originalCSS, this.opts)
+        if (input.map) this.previousMaps.push(input.map)
+      }
+    }
+
+    return this.previousMaps
+  }
+
+  setSourcesContent() {
+    let already = {}
+    if (this.root) {
+      this.root.walk(node => {
+        if (node.source) {
+          let from = node.source.input.from
+          if (from && !already[from]) {
+            already[from] = true
+            let fromUrl = this.usesFileUrls
+              ? this.toFileUrl(from)
+              : this.toUrl(this.path(from))
+            this.map.setSourceContent(fromUrl, node.source.input.css)
+          }
+        }
+      })
+    } else if (this.css) {
+      let from = this.opts.from
+        ? this.toUrl(this.path(this.opts.from))
+        : '<no source>'
+      this.map.setSourceContent(from, this.css)
+    }
+  }
+
+  sourcePath(node) {
+    if (this.mapOpts.from) {
+      return this.toUrl(this.mapOpts.from)
+    } else if (this.usesFileUrls) {
+      return this.toFileUrl(node.source.input.from)
+    } else {
+      return this.toUrl(this.path(node.source.input.from))
+    }
+  }
+
+  toBase64(str) {
+    if (Buffer) {
+      return Buffer.from(str).toString('base64')
+    } else {
+      return window.btoa(unescape(encodeURIComponent(str)))
+    }
+  }
+
+  toFileUrl(path) {
+    let cached = this.memoizedFileURLs.get(path)
+    if (cached) return cached
+
+    if (pathToFileURL) {
+      let fileURL = pathToFileURL(path).toString()
+      this.memoizedFileURLs.set(path, fileURL)
+
+      return fileURL
+    } else {
+      throw new Error(
+        '`map.absolute` option is not available in this PostCSS build'
+      )
+    }
+  }
+
+  toUrl(path) {
+    let cached = this.memoizedURLs.get(path)
+    if (cached) return cached
+
+    if (sep === '\\') {
+      path = path.replace(/\\/g, '/')
+    }
+
+    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent)
+    this.memoizedURLs.set(path, url)
+
+    return url
+  }
+}
+
+module.exports = MapGenerator
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/no-work-result.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/no-work-result.d.ts
new file mode 100644
index 0000000..fa9d284
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/no-work-result.d.ts
@@ -0,0 +1,45 @@
+import LazyResult from './lazy-result.js'
+import { SourceMap } from './postcss.js'
+import Processor from './processor.js'
+import Result, { Message, ResultOptions } from './result.js'
+import Root from './root.js'
+import Warning from './warning.js'
+
+declare namespace NoWorkResult {
+  export { NoWorkResult_ as default }
+}
+
+/**
+ * A Promise proxy for the result of PostCSS transformations.
+ * This lazy result instance doesn't parse css unless `NoWorkResult#root` or `Result#root`
+ * are accessed. See the example below for details.
+ * A `NoWork` instance is returned by `Processor#process` ONLY when no plugins defined.
+ *
+ * ```js
+ * const noWorkResult = postcss().process(css) // No plugins are defined.
+ *                                             // CSS is not parsed
+ * let root = noWorkResult.root // now css is parsed because we accessed the root
+ * ```
+ */
+declare class NoWorkResult_ implements LazyResult<Root> {
+  catch: Promise<Result<Root>>['catch']
+  finally: Promise<Result<Root>>['finally']
+  then: Promise<Result<Root>>['then']
+  get content(): string
+  get css(): string
+  get map(): SourceMap
+  get messages(): Message[]
+  get opts(): ResultOptions
+  get processor(): Processor
+  get root(): Root
+  get [Symbol.toStringTag](): string
+  constructor(processor: Processor, css: string, opts: ResultOptions)
+  async(): Promise<Result<Root>>
+  sync(): Result<Root>
+  toString(): string
+  warnings(): Warning[]
+}
+
+declare class NoWorkResult extends NoWorkResult_ {}
+
+export = NoWorkResult
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/no-work-result.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/no-work-result.js
new file mode 100644
index 0000000..7ec1a74
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/no-work-result.js
@@ -0,0 +1,137 @@
+'use strict'
+
+let MapGenerator = require('./map-generator')
+let parse = require('./parse')
+let Result = require('./result')
+let stringify = require('./stringify')
+let warnOnce = require('./warn-once')
+
+class NoWorkResult {
+  get content() {
+    return this.result.css
+  }
+
+  get css() {
+    return this.result.css
+  }
+
+  get map() {
+    return this.result.map
+  }
+
+  get messages() {
+    return []
+  }
+
+  get opts() {
+    return this.result.opts
+  }
+
+  get processor() {
+    return this.result.processor
+  }
+
+  get root() {
+    if (this._root) {
+      return this._root
+    }
+
+    let root
+    let parser = parse
+
+    try {
+      root = parser(this._css, this._opts)
+    } catch (error) {
+      this.error = error
+    }
+
+    if (this.error) {
+      throw this.error
+    } else {
+      this._root = root
+      return root
+    }
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'NoWorkResult'
+  }
+
+  constructor(processor, css, opts) {
+    css = css.toString()
+    this.stringified = false
+
+    this._processor = processor
+    this._css = css
+    this._opts = opts
+    this._map = undefined
+
+    let str = stringify
+    this.result = new Result(this._processor, undefined, this._opts)
+    this.result.css = css
+
+    let self = this
+    Object.defineProperty(this.result, 'root', {
+      get() {
+        return self.root
+      }
+    })
+
+    let map = new MapGenerator(str, undefined, this._opts, css)
+    if (map.isMap()) {
+      let [generatedCSS, generatedMap] = map.generate()
+      if (generatedCSS) {
+        this.result.css = generatedCSS
+      }
+      if (generatedMap) {
+        this.result.map = generatedMap
+      }
+    } else {
+      map.clearAnnotation()
+      this.result.css = map.css
+    }
+  }
+
+  async() {
+    if (this.error) return Promise.reject(this.error)
+    return Promise.resolve(this.result)
+  }
+
+  catch(onRejected) {
+    return this.async().catch(onRejected)
+  }
+
+  finally(onFinally) {
+    return this.async().then(onFinally, onFinally)
+  }
+
+  sync() {
+    if (this.error) throw this.error
+    return this.result
+  }
+
+  then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!('from' in this._opts)) {
+        warnOnce(
+          'Without `from` option PostCSS could generate wrong source map ' +
+            'and will not find Browserslist config. Set it to CSS file path ' +
+            'or to `undefined` to prevent this warning.'
+        )
+      }
+    }
+
+    return this.async().then(onFulfilled, onRejected)
+  }
+
+  toString() {
+    return this._css
+  }
+
+  warnings() {
+    return []
+  }
+}
+
+module.exports = NoWorkResult
+NoWorkResult.default = NoWorkResult
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/node.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/node.d.ts
new file mode 100644
index 0000000..ecd86e2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/node.d.ts
@@ -0,0 +1,555 @@
+import AtRule = require('./at-rule.js')
+import { AtRuleProps } from './at-rule.js'
+import Comment, { CommentProps } from './comment.js'
+import Container, { NewChild } from './container.js'
+import CssSyntaxError from './css-syntax-error.js'
+import Declaration, { DeclarationProps } from './declaration.js'
+import Document from './document.js'
+import Input from './input.js'
+import { Stringifier, Syntax } from './postcss.js'
+import Result from './result.js'
+import Root from './root.js'
+import Rule, { RuleProps } from './rule.js'
+import Warning, { WarningOptions } from './warning.js'
+
+declare namespace Node {
+  export type ChildNode = AtRule.default | Comment | Declaration | Rule
+
+  export type AnyNode =
+    | AtRule.default
+    | Comment
+    | Declaration
+    | Document
+    | Root
+    | Rule
+
+  export type ChildProps =
+    | AtRuleProps
+    | CommentProps
+    | DeclarationProps
+    | RuleProps
+
+  export interface Position {
+    /**
+     * Source line in file. In contrast to `offset` it starts from 1.
+     */
+    column: number
+
+    /**
+     * Source column in file.
+     */
+    line: number
+
+    /**
+     * Source offset in file. It starts from 0.
+     */
+    offset: number
+  }
+
+  export interface Range {
+    /**
+     * End position, exclusive.
+     */
+    end: Position
+
+    /**
+     * Start position, inclusive.
+     */
+    start: Position
+  }
+
+  /**
+   * Source represents an interface for the {@link Node.source} property.
+   */
+  export interface Source {
+    /**
+     * The inclusive ending position for the source
+     * code of a node.
+     *
+     * However, `end.offset` of a non `Root` node is the exclusive position.
+     * See https://github.com/postcss/postcss/pull/1879 for details.
+     *
+     * ```js
+     * const root = postcss.parse('a { color: black }')
+     * const a = root.first
+     * const color = a.first
+     *
+     * // The offset of `Root` node is the inclusive position
+     * css.source.end   // { line: 1, column: 19, offset: 18 }
+     *
+     * // The offset of non `Root` node is the exclusive position
+     * a.source.end     // { line: 1, column: 18, offset: 18 }
+     * color.source.end // { line: 1, column: 16, offset: 16 }
+     * ```
+     */
+    end?: Position
+
+    /**
+     * The source file from where a node has originated.
+     */
+    input: Input
+
+    /**
+     * The inclusive starting position for the source
+     * code of a node.
+     */
+    start?: Position
+  }
+
+  /**
+   * Interface represents an interface for an object received
+   * as parameter by Node class constructor.
+   */
+  export interface NodeProps {
+    source?: Source
+  }
+
+  export interface NodeErrorOptions {
+    /**
+     * An ending index inside a node's string that should be highlighted as
+     * source of error.
+     */
+    endIndex?: number
+    /**
+     * An index inside a node's string that should be highlighted as source
+     * of error.
+     */
+    index?: number
+    /**
+     * Plugin name that created this error. PostCSS will set it automatically.
+     */
+    plugin?: string
+    /**
+     * A word inside a node's string, that should be highlighted as source
+     * of error.
+     */
+    word?: string
+  }
+
+  class Node extends Node_ {}
+  export { Node as default }
+}
+
+/**
+ * It represents an abstract class that handles common
+ * methods for other CSS abstract syntax tree nodes.
+ *
+ * Any node that represents CSS selector or value should
+ * not extend the `Node` class.
+ */
+declare abstract class Node_ {
+  /**
+   * It represents parent of the current node.
+   *
+   * ```js
+   * root.nodes[0].parent === root //=> true
+   * ```
+   */
+  parent: Container | Document | undefined
+
+  /**
+   * It represents unnecessary whitespace and characters present
+   * in the css source code.
+   *
+   * Information to generate byte-to-byte equal node string as it was
+   * in the origin input.
+   *
+   * The properties of the raws object are decided by parser,
+   * the default parser uses the following properties:
+   *
+   * * `before`: the space symbols before the node. It also stores `*`
+   *   and `_` symbols before the declaration (IE hack).
+   * * `after`: the space symbols after the last child of the node
+   *   to the end of the node.
+   * * `between`: the symbols between the property and value
+   *   for declarations, selector and `{` for rules, or last parameter
+   *   and `{` for at-rules.
+   * * `semicolon`: contains true if the last child has
+   *   an (optional) semicolon.
+   * * `afterName`: the space between the at-rule name and its parameters.
+   * * `left`: the space symbols between `/*` and the comment’s text.
+   * * `right`: the space symbols between the comment’s text
+   *   and <code>*&#47;</code>.
+   * - `important`: the content of the important statement,
+   *   if it is not just `!important`.
+   *
+   * PostCSS filters out the comments inside selectors, declaration values
+   * and at-rule parameters but it stores the origin content in raws.
+   *
+   * ```js
+   * const root = postcss.parse('a {\n  color:black\n}')
+   * root.first.first.raws //=> { before: '\n  ', between: ':' }
+   * ```
+   */
+  raws: any
+
+  /**
+   * It represents information related to origin of a node and is required
+   * for generating source maps.
+   *
+   * The nodes that are created manually using the public APIs
+   * provided by PostCSS will have `source` undefined and
+   * will be absent in the source map.
+   *
+   * For this reason, the plugin developer should consider
+   * duplicating nodes as the duplicate node will have the
+   * same source as the original node by default or assign
+   * source to a node created manually.
+   *
+   * ```js
+   * decl.source.input.from //=> '/home/ai/source.css'
+   * decl.source.start      //=> { line: 10, column: 2 }
+   * decl.source.end        //=> { line: 10, column: 12 }
+   * ```
+   *
+   * ```js
+   * // Incorrect method, source not specified!
+   * const prefixed = postcss.decl({
+   *   prop: '-moz-' + decl.prop,
+   *   value: decl.value
+   * })
+   *
+   * // Correct method, source is inherited when duplicating.
+   * const prefixed = decl.clone({
+   *   prop: '-moz-' + decl.prop
+   * })
+   * ```
+   *
+   * ```js
+   * if (atrule.name === 'add-link') {
+   *   const rule = postcss.rule({
+   *     selector: 'a',
+   *     source: atrule.source
+   *   })
+   *
+   *  atrule.parent.insertBefore(atrule, rule)
+   * }
+   * ```
+   */
+  source?: Node.Source
+
+  /**
+   * It represents type of a node in
+   * an abstract syntax tree.
+   *
+   * A type of node helps in identification of a node
+   * and perform operation based on it's type.
+   *
+   * ```js
+   * const declaration = new Declaration({
+   *   prop: 'color',
+   *   value: 'black'
+   * })
+   *
+   * declaration.type //=> 'decl'
+   * ```
+   */
+  type: string
+
+  constructor(defaults?: object)
+
+  /**
+   * Insert new node after current node to current node’s parent.
+   *
+   * Just alias for `node.parent.insertAfter(node, add)`.
+   *
+   * ```js
+   * decl.after('color: black')
+   * ```
+   *
+   * @param newNode New node.
+   * @return This node for methods chain.
+   */
+  after(
+    newNode: Node | Node.ChildProps | readonly Node[] | string | undefined
+  ): this
+
+  /**
+   * It assigns properties to an existing node instance.
+   *
+   * ```js
+   * decl.assign({ prop: 'word-wrap', value: 'break-word' })
+   * ```
+   *
+   * @param overrides New properties to override the node.
+   *
+   * @return `this` for method chaining.
+   */
+  assign(overrides: object): this
+
+  /**
+   * Insert new node before current node to current node’s parent.
+   *
+   * Just alias for `node.parent.insertBefore(node, add)`.
+   *
+   * ```js
+   * decl.before('content: ""')
+   * ```
+   *
+   * @param newNode New node.
+   * @return This node for methods chain.
+   */
+  before(
+    newNode: Node | Node.ChildProps | readonly Node[] | string | undefined
+  ): this
+
+  /**
+   * Clear the code style properties for the node and its children.
+   *
+   * ```js
+   * node.raws.before  //=> ' '
+   * node.cleanRaws()
+   * node.raws.before  //=> undefined
+   * ```
+   *
+   * @param keepBetween Keep the `raws.between` symbols.
+   */
+  cleanRaws(keepBetween?: boolean): void
+
+  /**
+   * It creates clone of an existing node, which includes all the properties
+   * and their values, that includes `raws` but not `type`.
+   *
+   * ```js
+   * decl.raws.before    //=> "\n  "
+   * const cloned = decl.clone({ prop: '-moz-' + decl.prop })
+   * cloned.raws.before  //=> "\n  "
+   * cloned.toString()   //=> -moz-transform: scale(0)
+   * ```
+   *
+   * @param overrides New properties to override in the clone.
+   *
+   * @return Duplicate of the node instance.
+   */
+  clone(overrides?: object): this
+
+  /**
+   * Shortcut to clone the node and insert the resulting cloned node
+   * after the current node.
+   *
+   * @param overrides New properties to override in the clone.
+   * @return New node.
+   */
+  cloneAfter(overrides?: object): this
+
+  /**
+   * Shortcut to clone the node and insert the resulting cloned node
+   * before the current node.
+   *
+   * ```js
+   * decl.cloneBefore({ prop: '-moz-' + decl.prop })
+   * ```
+   *
+   * @param overrides Mew properties to override in the clone.
+   *
+   * @return New node
+   */
+  cloneBefore(overrides?: object): this
+
+  /**
+   * It creates an instance of the class `CssSyntaxError` and parameters passed
+   * to this method are assigned to the error instance.
+   *
+   * The error instance will have description for the
+   * error, original position of the node in the
+   * source, showing line and column number.
+   *
+   * If any previous map is present, it would be used
+   * to get original position of the source.
+   *
+   * The Previous Map here is referred to the source map
+   * generated by previous compilation, example: Less,
+   * Stylus and Sass.
+   *
+   * This method returns the error instance instead of
+   * throwing it.
+   *
+   * ```js
+   * if (!variables[name]) {
+   *   throw decl.error(`Unknown variable ${name}`, { word: name })
+   *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black
+   *   //   color: $black
+   *   // a
+   *   //          ^
+   *   //   background: white
+   * }
+   * ```
+   *
+   * @param message Description for the error instance.
+   * @param options Options for the error instance.
+   *
+   * @return Error instance is returned.
+   */
+  error(message: string, options?: Node.NodeErrorOptions): CssSyntaxError
+
+  /**
+   * Returns the next child of the node’s parent.
+   * Returns `undefined` if the current node is the last child.
+   *
+   * ```js
+   * if (comment.text === 'delete next') {
+   *   const next = comment.next()
+   *   if (next) {
+   *     next.remove()
+   *   }
+   * }
+   * ```
+   *
+   * @return Next node.
+   */
+  next(): Node.ChildNode | undefined
+
+  /**
+   * Get the position for a word or an index inside the node.
+   *
+   * @param opts Options.
+   * @return Position.
+   */
+  positionBy(opts?: Pick<WarningOptions, 'index' | 'word'>): Node.Position
+
+  /**
+   * Convert string index to line/column.
+   *
+   * @param index The symbol number in the node’s string.
+   * @return Symbol position in file.
+   */
+  positionInside(index: number): Node.Position
+
+  /**
+   * Returns the previous child of the node’s parent.
+   * Returns `undefined` if the current node is the first child.
+   *
+   * ```js
+   * const annotation = decl.prev()
+   * if (annotation.type === 'comment') {
+   *   readAnnotation(annotation.text)
+   * }
+   * ```
+   *
+   * @return Previous node.
+   */
+  prev(): Node.ChildNode | undefined
+
+  /**
+   * Get the range for a word or start and end index inside the node.
+   * The start index is inclusive; the end index is exclusive.
+   *
+   * @param opts Options.
+   * @return Range.
+   */
+  rangeBy(
+    opts?: Pick<WarningOptions, 'end' | 'endIndex' | 'index' | 'start' | 'word'>
+  ): Node.Range
+
+  /**
+   * Returns a `raws` value. If the node is missing
+   * the code style property (because the node was manually built or cloned),
+   * PostCSS will try to autodetect the code style property by looking
+   * at other nodes in the tree.
+   *
+   * ```js
+   * const root = postcss.parse('a { background: white }')
+   * root.nodes[0].append({ prop: 'color', value: 'black' })
+   * root.nodes[0].nodes[1].raws.before   //=> undefined
+   * root.nodes[0].nodes[1].raw('before') //=> ' '
+   * ```
+   *
+   * @param prop        Name of code style property.
+   * @param defaultType Name of default value, it can be missed
+   *                    if the value is the same as prop.
+   * @return {string} Code style value.
+   */
+  raw(prop: string, defaultType?: string): string
+
+  /**
+   * It removes the node from its parent and deletes its parent property.
+   *
+   * ```js
+   * if (decl.prop.match(/^-webkit-/)) {
+   *   decl.remove()
+   * }
+   * ```
+   *
+   * @return `this` for method chaining.
+   */
+  remove(): this
+
+  /**
+   * Inserts node(s) before the current node and removes the current node.
+   *
+   * ```js
+   * AtRule: {
+   *   mixin: atrule => {
+   *     atrule.replaceWith(mixinRules[atrule.params])
+   *   }
+   * }
+   * ```
+   *
+   * @param nodes Mode(s) to replace current one.
+   * @return Current node to methods chain.
+   */
+  replaceWith(...nodes: NewChild[]): this
+
+  /**
+   * Finds the Root instance of the node’s tree.
+   *
+   * ```js
+   * root.nodes[0].nodes[0].root() === root
+   * ```
+   *
+   * @return Root parent.
+   */
+  root(): Root
+
+  /**
+   * Fix circular links on `JSON.stringify()`.
+   *
+   * @return Cleaned object.
+   */
+  toJSON(): object
+
+  /**
+   * It compiles the node to browser readable cascading style sheets string
+   * depending on it's type.
+   *
+   * ```js
+   * new Rule({ selector: 'a' }).toString() //=> "a {}"
+   * ```
+   *
+   * @param stringifier A syntax to use in string generation.
+   * @return CSS string of this node.
+   */
+  toString(stringifier?: Stringifier | Syntax): string
+
+  /**
+   * It is a wrapper for {@link Result#warn}, providing convenient
+   * way of generating warnings.
+   *
+   * ```js
+   *   Declaration: {
+   *     bad: (decl, { result }) => {
+   *       decl.warn(result, 'Deprecated property: bad')
+   *     }
+   *   }
+   * ```
+   *
+   * @param result The `Result` instance that will receive the warning.
+   * @param message Description for the warning.
+   * @param options Options for the warning.
+   *
+   * @return `Warning` instance is returned
+   */
+  warn(result: Result, message: string, options?: WarningOptions): Warning
+
+  /**
+   * If this node isn't already dirty, marks it and its ancestors as such. This
+   * indicates to the LazyResult processor that the {@link Root} has been
+   * modified by the current plugin and may need to be processed again by other
+   * plugins.
+   */
+  protected markDirty(): void
+}
+
+declare class Node extends Node_ {}
+
+export = Node
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/node.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/node.js
new file mode 100644
index 0000000..b403b71
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/node.js
@@ -0,0 +1,449 @@
+'use strict'
+
+let CssSyntaxError = require('./css-syntax-error')
+let Stringifier = require('./stringifier')
+let stringify = require('./stringify')
+let { isClean, my } = require('./symbols')
+
+function cloneNode(obj, parent) {
+  let cloned = new obj.constructor()
+
+  for (let i in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, i)) {
+      /* c8 ignore next 2 */
+      continue
+    }
+    if (i === 'proxyCache') continue
+    let value = obj[i]
+    let type = typeof value
+
+    if (i === 'parent' && type === 'object') {
+      if (parent) cloned[i] = parent
+    } else if (i === 'source') {
+      cloned[i] = value
+    } else if (Array.isArray(value)) {
+      cloned[i] = value.map(j => cloneNode(j, cloned))
+    } else {
+      if (type === 'object' && value !== null) value = cloneNode(value)
+      cloned[i] = value
+    }
+  }
+
+  return cloned
+}
+
+function sourceOffset(inputCSS, position) {
+  // Not all custom syntaxes support `offset` in `source.start` and `source.end`
+  if (position && typeof position.offset !== 'undefined') {
+    return position.offset
+  }
+
+  let column = 1
+  let line = 1
+  let offset = 0
+
+  for (let i = 0; i < inputCSS.length; i++) {
+    if (line === position.line && column === position.column) {
+      offset = i
+      break
+    }
+
+    if (inputCSS[i] === '\n') {
+      column = 1
+      line += 1
+    } else {
+      column += 1
+    }
+  }
+
+  return offset
+}
+
+class Node {
+  get proxyOf() {
+    return this
+  }
+
+  constructor(defaults = {}) {
+    this.raws = {}
+    this[isClean] = false
+    this[my] = true
+
+    for (let name in defaults) {
+      if (name === 'nodes') {
+        this.nodes = []
+        for (let node of defaults[name]) {
+          if (typeof node.clone === 'function') {
+            this.append(node.clone())
+          } else {
+            this.append(node)
+          }
+        }
+      } else {
+        this[name] = defaults[name]
+      }
+    }
+  }
+
+  addToError(error) {
+    error.postcssNode = this
+    if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
+      let s = this.source
+      error.stack = error.stack.replace(
+        /\n\s{4}at /,
+        `$&${s.input.from}:${s.start.line}:${s.start.column}$&`
+      )
+    }
+    return error
+  }
+
+  after(add) {
+    this.parent.insertAfter(this, add)
+    return this
+  }
+
+  assign(overrides = {}) {
+    for (let name in overrides) {
+      this[name] = overrides[name]
+    }
+    return this
+  }
+
+  before(add) {
+    this.parent.insertBefore(this, add)
+    return this
+  }
+
+  cleanRaws(keepBetween) {
+    delete this.raws.before
+    delete this.raws.after
+    if (!keepBetween) delete this.raws.between
+  }
+
+  clone(overrides = {}) {
+    let cloned = cloneNode(this)
+    for (let name in overrides) {
+      cloned[name] = overrides[name]
+    }
+    return cloned
+  }
+
+  cloneAfter(overrides = {}) {
+    let cloned = this.clone(overrides)
+    this.parent.insertAfter(this, cloned)
+    return cloned
+  }
+
+  cloneBefore(overrides = {}) {
+    let cloned = this.clone(overrides)
+    this.parent.insertBefore(this, cloned)
+    return cloned
+  }
+
+  error(message, opts = {}) {
+    if (this.source) {
+      let { end, start } = this.rangeBy(opts)
+      return this.source.input.error(
+        message,
+        { column: start.column, line: start.line },
+        { column: end.column, line: end.line },
+        opts
+      )
+    }
+    return new CssSyntaxError(message)
+  }
+
+  getProxyProcessor() {
+    return {
+      get(node, prop) {
+        if (prop === 'proxyOf') {
+          return node
+        } else if (prop === 'root') {
+          return () => node.root().toProxy()
+        } else {
+          return node[prop]
+        }
+      },
+
+      set(node, prop, value) {
+        if (node[prop] === value) return true
+        node[prop] = value
+        if (
+          prop === 'prop' ||
+          prop === 'value' ||
+          prop === 'name' ||
+          prop === 'params' ||
+          prop === 'important' ||
+          /* c8 ignore next */
+          prop === 'text'
+        ) {
+          node.markDirty()
+        }
+        return true
+      }
+    }
+  }
+
+  /* c8 ignore next 3 */
+  markClean() {
+    this[isClean] = true
+  }
+
+  markDirty() {
+    if (this[isClean]) {
+      this[isClean] = false
+      let next = this
+      while ((next = next.parent)) {
+        next[isClean] = false
+      }
+    }
+  }
+
+  next() {
+    if (!this.parent) return undefined
+    let index = this.parent.index(this)
+    return this.parent.nodes[index + 1]
+  }
+
+  positionBy(opts = {}) {
+    let pos = this.source.start
+    if (opts.index) {
+      pos = this.positionInside(opts.index)
+    } else if (opts.word) {
+      let inputString =
+        'document' in this.source.input
+          ? this.source.input.document
+          : this.source.input.css
+      let stringRepresentation = inputString.slice(
+        sourceOffset(inputString, this.source.start),
+        sourceOffset(inputString, this.source.end)
+      )
+      let index = stringRepresentation.indexOf(opts.word)
+      if (index !== -1) pos = this.positionInside(index)
+    }
+    return pos
+  }
+
+  positionInside(index) {
+    let column = this.source.start.column
+    let line = this.source.start.line
+    let inputString =
+      'document' in this.source.input
+        ? this.source.input.document
+        : this.source.input.css
+    let offset = sourceOffset(inputString, this.source.start)
+    let end = offset + index
+
+    for (let i = offset; i < end; i++) {
+      if (inputString[i] === '\n') {
+        column = 1
+        line += 1
+      } else {
+        column += 1
+      }
+    }
+
+    return { column, line, offset: end }
+  }
+
+  prev() {
+    if (!this.parent) return undefined
+    let index = this.parent.index(this)
+    return this.parent.nodes[index - 1]
+  }
+
+  rangeBy(opts = {}) {
+    let inputString =
+      'document' in this.source.input
+        ? this.source.input.document
+        : this.source.input.css
+    let start = {
+      column: this.source.start.column,
+      line: this.source.start.line,
+      offset: sourceOffset(inputString, this.source.start)
+    }
+    let end = this.source.end
+      ? {
+          column: this.source.end.column + 1,
+          line: this.source.end.line,
+          offset:
+            typeof this.source.end.offset === 'number'
+              ? // `source.end.offset` is exclusive, so we don't need to add 1
+                this.source.end.offset
+              : // Since line/column in this.source.end is inclusive,
+                // the `sourceOffset(... , this.source.end)` returns an inclusive offset.
+                // So, we add 1 to convert it to exclusive.
+                sourceOffset(inputString, this.source.end) + 1
+        }
+      : {
+          column: start.column + 1,
+          line: start.line,
+          offset: start.offset + 1
+        }
+
+    if (opts.word) {
+      let stringRepresentation = inputString.slice(
+        sourceOffset(inputString, this.source.start),
+        sourceOffset(inputString, this.source.end)
+      )
+      let index = stringRepresentation.indexOf(opts.word)
+      if (index !== -1) {
+        start = this.positionInside(index)
+        end = this.positionInside(index + opts.word.length)
+      }
+    } else {
+      if (opts.start) {
+        start = {
+          column: opts.start.column,
+          line: opts.start.line,
+          offset: sourceOffset(inputString, opts.start)
+        }
+      } else if (opts.index) {
+        start = this.positionInside(opts.index)
+      }
+
+      if (opts.end) {
+        end = {
+          column: opts.end.column,
+          line: opts.end.line,
+          offset: sourceOffset(inputString, opts.end)
+        }
+      } else if (typeof opts.endIndex === 'number') {
+        end = this.positionInside(opts.endIndex)
+      } else if (opts.index) {
+        end = this.positionInside(opts.index + 1)
+      }
+    }
+
+    if (
+      end.line < start.line ||
+      (end.line === start.line && end.column <= start.column)
+    ) {
+      end = {
+        column: start.column + 1,
+        line: start.line,
+        offset: start.offset + 1
+      }
+    }
+
+    return { end, start }
+  }
+
+  raw(prop, defaultType) {
+    let str = new Stringifier()
+    return str.raw(this, prop, defaultType)
+  }
+
+  remove() {
+    if (this.parent) {
+      this.parent.removeChild(this)
+    }
+    this.parent = undefined
+    return this
+  }
+
+  replaceWith(...nodes) {
+    if (this.parent) {
+      let bookmark = this
+      let foundSelf = false
+      for (let node of nodes) {
+        if (node === this) {
+          foundSelf = true
+        } else if (foundSelf) {
+          this.parent.insertAfter(bookmark, node)
+          bookmark = node
+        } else {
+          this.parent.insertBefore(bookmark, node)
+        }
+      }
+
+      if (!foundSelf) {
+        this.remove()
+      }
+    }
+
+    return this
+  }
+
+  root() {
+    let result = this
+    while (result.parent && result.parent.type !== 'document') {
+      result = result.parent
+    }
+    return result
+  }
+
+  toJSON(_, inputs) {
+    let fixed = {}
+    let emitInputs = inputs == null
+    inputs = inputs || new Map()
+    let inputsNextIndex = 0
+
+    for (let name in this) {
+      if (!Object.prototype.hasOwnProperty.call(this, name)) {
+        /* c8 ignore next 2 */
+        continue
+      }
+      if (name === 'parent' || name === 'proxyCache') continue
+      let value = this[name]
+
+      if (Array.isArray(value)) {
+        fixed[name] = value.map(i => {
+          if (typeof i === 'object' && i.toJSON) {
+            return i.toJSON(null, inputs)
+          } else {
+            return i
+          }
+        })
+      } else if (typeof value === 'object' && value.toJSON) {
+        fixed[name] = value.toJSON(null, inputs)
+      } else if (name === 'source') {
+        if (value == null) continue
+        let inputId = inputs.get(value.input)
+        if (inputId == null) {
+          inputId = inputsNextIndex
+          inputs.set(value.input, inputsNextIndex)
+          inputsNextIndex++
+        }
+        fixed[name] = {
+          end: value.end,
+          inputId,
+          start: value.start
+        }
+      } else {
+        fixed[name] = value
+      }
+    }
+
+    if (emitInputs) {
+      fixed.inputs = [...inputs.keys()].map(input => input.toJSON())
+    }
+
+    return fixed
+  }
+
+  toProxy() {
+    if (!this.proxyCache) {
+      this.proxyCache = new Proxy(this, this.getProxyProcessor())
+    }
+    return this.proxyCache
+  }
+
+  toString(stringifier = stringify) {
+    if (stringifier.stringify) stringifier = stringifier.stringify
+    let result = ''
+    stringifier(this, i => {
+      result += i
+    })
+    return result
+  }
+
+  warn(result, text, opts = {}) {
+    let data = { node: this }
+    for (let i in opts) data[i] = opts[i]
+    return result.warn(text, data)
+  }
+}
+
+module.exports = Node
+Node.default = Node
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/parse.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/parse.d.ts
new file mode 100644
index 0000000..ffe35b4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/parse.d.ts
@@ -0,0 +1,9 @@
+import { Parser } from './postcss.js'
+
+interface Parse extends Parser {
+  default: Parse
+}
+
+declare let parse: Parse
+
+export = parse
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/parse.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/parse.js
new file mode 100644
index 0000000..00a1037
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/parse.js
@@ -0,0 +1,42 @@
+'use strict'
+
+let Container = require('./container')
+let Input = require('./input')
+let Parser = require('./parser')
+
+function parse(css, opts) {
+  let input = new Input(css, opts)
+  let parser = new Parser(input)
+  try {
+    parser.parse()
+  } catch (e) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (e.name === 'CssSyntaxError' && opts && opts.from) {
+        if (/\.scss$/i.test(opts.from)) {
+          e.message +=
+            '\nYou tried to parse SCSS with ' +
+            'the standard CSS parser; ' +
+            'try again with the postcss-scss parser'
+        } else if (/\.sass/i.test(opts.from)) {
+          e.message +=
+            '\nYou tried to parse Sass with ' +
+            'the standard CSS parser; ' +
+            'try again with the postcss-sass parser'
+        } else if (/\.less$/i.test(opts.from)) {
+          e.message +=
+            '\nYou tried to parse Less with ' +
+            'the standard CSS parser; ' +
+            'try again with the postcss-less parser'
+        }
+      }
+    }
+    throw e
+  }
+
+  return parser.root
+}
+
+module.exports = parse
+parse.default = parse
+
+Container.registerParse(parse)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/parser.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/parser.js
new file mode 100644
index 0000000..b29ff5b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/parser.js
@@ -0,0 +1,611 @@
+'use strict'
+
+let AtRule = require('./at-rule')
+let Comment = require('./comment')
+let Declaration = require('./declaration')
+let Root = require('./root')
+let Rule = require('./rule')
+let tokenizer = require('./tokenize')
+
+const SAFE_COMMENT_NEIGHBOR = {
+  empty: true,
+  space: true
+}
+
+function findLastWithPosition(tokens) {
+  for (let i = tokens.length - 1; i >= 0; i--) {
+    let token = tokens[i]
+    let pos = token[3] || token[2]
+    if (pos) return pos
+  }
+}
+
+class Parser {
+  constructor(input) {
+    this.input = input
+
+    this.root = new Root()
+    this.current = this.root
+    this.spaces = ''
+    this.semicolon = false
+
+    this.createTokenizer()
+    this.root.source = { input, start: { column: 1, line: 1, offset: 0 } }
+  }
+
+  atrule(token) {
+    let node = new AtRule()
+    node.name = token[1].slice(1)
+    if (node.name === '') {
+      this.unnamedAtrule(node, token)
+    }
+    this.init(node, token[2])
+
+    let type
+    let prev
+    let shift
+    let last = false
+    let open = false
+    let params = []
+    let brackets = []
+
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken()
+      type = token[0]
+
+      if (type === '(' || type === '[') {
+        brackets.push(type === '(' ? ')' : ']')
+      } else if (type === '{' && brackets.length > 0) {
+        brackets.push('}')
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop()
+      }
+
+      if (brackets.length === 0) {
+        if (type === ';') {
+          node.source.end = this.getPosition(token[2])
+          node.source.end.offset++
+          this.semicolon = true
+          break
+        } else if (type === '{') {
+          open = true
+          break
+        } else if (type === '}') {
+          if (params.length > 0) {
+            shift = params.length - 1
+            prev = params[shift]
+            while (prev && prev[0] === 'space') {
+              prev = params[--shift]
+            }
+            if (prev) {
+              node.source.end = this.getPosition(prev[3] || prev[2])
+              node.source.end.offset++
+            }
+          }
+          this.end(token)
+          break
+        } else {
+          params.push(token)
+        }
+      } else {
+        params.push(token)
+      }
+
+      if (this.tokenizer.endOfFile()) {
+        last = true
+        break
+      }
+    }
+
+    node.raws.between = this.spacesAndCommentsFromEnd(params)
+    if (params.length) {
+      node.raws.afterName = this.spacesAndCommentsFromStart(params)
+      this.raw(node, 'params', params)
+      if (last) {
+        token = params[params.length - 1]
+        node.source.end = this.getPosition(token[3] || token[2])
+        node.source.end.offset++
+        this.spaces = node.raws.between
+        node.raws.between = ''
+      }
+    } else {
+      node.raws.afterName = ''
+      node.params = ''
+    }
+
+    if (open) {
+      node.nodes = []
+      this.current = node
+    }
+  }
+
+  checkMissedSemicolon(tokens) {
+    let colon = this.colon(tokens)
+    if (colon === false) return
+
+    let founded = 0
+    let token
+    for (let j = colon - 1; j >= 0; j--) {
+      token = tokens[j]
+      if (token[0] !== 'space') {
+        founded += 1
+        if (founded === 2) break
+      }
+    }
+    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.
+    // Then we need to return the colon after that word token. [3] is the "end" colon of that word.
+    // And because we need it after that one we do +1 to get the next one.
+    throw this.input.error(
+      'Missed semicolon',
+      token[0] === 'word' ? token[3] + 1 : token[2]
+    )
+  }
+
+  colon(tokens) {
+    let brackets = 0
+    let prev, token, type
+    for (let [i, element] of tokens.entries()) {
+      token = element
+      type = token[0]
+
+      if (type === '(') {
+        brackets += 1
+      }
+      if (type === ')') {
+        brackets -= 1
+      }
+      if (brackets === 0 && type === ':') {
+        if (!prev) {
+          this.doubleColon(token)
+        } else if (prev[0] === 'word' && prev[1] === 'progid') {
+          continue
+        } else {
+          return i
+        }
+      }
+
+      prev = token
+    }
+    return false
+  }
+
+  comment(token) {
+    let node = new Comment()
+    this.init(node, token[2])
+    node.source.end = this.getPosition(token[3] || token[2])
+    node.source.end.offset++
+
+    let text = token[1].slice(2, -2)
+    if (!text.trim()) {
+      node.text = ''
+      node.raws.left = text
+      node.raws.right = ''
+    } else {
+      let match = text.match(/^(\s*)([^]*\S)(\s*)$/)
+      node.text = match[2]
+      node.raws.left = match[1]
+      node.raws.right = match[3]
+    }
+  }
+
+  createTokenizer() {
+    this.tokenizer = tokenizer(this.input)
+  }
+
+  decl(tokens, customProperty) {
+    let node = new Declaration()
+    this.init(node, tokens[0][2])
+
+    let last = tokens[tokens.length - 1]
+    if (last[0] === ';') {
+      this.semicolon = true
+      tokens.pop()
+    }
+
+    node.source.end = this.getPosition(
+      last[3] || last[2] || findLastWithPosition(tokens)
+    )
+    node.source.end.offset++
+
+    while (tokens[0][0] !== 'word') {
+      if (tokens.length === 1) this.unknownWord(tokens)
+      node.raws.before += tokens.shift()[1]
+    }
+    node.source.start = this.getPosition(tokens[0][2])
+
+    node.prop = ''
+    while (tokens.length) {
+      let type = tokens[0][0]
+      if (type === ':' || type === 'space' || type === 'comment') {
+        break
+      }
+      node.prop += tokens.shift()[1]
+    }
+
+    node.raws.between = ''
+
+    let token
+    while (tokens.length) {
+      token = tokens.shift()
+
+      if (token[0] === ':') {
+        node.raws.between += token[1]
+        break
+      } else {
+        if (token[0] === 'word' && /\w/.test(token[1])) {
+          this.unknownWord([token])
+        }
+        node.raws.between += token[1]
+      }
+    }
+
+    if (node.prop[0] === '_' || node.prop[0] === '*') {
+      node.raws.before += node.prop[0]
+      node.prop = node.prop.slice(1)
+    }
+
+    let firstSpaces = []
+    let next
+    while (tokens.length) {
+      next = tokens[0][0]
+      if (next !== 'space' && next !== 'comment') break
+      firstSpaces.push(tokens.shift())
+    }
+
+    this.precheckMissedSemicolon(tokens)
+
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      token = tokens[i]
+      if (token[1].toLowerCase() === '!important') {
+        node.important = true
+        let string = this.stringFrom(tokens, i)
+        string = this.spacesFromEnd(tokens) + string
+        if (string !== ' !important') node.raws.important = string
+        break
+      } else if (token[1].toLowerCase() === 'important') {
+        let cache = tokens.slice(0)
+        let str = ''
+        for (let j = i; j > 0; j--) {
+          let type = cache[j][0]
+          if (str.trim().startsWith('!') && type !== 'space') {
+            break
+          }
+          str = cache.pop()[1] + str
+        }
+        if (str.trim().startsWith('!')) {
+          node.important = true
+          node.raws.important = str
+          tokens = cache
+        }
+      }
+
+      if (token[0] !== 'space' && token[0] !== 'comment') {
+        break
+      }
+    }
+
+    let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment')
+
+    if (hasWord) {
+      node.raws.between += firstSpaces.map(i => i[1]).join('')
+      firstSpaces = []
+    }
+    this.raw(node, 'value', firstSpaces.concat(tokens), customProperty)
+
+    if (node.value.includes(':') && !customProperty) {
+      this.checkMissedSemicolon(tokens)
+    }
+  }
+
+  doubleColon(token) {
+    throw this.input.error(
+      'Double colon',
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
+    )
+  }
+
+  emptyRule(token) {
+    let node = new Rule()
+    this.init(node, token[2])
+    node.selector = ''
+    node.raws.between = ''
+    this.current = node
+  }
+
+  end(token) {
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon
+    }
+    this.semicolon = false
+
+    this.current.raws.after = (this.current.raws.after || '') + this.spaces
+    this.spaces = ''
+
+    if (this.current.parent) {
+      this.current.source.end = this.getPosition(token[2])
+      this.current.source.end.offset++
+      this.current = this.current.parent
+    } else {
+      this.unexpectedClose(token)
+    }
+  }
+
+  endFile() {
+    if (this.current.parent) this.unclosedBlock()
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon
+    }
+    this.current.raws.after = (this.current.raws.after || '') + this.spaces
+    this.root.source.end = this.getPosition(this.tokenizer.position())
+  }
+
+  freeSemicolon(token) {
+    this.spaces += token[1]
+    if (this.current.nodes) {
+      let prev = this.current.nodes[this.current.nodes.length - 1]
+      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
+        prev.raws.ownSemicolon = this.spaces
+        this.spaces = ''
+        prev.source.end = this.getPosition(token[2])
+        prev.source.end.offset += prev.raws.ownSemicolon.length
+      }
+    }
+  }
+
+  // Helpers
+
+  getPosition(offset) {
+    let pos = this.input.fromOffset(offset)
+    return {
+      column: pos.col,
+      line: pos.line,
+      offset
+    }
+  }
+
+  init(node, offset) {
+    this.current.push(node)
+    node.source = {
+      input: this.input,
+      start: this.getPosition(offset)
+    }
+    node.raws.before = this.spaces
+    this.spaces = ''
+    if (node.type !== 'comment') this.semicolon = false
+  }
+
+  other(start) {
+    let end = false
+    let type = null
+    let colon = false
+    let bracket = null
+    let brackets = []
+    let customProperty = start[1].startsWith('--')
+
+    let tokens = []
+    let token = start
+    while (token) {
+      type = token[0]
+      tokens.push(token)
+
+      if (type === '(' || type === '[') {
+        if (!bracket) bracket = token
+        brackets.push(type === '(' ? ')' : ']')
+      } else if (customProperty && colon && type === '{') {
+        if (!bracket) bracket = token
+        brackets.push('}')
+      } else if (brackets.length === 0) {
+        if (type === ';') {
+          if (colon) {
+            this.decl(tokens, customProperty)
+            return
+          } else {
+            break
+          }
+        } else if (type === '{') {
+          this.rule(tokens)
+          return
+        } else if (type === '}') {
+          this.tokenizer.back(tokens.pop())
+          end = true
+          break
+        } else if (type === ':') {
+          colon = true
+        }
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop()
+        if (brackets.length === 0) bracket = null
+      }
+
+      token = this.tokenizer.nextToken()
+    }
+
+    if (this.tokenizer.endOfFile()) end = true
+    if (brackets.length > 0) this.unclosedBracket(bracket)
+
+    if (end && colon) {
+      if (!customProperty) {
+        while (tokens.length) {
+          token = tokens[tokens.length - 1][0]
+          if (token !== 'space' && token !== 'comment') break
+          this.tokenizer.back(tokens.pop())
+        }
+      }
+      this.decl(tokens, customProperty)
+    } else {
+      this.unknownWord(tokens)
+    }
+  }
+
+  parse() {
+    let token
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken()
+
+      switch (token[0]) {
+        case 'space':
+          this.spaces += token[1]
+          break
+
+        case ';':
+          this.freeSemicolon(token)
+          break
+
+        case '}':
+          this.end(token)
+          break
+
+        case 'comment':
+          this.comment(token)
+          break
+
+        case 'at-word':
+          this.atrule(token)
+          break
+
+        case '{':
+          this.emptyRule(token)
+          break
+
+        default:
+          this.other(token)
+          break
+      }
+    }
+    this.endFile()
+  }
+
+  precheckMissedSemicolon(/* tokens */) {
+    // Hook for Safe Parser
+  }
+
+  raw(node, prop, tokens, customProperty) {
+    let token, type
+    let length = tokens.length
+    let value = ''
+    let clean = true
+    let next, prev
+
+    for (let i = 0; i < length; i += 1) {
+      token = tokens[i]
+      type = token[0]
+      if (type === 'space' && i === length - 1 && !customProperty) {
+        clean = false
+      } else if (type === 'comment') {
+        prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty'
+        next = tokens[i + 1] ? tokens[i + 1][0] : 'empty'
+        if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
+          if (value.slice(-1) === ',') {
+            clean = false
+          } else {
+            value += token[1]
+          }
+        } else {
+          clean = false
+        }
+      } else {
+        value += token[1]
+      }
+    }
+    if (!clean) {
+      let raw = tokens.reduce((all, i) => all + i[1], '')
+      node.raws[prop] = { raw, value }
+    }
+    node[prop] = value
+  }
+
+  rule(tokens) {
+    tokens.pop()
+
+    let node = new Rule()
+    this.init(node, tokens[0][2])
+
+    node.raws.between = this.spacesAndCommentsFromEnd(tokens)
+    this.raw(node, 'selector', tokens)
+    this.current = node
+  }
+
+  spacesAndCommentsFromEnd(tokens) {
+    let lastTokenType
+    let spaces = ''
+    while (tokens.length) {
+      lastTokenType = tokens[tokens.length - 1][0]
+      if (lastTokenType !== 'space' && lastTokenType !== 'comment') break
+      spaces = tokens.pop()[1] + spaces
+    }
+    return spaces
+  }
+
+  // Errors
+
+  spacesAndCommentsFromStart(tokens) {
+    let next
+    let spaces = ''
+    while (tokens.length) {
+      next = tokens[0][0]
+      if (next !== 'space' && next !== 'comment') break
+      spaces += tokens.shift()[1]
+    }
+    return spaces
+  }
+
+  spacesFromEnd(tokens) {
+    let lastTokenType
+    let spaces = ''
+    while (tokens.length) {
+      lastTokenType = tokens[tokens.length - 1][0]
+      if (lastTokenType !== 'space') break
+      spaces = tokens.pop()[1] + spaces
+    }
+    return spaces
+  }
+
+  stringFrom(tokens, from) {
+    let result = ''
+    for (let i = from; i < tokens.length; i++) {
+      result += tokens[i][1]
+    }
+    tokens.splice(from, tokens.length - from)
+    return result
+  }
+
+  unclosedBlock() {
+    let pos = this.current.source.start
+    throw this.input.error('Unclosed block', pos.line, pos.column)
+  }
+
+  unclosedBracket(bracket) {
+    throw this.input.error(
+      'Unclosed bracket',
+      { offset: bracket[2] },
+      { offset: bracket[2] + 1 }
+    )
+  }
+
+  unexpectedClose(token) {
+    throw this.input.error(
+      'Unexpected }',
+      { offset: token[2] },
+      { offset: token[2] + 1 }
+    )
+  }
+
+  unknownWord(tokens) {
+    throw this.input.error(
+      'Unknown word ' + tokens[0][1],
+      { offset: tokens[0][2] },
+      { offset: tokens[0][2] + tokens[0][1].length }
+    )
+  }
+
+  unnamedAtrule(node, token) {
+    throw this.input.error(
+      'At-rule without name',
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
+    )
+  }
+}
+
+module.exports = Parser
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.d.mts
new file mode 100644
index 0000000..eaec868
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.d.mts
@@ -0,0 +1,66 @@
+export {
+  // Type-only exports
+  AcceptedPlugin,
+  AnyNode,
+  atRule,
+  AtRule,
+  AtRuleProps,
+  Builder,
+  ChildNode,
+  ChildProps,
+  comment,
+  Comment,
+  CommentProps,
+  Container,
+  ContainerProps,
+  CssSyntaxError,
+  decl,
+  Declaration,
+  DeclarationProps,
+  // postcss function / namespace
+  default,
+  document,
+  Document,
+  DocumentProps,
+  FilePosition,
+  fromJSON,
+  Helpers,
+  Input,
+  JSONHydrator,
+  // This is a class, but it’s not re-exported. That’s why it’s exported as type-only here.
+  type LazyResult,
+  list,
+  Message,
+  Node,
+  NodeErrorOptions,
+  NodeProps,
+  OldPlugin,
+  parse,
+  Parser,
+  // @ts-expect-error This value exists, but it’s untyped.
+  plugin,
+  Plugin,
+  PluginCreator,
+  Position,
+  Postcss,
+  ProcessOptions,
+  Processor,
+  Result,
+  root,
+  Root,
+  RootProps,
+  rule,
+  Rule,
+  RuleProps,
+  Source,
+  SourceMap,
+  SourceMapOptions,
+  Stringifier,
+  // Value exports from postcss.mjs
+  stringify,
+  Syntax,
+  TransformCallback,
+  Transformer,
+  Warning,
+  WarningOptions
+} from './postcss.js'
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.d.ts
new file mode 100644
index 0000000..667d820
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.d.ts
@@ -0,0 +1,461 @@
+import { RawSourceMap, SourceMapGenerator } from 'source-map-js'
+
+import AtRule, { AtRuleProps } from './at-rule.js'
+import Comment, { CommentProps } from './comment.js'
+import Container, { ContainerProps, NewChild } from './container.js'
+import CssSyntaxError from './css-syntax-error.js'
+import Declaration, { DeclarationProps } from './declaration.js'
+import Document, { DocumentProps } from './document.js'
+import Input, { FilePosition } from './input.js'
+import LazyResult from './lazy-result.js'
+import list from './list.js'
+import Node, {
+  AnyNode,
+  ChildNode,
+  ChildProps,
+  NodeErrorOptions,
+  NodeProps,
+  Position,
+  Source
+} from './node.js'
+import Processor from './processor.js'
+import Result, { Message } from './result.js'
+import Root, { RootProps } from './root.js'
+import Rule, { RuleProps } from './rule.js'
+import Warning, { WarningOptions } from './warning.js'
+
+type DocumentProcessor = (
+  document: Document,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type RootProcessor = (
+  root: Root,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type DeclarationProcessor = (
+  decl: Declaration,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type RuleProcessor = (
+  rule: Rule,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type AtRuleProcessor = (
+  atRule: AtRule,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type CommentProcessor = (
+  comment: Comment,
+  helper: postcss.Helpers
+) => Promise<void> | void
+
+interface Processors {
+  /**
+   * Will be called on all`AtRule` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  AtRule?: { [name: string]: AtRuleProcessor } | AtRuleProcessor
+
+  /**
+   * Will be called on all `AtRule` nodes, when all children will be processed.
+   *
+   * Will be called again on node or children changes.
+   */
+  AtRuleExit?: { [name: string]: AtRuleProcessor } | AtRuleProcessor
+
+  /**
+   * Will be called on all `Comment` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  Comment?: CommentProcessor
+
+  /**
+   * Will be called on all `Comment` nodes after listeners
+   * for `Comment` event.
+   *
+   * Will be called again on node or children changes.
+   */
+  CommentExit?: CommentProcessor
+
+  /**
+   * Will be called on all `Declaration` nodes after listeners
+   * for `Declaration` event.
+   *
+   * Will be called again on node or children changes.
+   */
+  Declaration?: { [prop: string]: DeclarationProcessor } | DeclarationProcessor
+
+  /**
+   * Will be called on all `Declaration` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  DeclarationExit?:
+    | { [prop: string]: DeclarationProcessor }
+    | DeclarationProcessor
+
+  /**
+   * Will be called on `Document` node.
+   *
+   * Will be called again on children changes.
+   */
+  Document?: DocumentProcessor
+
+  /**
+   * Will be called on `Document` node, when all children will be processed.
+   *
+   * Will be called again on children changes.
+   */
+  DocumentExit?: DocumentProcessor
+
+  /**
+   * Will be called on `Root` node once.
+   */
+  Once?: RootProcessor
+
+  /**
+   * Will be called on `Root` node once, when all children will be processed.
+   */
+  OnceExit?: RootProcessor
+
+  /**
+   * Will be called on `Root` node.
+   *
+   * Will be called again on children changes.
+   */
+  Root?: RootProcessor
+
+  /**
+   * Will be called on `Root` node, when all children will be processed.
+   *
+   * Will be called again on children changes.
+   */
+  RootExit?: RootProcessor
+
+  /**
+   * Will be called on all `Rule` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  Rule?: RuleProcessor
+
+  /**
+   * Will be called on all `Rule` nodes, when all children will be processed.
+   *
+   * Will be called again on node or children changes.
+   */
+  RuleExit?: RuleProcessor
+}
+
+declare namespace postcss {
+  export {
+    AnyNode,
+    AtRule,
+    AtRuleProps,
+    ChildNode,
+    ChildProps,
+    Comment,
+    CommentProps,
+    Container,
+    ContainerProps,
+    CssSyntaxError,
+    Declaration,
+    DeclarationProps,
+    Document,
+    DocumentProps,
+    FilePosition,
+    Input,
+    LazyResult,
+    list,
+    Message,
+    NewChild,
+    Node,
+    NodeErrorOptions,
+    NodeProps,
+    Position,
+    Processor,
+    Result,
+    Root,
+    RootProps,
+    Rule,
+    RuleProps,
+    Source,
+    Warning,
+    WarningOptions
+  }
+
+  export type SourceMap = {
+    toJSON(): RawSourceMap
+  } & SourceMapGenerator
+
+  export type Helpers = { postcss: Postcss; result: Result } & Postcss
+
+  export interface Plugin extends Processors {
+    postcssPlugin: string
+    prepare?: (result: Result) => Processors
+  }
+
+  export interface PluginCreator<PluginOptions> {
+    (opts?: PluginOptions): Plugin | Processor
+    postcss: true
+  }
+
+  export interface Transformer extends TransformCallback {
+    postcssPlugin: string
+    postcssVersion: string
+  }
+
+  export interface TransformCallback {
+    (root: Root, result: Result): Promise<void> | void
+  }
+
+  export interface OldPlugin<T> extends Transformer {
+    (opts?: T): Transformer
+    postcss: Transformer
+  }
+
+  export type AcceptedPlugin =
+    | {
+        postcss: Processor | TransformCallback
+      }
+    | OldPlugin<any>
+    | Plugin
+    | PluginCreator<any>
+    | Processor
+    | TransformCallback
+
+  export interface Parser<RootNode = Document | Root> {
+    (
+      css: { toString(): string } | string,
+      opts?: Pick<ProcessOptions, 'document' | 'from' | 'map'>
+    ): RootNode
+  }
+
+  export interface Builder {
+    (part: string, node?: AnyNode, type?: 'end' | 'start'): void
+  }
+
+  export interface Stringifier {
+    (node: AnyNode, builder: Builder): void
+  }
+
+  export interface JSONHydrator {
+    (data: object): Node
+    (data: object[]): Node[]
+  }
+
+  export interface Syntax<RootNode = Document | Root> {
+    /**
+     * Function to generate AST by string.
+     */
+    parse?: Parser<RootNode>
+
+    /**
+     * Class to generate string by AST.
+     */
+    stringify?: Stringifier
+  }
+
+  export interface SourceMapOptions {
+    /**
+     * Use absolute path in generated source map.
+     */
+    absolute?: boolean
+
+    /**
+     * Indicates that PostCSS should add annotation comments to the CSS.
+     * By default, PostCSS will always add a comment with a path
+     * to the source map. PostCSS will not add annotations to CSS files
+     * that do not contain any comments.
+     *
+     * By default, PostCSS presumes that you want to save the source map as
+     * `opts.to + '.map'` and will use this path in the annotation comment.
+     * A different path can be set by providing a string value for annotation.
+     *
+     * If you have set `inline: true`, annotation cannot be disabled.
+     */
+    annotation?: ((file: string, root: Root) => string) | boolean | string
+
+    /**
+     * Override `from` in map’s sources.
+     */
+    from?: string
+
+    /**
+     * Indicates that the source map should be embedded in the output CSS
+     * as a Base64-encoded comment. By default, it is `true`.
+     * But if all previous maps are external, not inline, PostCSS will not embed
+     * the map even if you do not set this option.
+     *
+     * If you have an inline source map, the result.map property will be empty,
+     * as the source map will be contained within the text of `result.css`.
+     */
+    inline?: boolean
+
+    /**
+     * Source map content from a previous processing step (e.g., Sass).
+     *
+     * PostCSS will try to read the previous source map
+     * automatically (based on comments within the source CSS), but you can use
+     * this option to identify it manually.
+     *
+     * If desired, you can omit the previous map with prev: `false`.
+     */
+    prev?: ((file: string) => string) | boolean | object | string
+
+    /**
+     * Indicates that PostCSS should set the origin content (e.g., Sass source)
+     * of the source map. By default, it is true. But if all previous maps do not
+     * contain sources content, PostCSS will also leave it out even if you
+     * do not set this option.
+     */
+    sourcesContent?: boolean
+  }
+
+  export interface ProcessOptions<RootNode = Document | Root> {
+    /**
+     * Input file if it is not simple CSS file, but HTML with <style> or JS with CSS-in-JS blocks.
+     */
+    document?: string
+
+    /**
+     * The path of the CSS source file. You should always set `from`,
+     * because it is used in source map generation and syntax error messages.
+     */
+    from?: string | undefined
+
+    /**
+     * Source map options
+     */
+    map?: boolean | SourceMapOptions
+
+    /**
+     * Function to generate AST by string.
+     */
+    parser?: Parser<RootNode> | Syntax<RootNode>
+
+    /**
+     * Class to generate string by AST.
+     */
+    stringifier?: Stringifier | Syntax<RootNode>
+
+    /**
+     * Object with parse and stringify.
+     */
+    syntax?: Syntax<RootNode>
+
+    /**
+     * The path where you'll put the output CSS file. You should always set `to`
+     * to generate correct source maps.
+     */
+    to?: string
+
+    /**
+     * Disable source map file protections.
+     */
+    unsafeMap?: boolean
+  }
+
+  export type Postcss = typeof postcss
+
+  /**
+   * Default function to convert a node tree into a CSS string.
+   */
+  export let stringify: Stringifier
+
+  /**
+   * Parses source css and returns a new `Root` or `Document` node,
+   * which contains the source CSS nodes.
+   *
+   * ```js
+   * // Simple CSS concatenation with source map support
+   * const root1 = postcss.parse(css1, { from: file1 })
+   * const root2 = postcss.parse(css2, { from: file2 })
+   * root1.append(root2).toResult().css
+   * ```
+   */
+  export let parse: Parser<Root>
+
+  /**
+   * Rehydrate a JSON AST (from `Node#toJSON`) back into the AST classes.
+   *
+   * ```js
+   * const json = root.toJSON()
+   * // save to file, send by network, etc
+   * const root2  = postcss.fromJSON(json)
+   * ```
+   */
+  export let fromJSON: JSONHydrator
+
+  /**
+   * Creates a new `Comment` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New comment node
+   */
+  export function comment(defaults?: CommentProps): Comment
+
+  /**
+   * Creates a new `AtRule` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New at-rule node.
+   */
+  export function atRule(defaults?: AtRuleProps): AtRule
+
+  /**
+   * Creates a new `Declaration` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New declaration node.
+   */
+  export function decl(defaults?: DeclarationProps): Declaration
+
+  /**
+   * Creates a new `Rule` node.
+   *
+   * @param default Properties for the new node.
+   * @return New rule node.
+   */
+  export function rule(defaults?: RuleProps): Rule
+
+  /**
+   * Creates a new `Root` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New root node.
+   */
+  export function root(defaults?: RootProps): Root
+
+  /**
+   * Creates a new `Document` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New document node.
+   */
+  export function document(defaults?: DocumentProps): Document
+
+  export { postcss as default }
+}
+
+/**
+ * Create a new `Processor` instance that will apply `plugins`
+ * as CSS processors.
+ *
+ * ```js
+ * let postcss = require('postcss')
+ *
+ * postcss(plugins).process(css, { from, to }).then(result => {
+ *   console.log(result.css)
+ * })
+ * ```
+ *
+ * @param plugins PostCSS plugins.
+ * @return Processor to process multiple CSS.
+ */
+declare function postcss(plugins?: readonly postcss.AcceptedPlugin[]): Processor
+declare function postcss(...plugins: postcss.AcceptedPlugin[]): Processor
+
+export = postcss
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.js
new file mode 100644
index 0000000..8f0773b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.js
@@ -0,0 +1,101 @@
+'use strict'
+
+let AtRule = require('./at-rule')
+let Comment = require('./comment')
+let Container = require('./container')
+let CssSyntaxError = require('./css-syntax-error')
+let Declaration = require('./declaration')
+let Document = require('./document')
+let fromJSON = require('./fromJSON')
+let Input = require('./input')
+let LazyResult = require('./lazy-result')
+let list = require('./list')
+let Node = require('./node')
+let parse = require('./parse')
+let Processor = require('./processor')
+let Result = require('./result.js')
+let Root = require('./root')
+let Rule = require('./rule')
+let stringify = require('./stringify')
+let Warning = require('./warning')
+
+function postcss(...plugins) {
+  if (plugins.length === 1 && Array.isArray(plugins[0])) {
+    plugins = plugins[0]
+  }
+  return new Processor(plugins)
+}
+
+postcss.plugin = function plugin(name, initializer) {
+  let warningPrinted = false
+  function creator(...args) {
+    // eslint-disable-next-line no-console
+    if (console && console.warn && !warningPrinted) {
+      warningPrinted = true
+      // eslint-disable-next-line no-console
+      console.warn(
+        name +
+          ': postcss.plugin was deprecated. Migration guide:\n' +
+          'https://evilmartians.com/chronicles/postcss-8-plugin-migration'
+      )
+      if (process.env.LANG && process.env.LANG.startsWith('cn')) {
+        /* c8 ignore next 7 */
+        // eslint-disable-next-line no-console
+        console.warn(
+          name +
+            ': 里面 postcss.plugin 被弃用. 迁移指南:\n' +
+            'https://www.w3ctech.com/topic/2226'
+        )
+      }
+    }
+    let transformer = initializer(...args)
+    transformer.postcssPlugin = name
+    transformer.postcssVersion = new Processor().version
+    return transformer
+  }
+
+  let cache
+  Object.defineProperty(creator, 'postcss', {
+    get() {
+      if (!cache) cache = creator()
+      return cache
+    }
+  })
+
+  creator.process = function (css, processOpts, pluginOpts) {
+    return postcss([creator(pluginOpts)]).process(css, processOpts)
+  }
+
+  return creator
+}
+
+postcss.stringify = stringify
+postcss.parse = parse
+postcss.fromJSON = fromJSON
+postcss.list = list
+
+postcss.comment = defaults => new Comment(defaults)
+postcss.atRule = defaults => new AtRule(defaults)
+postcss.decl = defaults => new Declaration(defaults)
+postcss.rule = defaults => new Rule(defaults)
+postcss.root = defaults => new Root(defaults)
+postcss.document = defaults => new Document(defaults)
+
+postcss.CssSyntaxError = CssSyntaxError
+postcss.Declaration = Declaration
+postcss.Container = Container
+postcss.Processor = Processor
+postcss.Document = Document
+postcss.Comment = Comment
+postcss.Warning = Warning
+postcss.AtRule = AtRule
+postcss.Result = Result
+postcss.Input = Input
+postcss.Rule = Rule
+postcss.Root = Root
+postcss.Node = Node
+
+LazyResult.registerPostcss(postcss)
+
+module.exports = postcss
+postcss.default = postcss
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.mjs
new file mode 100644
index 0000000..3507598
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/postcss.mjs
@@ -0,0 +1,30 @@
+import postcss from './postcss.js'
+
+export default postcss
+
+export const stringify = postcss.stringify
+export const fromJSON = postcss.fromJSON
+export const plugin = postcss.plugin
+export const parse = postcss.parse
+export const list = postcss.list
+
+export const document = postcss.document
+export const comment = postcss.comment
+export const atRule = postcss.atRule
+export const rule = postcss.rule
+export const decl = postcss.decl
+export const root = postcss.root
+
+export const CssSyntaxError = postcss.CssSyntaxError
+export const Declaration = postcss.Declaration
+export const Container = postcss.Container
+export const Processor = postcss.Processor
+export const Document = postcss.Document
+export const Comment = postcss.Comment
+export const Warning = postcss.Warning
+export const AtRule = postcss.AtRule
+export const Result = postcss.Result
+export const Input = postcss.Input
+export const Rule = postcss.Rule
+export const Root = postcss.Root
+export const Node = postcss.Node
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/previous-map.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/previous-map.d.ts
new file mode 100644
index 0000000..a9adb0b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/previous-map.d.ts
@@ -0,0 +1,80 @@
+import { SourceMapConsumer } from 'source-map-js'
+
+import { ProcessOptions } from './postcss.js'
+
+declare namespace PreviousMap {
+  export { PreviousMap_ as default }
+}
+
+/**
+ * Source map information from input CSS.
+ * For example, source map after Sass compiler.
+ *
+ * This class will automatically find source map in input CSS or in file system
+ * near input file (according `from` option).
+ *
+ * ```js
+ * const root = parse(css, { from: 'a.sass.css' })
+ * root.input.map //=> PreviousMap
+ * ```
+ */
+declare class PreviousMap_ {
+  /**
+   * `sourceMappingURL` content.
+   */
+  annotation?: string
+
+  /**
+   * The CSS source identifier. Contains `Input#file` if the user
+   * set the `from` option, or `Input#id` if they did not.
+   */
+  file?: string
+
+  /**
+   * Was source map inlined by data-uri to input CSS.
+   */
+  inline: boolean
+
+  /**
+   * Path to source map file.
+   */
+  mapFile?: string
+
+  /**
+   * The directory with source map file, if source map is in separated file.
+   */
+  root?: string
+
+  /**
+   * Source map file content.
+   */
+  text?: string
+
+  /**
+   * @param css  Input CSS source.
+   * @param opts Process options.
+   */
+  constructor(css: string, opts?: ProcessOptions)
+
+  /**
+   * Create a instance of `SourceMapGenerator` class
+   * from the `source-map` library to work with source map information.
+   *
+   * It is lazy method, so it will create object only on first call
+   * and then it will use cache.
+   *
+   * @return Object with source map information.
+   */
+  consumer(): SourceMapConsumer
+
+  /**
+   * Does source map contains `sourcesContent` with input source text.
+   *
+   * @return Is `sourcesContent` present.
+   */
+  withContent(): boolean
+}
+
+declare class PreviousMap extends PreviousMap_ {}
+
+export = PreviousMap
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/previous-map.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/previous-map.js
new file mode 100644
index 0000000..3c9d8b9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/previous-map.js
@@ -0,0 +1,161 @@
+'use strict'
+
+let { existsSync, readFileSync } = require('fs')
+let { dirname, join } = require('path')
+let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
+
+function fromBase64(str) {
+  if (Buffer) {
+    return Buffer.from(str, 'base64').toString()
+  } else {
+    /* c8 ignore next 2 */
+    return window.atob(str)
+  }
+}
+
+class PreviousMap {
+  constructor(css, opts) {
+    if (opts.map === false) return
+    if (opts.unsafeMap) this.unsafeMap = true
+    this.loadAnnotation(css)
+    this.inline = this.startWith(this.annotation, 'data:')
+
+    let prev = opts.map ? opts.map.prev : undefined
+    let text = this.loadMap(opts.from, prev)
+    if (!this.mapFile && opts.from) {
+      this.mapFile = opts.from
+    }
+    if (this.mapFile) this.root = dirname(this.mapFile)
+    if (text) this.text = text
+  }
+
+  consumer() {
+    if (!this.consumerCache) {
+      this.consumerCache = new SourceMapConsumer(this.json || this.text)
+    }
+    return this.consumerCache
+  }
+
+  decodeInline(text) {
+    let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/
+    let baseUri = /^data:application\/json;base64,/
+    let charsetUri = /^data:application\/json;charset=utf-?8,/
+    let uri = /^data:application\/json,/
+
+    let uriMatch = text.match(charsetUri) || text.match(uri)
+    if (uriMatch) {
+      return decodeURIComponent(text.substr(uriMatch[0].length))
+    }
+
+    let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri)
+    if (baseUriMatch) {
+      return fromBase64(text.substr(baseUriMatch[0].length))
+    }
+
+    let encoding = text.slice('data:application/json;'.length)
+    encoding = encoding.slice(0, encoding.indexOf(','))
+    throw new Error('Unsupported source map encoding ' + encoding)
+  }
+
+  getAnnotationURL(sourceMapString) {
+    return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
+  }
+
+  isMap(map) {
+    if (typeof map !== 'object') return false
+    return (
+      typeof map.mappings === 'string' ||
+      typeof map._mappings === 'string' ||
+      Array.isArray(map.sections)
+    )
+  }
+
+  loadAnnotation(css) {
+    let comments = css.match(/\/\*\s*# sourceMappingURL=/g)
+    if (!comments) return
+
+    // sourceMappingURLs from comments, strings, etc.
+    let start = css.lastIndexOf(comments.pop())
+    let end = css.indexOf('*/', start)
+
+    if (start > -1 && end > -1) {
+      // Locate the last sourceMappingURL to avoid pickin
+      this.annotation = this.getAnnotationURL(css.substring(start, end))
+    }
+  }
+
+  loadFile(path, cssFile, trusted) {
+    /* c8 ignore next 5 */
+    if (!trusted && !this.unsafeMap) {
+      if (!/\.map$/i.test(path)) {
+        return undefined
+      }
+    }
+    this.root = dirname(path)
+    if (existsSync(path)) {
+      this.mapFile = path
+      return readFileSync(path, 'utf-8').toString().trim()
+    }
+  }
+
+  loadMap(file, prev) {
+    if (prev === false) return false
+
+    if (prev) {
+      if (typeof prev === 'string') {
+        return prev
+      } else if (typeof prev === 'function') {
+        let prevPath = prev(file)
+        if (prevPath) {
+          let map = this.loadFile(prevPath, file, true)
+          if (!map) {
+            throw new Error(
+              'Unable to load previous source map: ' + prevPath.toString()
+            )
+          }
+          return map
+        }
+      } else if (prev instanceof SourceMapConsumer) {
+        return SourceMapGenerator.fromSourceMap(prev).toString()
+      } else if (prev instanceof SourceMapGenerator) {
+        return prev.toString()
+      } else if (this.isMap(prev)) {
+        return JSON.stringify(prev)
+      } else {
+        throw new Error(
+          'Unsupported previous source map format: ' + prev.toString()
+        )
+      }
+    } else if (this.inline) {
+      return this.decodeInline(this.annotation)
+    } else if (this.annotation) {
+      let map = this.annotation
+      if (file) map = join(dirname(file), map)
+      let unknown = this.loadFile(map, file, false)
+      if (unknown) {
+        try {
+          /* c8 ignore next 4 */
+          this.json = JSON.parse(unknown.replace(/^\)]}'[^\n]*\n/, ''))
+        } catch {
+          return undefined
+        }
+      }
+      return unknown
+    }
+  }
+
+  startWith(string, start) {
+    if (!string) return false
+    return string.substr(0, start.length) === start
+  }
+
+  withContent() {
+    return !!(
+      this.consumer().sourcesContent &&
+      this.consumer().sourcesContent.length > 0
+    )
+  }
+}
+
+module.exports = PreviousMap
+PreviousMap.default = PreviousMap
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/processor.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/processor.d.ts
new file mode 100644
index 0000000..8825951
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/processor.d.ts
@@ -0,0 +1,114 @@
+import Document from './document.js'
+import LazyResult from './lazy-result.js'
+import NoWorkResult from './no-work-result.js'
+import {
+  AcceptedPlugin,
+  Plugin,
+  ProcessOptions,
+  TransformCallback,
+  Transformer
+} from './postcss.js'
+import Result from './result.js'
+import Root from './root.js'
+
+declare namespace Processor {
+  export { Processor_ as default }
+}
+
+/**
+ * Contains plugins to process CSS. Create one `Processor` instance,
+ * initialize its plugins, and then use that instance on numerous CSS files.
+ *
+ * ```js
+ * const processor = postcss([autoprefixer, postcssNested])
+ * processor.process(css1).then(result => console.log(result.css))
+ * processor.process(css2).then(result => console.log(result.css))
+ * ```
+ */
+declare class Processor_ {
+  /**
+   * Plugins added to this processor.
+   *
+   * ```js
+   * const processor = postcss([autoprefixer, postcssNested])
+   * processor.plugins.length //=> 2
+   * ```
+   */
+  plugins: (Plugin | TransformCallback | Transformer)[]
+
+  /**
+   * Current PostCSS version.
+   *
+   * ```js
+   * if (result.processor.version.split('.')[0] !== '6') {
+   *   throw new Error('This plugin works only with PostCSS 6')
+   * }
+   * ```
+   */
+  version: string
+
+  /**
+   * @param plugins PostCSS plugins
+   */
+  constructor(plugins?: readonly AcceptedPlugin[])
+
+  /**
+   * Parses source CSS and returns a `LazyResult` Promise proxy.
+   * Because some plugins can be asynchronous it doesn’t make
+   * any transformations. Transformations will be applied
+   * in the `LazyResult` methods.
+   *
+   * ```js
+   * processor.process(css, { from: 'a.css', to: 'a.out.css' })
+   *   .then(result => {
+   *      console.log(result.css)
+   *   })
+   * ```
+   *
+   * @param css String with input CSS or any object with a `toString()` method,
+   *            like a Buffer. Optionally, send a `Result` instance
+   *            and the processor will take the `Root` from it.
+   * @param opts Options.
+   * @return Promise proxy.
+   */
+  process(
+    css: { toString(): string } | LazyResult | Result | Root | string
+  ): LazyResult | NoWorkResult
+  process<RootNode extends Document | Root = Root>(
+    css: { toString(): string } | LazyResult | Result | Root | string,
+    options: ProcessOptions<RootNode>
+  ): LazyResult<RootNode>
+
+  /**
+   * Adds a plugin to be used as a CSS processor.
+   *
+   * PostCSS plugin can be in 4 formats:
+   * * A plugin in `Plugin` format.
+   * * A plugin creator function with `pluginCreator.postcss = true`.
+   *   PostCSS will call this function without argument to get plugin.
+   * * A function. PostCSS will pass the function a {@link Root}
+   *   as the first argument and current `Result` instance
+   *   as the second.
+   * * Another `Processor` instance. PostCSS will copy plugins
+   *   from that instance into this one.
+   *
+   * Plugins can also be added by passing them as arguments when creating
+   * a `postcss` instance (see [`postcss(plugins)`]).
+   *
+   * Asynchronous plugins should return a `Promise` instance.
+   *
+   * ```js
+   * const processor = postcss()
+   *   .use(autoprefixer)
+   *   .use(postcssNested)
+   * ```
+   *
+   * @param plugin PostCSS plugin or `Processor` with plugins.
+   * @return Current processor to make methods chain.
+   */
+  use(plugin: AcceptedPlugin): this
+}
+
+declare class Processor extends Processor_ {}
+
+export = Processor
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/processor.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/processor.js
new file mode 100644
index 0000000..eabcd9f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/processor.js
@@ -0,0 +1,67 @@
+'use strict'
+
+let Document = require('./document')
+let LazyResult = require('./lazy-result')
+let NoWorkResult = require('./no-work-result')
+let Root = require('./root')
+
+class Processor {
+  constructor(plugins = []) {
+    this.version = '8.5.14'
+    this.plugins = this.normalize(plugins)
+  }
+
+  normalize(plugins) {
+    let normalized = []
+    for (let i of plugins) {
+      if (i.postcss === true) {
+        i = i()
+      } else if (i.postcss) {
+        i = i.postcss
+      }
+
+      if (typeof i === 'object' && Array.isArray(i.plugins)) {
+        normalized = normalized.concat(i.plugins)
+      } else if (typeof i === 'object' && i.postcssPlugin) {
+        normalized.push(i)
+      } else if (typeof i === 'function') {
+        normalized.push(i)
+      } else if (typeof i === 'object' && (i.parse || i.stringify)) {
+        if (process.env.NODE_ENV !== 'production') {
+          throw new Error(
+            'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +
+              'one of the syntax/parser/stringifier options as outlined ' +
+              'in your PostCSS runner documentation.'
+          )
+        }
+      } else {
+        throw new Error(i + ' is not a PostCSS plugin')
+      }
+    }
+    return normalized
+  }
+
+  process(css, opts = {}) {
+    if (
+      !this.plugins.length &&
+      !opts.parser &&
+      !opts.stringifier &&
+      !opts.syntax
+    ) {
+      return new NoWorkResult(this, css, opts)
+    } else {
+      return new LazyResult(this, css, opts)
+    }
+  }
+
+  use(plugin) {
+    this.plugins = this.plugins.concat(this.normalize([plugin]))
+    return this
+  }
+}
+
+module.exports = Processor
+Processor.default = Processor
+
+Root.registerProcessor(Processor)
+Document.registerProcessor(Processor)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/result.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/result.d.ts
new file mode 100644
index 0000000..161dce9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/result.d.ts
@@ -0,0 +1,204 @@
+import {
+  Document,
+  Node,
+  Plugin,
+  ProcessOptions,
+  Root,
+  SourceMap,
+  TransformCallback,
+  Warning,
+  WarningOptions
+} from './postcss.js'
+import Processor from './processor.js'
+
+declare namespace Result {
+  export interface Message {
+    [others: string]: any
+
+    /**
+     * Source PostCSS plugin name.
+     */
+    plugin?: string
+
+    /**
+     * Message type.
+     */
+    type: string
+  }
+
+  export interface ResultOptions extends ProcessOptions {
+    /**
+     * The CSS node that was the source of the warning.
+     */
+    node?: Node
+
+    /**
+     * Name of plugin that created this warning. `Result#warn` will fill it
+     * automatically with `Plugin#postcssPlugin` value.
+     */
+    plugin?: string
+  }
+
+  export { Result_ as default }
+}
+
+/**
+ * Provides the result of the PostCSS transformations.
+ *
+ * A Result instance is returned by `LazyResult#then`
+ * or `Root#toResult` methods.
+ *
+ * ```js
+ * postcss([autoprefixer]).process(css).then(result => {
+ *  console.log(result.css)
+ * })
+ * ```
+ *
+ * ```js
+ * const result2 = postcss.parse(css).toResult()
+ * ```
+ */
+declare class Result_<RootNode = Document | Root> {
+  /**
+   * A CSS string representing of `Result#root`.
+   *
+   * ```js
+   * postcss.parse('a{}').toResult().css //=> "a{}"
+   * ```
+   */
+  css: string
+
+  /**
+   * Last runned PostCSS plugin.
+   */
+  lastPlugin: Plugin | TransformCallback
+
+  /**
+   * An instance of `SourceMapGenerator` class from the `source-map` library,
+   * representing changes to the `Result#root` instance.
+   *
+   * ```js
+   * result.map.toJSON() //=> { version: 3, file: 'a.css', … }
+   * ```
+   *
+   * ```js
+   * if (result.map) {
+   *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())
+   * }
+   * ```
+   */
+  map: SourceMap
+
+  /**
+   * Contains messages from plugins (e.g., warnings or custom messages).
+   * Each message should have type and plugin properties.
+   *
+   * ```js
+   * AtRule: {
+   *   import: (atRule, { result }) {
+   *     const importedFile = parseImport(atRule)
+   *     result.messages.push({
+   *       type: 'dependency',
+   *       plugin: 'postcss-import',
+   *       file: importedFile,
+   *       parent: result.opts.from
+   *     })
+   *   }
+   * }
+   * ```
+   */
+  messages: Result.Message[]
+
+  /**
+   * Options from the `Processor#process` or `Root#toResult` call
+   * that produced this Result instance.]
+   *
+   * ```js
+   * root.toResult(opts).opts === opts
+   * ```
+   */
+  opts: Result.ResultOptions
+
+  /**
+   * The Processor instance used for this transformation.
+   *
+   * ```js
+   * for (const plugin of result.processor.plugins) {
+   *   if (plugin.postcssPlugin === 'postcss-bad') {
+   *     throw 'postcss-good is incompatible with postcss-bad'
+   *   }
+   * })
+   * ```
+   */
+  processor: Processor
+
+  /**
+   * Root node after all transformations.
+   *
+   * ```js
+   * root.toResult().root === root
+   * ```
+   */
+  root: RootNode
+
+  /**
+   * An alias for the `Result#css` property.
+   * Use it with syntaxes that generate non-CSS output.
+   *
+   * ```js
+   * result.css === result.content
+   * ```
+   */
+  get content(): string
+
+  /**
+   * @param processor Processor used for this transformation.
+   * @param root      Root node after all transformations.
+   * @param opts      Options from the `Processor#process` or `Root#toResult`.
+   */
+  constructor(processor: Processor, root: RootNode, opts: Result.ResultOptions)
+
+  /**
+   * Returns for `Result#css` content.
+   *
+   * ```js
+   * result + '' === result.css
+   * ```
+   *
+   * @return String representing of `Result#root`.
+   */
+  toString(): string
+
+  /**
+   * Creates an instance of `Warning` and adds it to `Result#messages`.
+   *
+   * ```js
+   * if (decl.important) {
+   *   result.warn('Avoid !important', { node: decl, word: '!important' })
+   * }
+   * ```
+   *
+   * @param text Warning message.
+   * @param opts Warning options.
+   * @return Created warning.
+   */
+  warn(message: string, options?: WarningOptions): Warning
+
+  /**
+   * Returns warnings from plugins. Filters `Warning` instances
+   * from `Result#messages`.
+   *
+   * ```js
+   * result.warnings().forEach(warn => {
+   *   console.warn(warn.toString())
+   * })
+   * ```
+   *
+   * @return Warnings from plugins.
+   */
+  warnings(): Warning[]
+}
+
+declare class Result<RootNode = Document | Root> extends Result_<RootNode> {}
+
+export = Result
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/result.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/result.js
new file mode 100644
index 0000000..c6af4e8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/result.js
@@ -0,0 +1,42 @@
+'use strict'
+
+let Warning = require('./warning')
+
+class Result {
+  get content() {
+    return this.css
+  }
+
+  constructor(processor, root, opts) {
+    this.processor = processor
+    this.messages = []
+    this.root = root
+    this.opts = opts
+    this.css = ''
+    this.map = undefined
+  }
+
+  toString() {
+    return this.css
+  }
+
+  warn(text, opts = {}) {
+    if (!opts.plugin) {
+      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
+        opts.plugin = this.lastPlugin.postcssPlugin
+      }
+    }
+
+    let warning = new Warning(text, opts)
+    this.messages.push(warning)
+
+    return warning
+  }
+
+  warnings() {
+    return this.messages.filter(i => i.type === 'warning')
+  }
+}
+
+module.exports = Result
+Result.default = Result
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/root.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/root.d.ts
new file mode 100644
index 0000000..fd04981
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/root.d.ts
@@ -0,0 +1,86 @@
+import Container, { ContainerProps } from './container.js'
+import Document from './document.js'
+import { ProcessOptions } from './postcss.js'
+import Result from './result.js'
+
+declare namespace Root {
+  export interface RootRaws extends Record<string, any> {
+    /**
+     * The space symbols after the last child to the end of file.
+     */
+    after?: string
+
+    /**
+     * Non-CSS code after `Root`, when `Root` is inside `Document`.
+     *
+     * **Experimental:** some aspects of this node could change within minor
+     * or patch version releases.
+     */
+    codeAfter?: string
+
+    /**
+     * Non-CSS code before `Root`, when `Root` is inside `Document`.
+     *
+     * **Experimental:** some aspects of this node could change within minor
+     * or patch version releases.
+     */
+    codeBefore?: string
+
+    /**
+     * Is the last child has an (optional) semicolon.
+     */
+    semicolon?: boolean
+  }
+
+  export interface RootProps extends ContainerProps {
+    /**
+     * Information used to generate byte-to-byte equal node string
+     * as it was in the origin input.
+     * */
+    raws?: RootRaws
+  }
+
+  export { Root_ as default }
+}
+
+/**
+ * Represents a CSS file and contains all its parsed nodes.
+ *
+ * ```js
+ * const root = postcss.parse('a{color:black} b{z-index:2}')
+ * root.type         //=> 'root'
+ * root.nodes.length //=> 2
+ * ```
+ */
+declare class Root_ extends Container {
+  nodes: NonNullable<Container['nodes']>
+  parent: Document | undefined
+  raws: Root.RootRaws
+  type: 'root'
+
+  constructor(defaults?: Root.RootProps)
+
+  assign(overrides: object | Root.RootProps): this
+  clone(overrides?: Partial<Root.RootProps>): this
+  cloneAfter(overrides?: Partial<Root.RootProps>): this
+  cloneBefore(overrides?: Partial<Root.RootProps>): this
+
+  /**
+   * Returns a `Result` instance representing the root’s CSS.
+   *
+   * ```js
+   * const root1 = postcss.parse(css1, { from: 'a.css' })
+   * const root2 = postcss.parse(css2, { from: 'b.css' })
+   * root1.append(root2)
+   * const result = root1.toResult({ to: 'all.css', map: true })
+   * ```
+   *
+   * @param options Options.
+   * @return Result with current root’s CSS.
+   */
+  toResult(options?: ProcessOptions): Result
+}
+
+declare class Root extends Root_ {}
+
+export = Root
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/root.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/root.js
new file mode 100644
index 0000000..ea574ed
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/root.js
@@ -0,0 +1,61 @@
+'use strict'
+
+let Container = require('./container')
+
+let LazyResult, Processor
+
+class Root extends Container {
+  constructor(defaults) {
+    super(defaults)
+    this.type = 'root'
+    if (!this.nodes) this.nodes = []
+  }
+
+  normalize(child, sample, type) {
+    let nodes = super.normalize(child)
+
+    if (sample) {
+      if (type === 'prepend') {
+        if (this.nodes.length > 1) {
+          sample.raws.before = this.nodes[1].raws.before
+        } else {
+          delete sample.raws.before
+        }
+      } else if (this.first !== sample) {
+        for (let node of nodes) {
+          node.raws.before = sample.raws.before
+        }
+      }
+    }
+
+    return nodes
+  }
+
+  removeChild(child, ignore) {
+    let index = this.index(child)
+
+    if (!ignore && index === 0 && this.nodes.length > 1) {
+      this.nodes[1].raws.before = this.nodes[index].raws.before
+    }
+
+    return super.removeChild(child)
+  }
+
+  toResult(opts = {}) {
+    let lazy = new LazyResult(new Processor(), this, opts)
+    return lazy.stringify()
+  }
+}
+
+Root.registerLazyResult = dependant => {
+  LazyResult = dependant
+}
+
+Root.registerProcessor = dependant => {
+  Processor = dependant
+}
+
+module.exports = Root
+Root.default = Root
+
+Container.registerRoot(Root)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/rule.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/rule.d.ts
new file mode 100644
index 0000000..dc1fb8e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/rule.d.ts
@@ -0,0 +1,126 @@
+import Container, {
+  ContainerProps,
+  ContainerWithChildren
+} from './container.js'
+
+declare namespace Rule {
+  export interface RuleRaws extends Record<string, unknown> {
+    /**
+     * The space symbols after the last child of the node to the end of the node.
+     */
+    after?: string
+
+    /**
+     * The space symbols before the node. It also stores `*`
+     * and `_` symbols before the declaration (IE hack).
+     */
+    before?: string
+
+    /**
+     * The symbols between the selector and `{` for rules.
+     */
+    between?: string
+
+    /**
+     * Contains the text of the semicolon after this rule.
+     */
+    ownSemicolon?: string
+
+    /**
+     * The rule’s selector with comments.
+     */
+    selector?: {
+      raw: string
+      value: string
+    }
+
+    /**
+     * Contains `true` if the last child has an (optional) semicolon.
+     */
+    semicolon?: boolean
+  }
+
+  export type RuleProps = {
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: RuleRaws
+  } & (
+    | {
+        /** Selector or selectors of the rule. */
+        selector: string
+        selectors?: never
+      }
+    | {
+        selector?: never
+        /** Selectors of the rule represented as an array of strings. */
+        selectors: readonly string[]
+      }
+  ) &
+    ContainerProps
+
+  export { Rule_ as default }
+}
+
+/**
+ * Represents a CSS rule: a selector followed by a declaration block.
+ *
+ * ```js
+ * Once (root, { Rule }) {
+ *   let a = new Rule({ selector: 'a' })
+ *   a.append(…)
+ *   root.append(a)
+ * }
+ * ```
+ *
+ * ```js
+ * const root = postcss.parse('a{}')
+ * const rule = root.first
+ * rule.type       //=> 'rule'
+ * rule.toString() //=> 'a{}'
+ * ```
+ */
+declare class Rule_ extends Container {
+  nodes: NonNullable<Container['nodes']>
+  parent: ContainerWithChildren | undefined
+  raws: Rule.RuleRaws
+  type: 'rule'
+  /**
+   * The rule’s full selector represented as a string.
+   *
+   * ```js
+   * const root = postcss.parse('a, b { }')
+   * const rule = root.first
+   * rule.selector //=> 'a, b'
+   * ```
+   */
+  get selector(): string
+
+  set selector(value: string)
+  /**
+   * An array containing the rule’s individual selectors.
+   * Groups of selectors are split at commas.
+   *
+   * ```js
+   * const root = postcss.parse('a, b { }')
+   * const rule = root.first
+   *
+   * rule.selector  //=> 'a, b'
+   * rule.selectors //=> ['a', 'b']
+   *
+   * rule.selectors = ['a', 'strong']
+   * rule.selector //=> 'a, strong'
+   * ```
+   */
+  get selectors(): string[]
+
+  set selectors(values: string[])
+
+  constructor(defaults?: Rule.RuleProps)
+  assign(overrides: object | Rule.RuleProps): this
+  clone(overrides?: Partial<Rule.RuleProps>): this
+  cloneAfter(overrides?: Partial<Rule.RuleProps>): this
+  cloneBefore(overrides?: Partial<Rule.RuleProps>): this
+}
+
+declare class Rule extends Rule_ {}
+
+export = Rule
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/rule.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/rule.js
new file mode 100644
index 0000000..3b9b7e9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/rule.js
@@ -0,0 +1,27 @@
+'use strict'
+
+let Container = require('./container')
+let list = require('./list')
+
+class Rule extends Container {
+  get selectors() {
+    return list.comma(this.selector)
+  }
+
+  set selectors(values) {
+    let match = this.selector ? this.selector.match(/,\s*/) : null
+    let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen')
+    this.selector = values.join(sep)
+  }
+
+  constructor(defaults) {
+    super(defaults)
+    this.type = 'rule'
+    if (!this.nodes) this.nodes = []
+  }
+}
+
+module.exports = Rule
+Rule.default = Rule
+
+Container.registerRule(Rule)
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringifier.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringifier.d.ts
new file mode 100644
index 0000000..cfb106b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringifier.d.ts
@@ -0,0 +1,45 @@
+import {
+  AnyNode,
+  AtRule,
+  Builder,
+  Comment,
+  Container,
+  Declaration,
+  Document,
+  Root,
+  Rule
+} from './postcss.js'
+
+declare namespace Stringifier {
+  export { Stringifier_ as default }
+}
+
+declare class Stringifier_ {
+  builder: Builder
+  constructor(builder: Builder)
+  atrule(node: AtRule, semicolon?: boolean): void
+  beforeAfter(node: AnyNode, detect: 'after' | 'before'): string
+  block(node: AnyNode, start: string): void
+  body(node: Container): void
+  comment(node: Comment): void
+  decl(node: Declaration, semicolon?: boolean): void
+  document(node: Document): void
+  raw(node: AnyNode, own: null | string, detect?: string): boolean | string
+  rawBeforeClose(root: Root): string | undefined
+  rawBeforeComment(root: Root, node: Comment): string | undefined
+  rawBeforeDecl(root: Root, node: Declaration): string | undefined
+  rawBeforeOpen(root: Root): string | undefined
+  rawBeforeRule(root: Root): string | undefined
+  rawColon(root: Root): string | undefined
+  rawEmptyBody(root: Root): string | undefined
+  rawIndent(root: Root): string | undefined
+  rawSemicolon(root: Root): boolean | undefined
+  rawValue(node: AnyNode, prop: string): number | string
+  root(node: Root): void
+  rule(node: Rule): void
+  stringify(node: AnyNode, semicolon?: boolean): void
+}
+
+declare class Stringifier extends Stringifier_ {}
+
+export = Stringifier
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringifier.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringifier.js
new file mode 100644
index 0000000..b1aa835
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringifier.js
@@ -0,0 +1,374 @@
+'use strict'
+
+// Escapes sequences that could break out of an HTML <style> context.
+// Uses CSS unicode escaping (\3c = '<') which is valid CSS and parsed
+// correctly by all compliant CSS consumers.
+const STYLE_TAG = /(<)(\/?style\b)/gi
+const COMMENT_OPEN = /(<)(!--)/g
+
+function escapeHTMLInCSS(str) {
+  if (typeof str !== 'string') return str
+  if (!str.includes('<')) return str
+  return str.replace(STYLE_TAG, '\\3c $2').replace(COMMENT_OPEN, '\\3c $2')
+}
+
+const DEFAULT_RAW = {
+  after: '\n',
+  beforeClose: '\n',
+  beforeComment: '\n',
+  beforeDecl: '\n',
+  beforeOpen: ' ',
+  beforeRule: '\n',
+  colon: ': ',
+  commentLeft: ' ',
+  commentRight: ' ',
+  emptyBody: '',
+  indent: '    ',
+  semicolon: false
+}
+
+function capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1)
+}
+
+class Stringifier {
+  constructor(builder) {
+    this.builder = builder
+  }
+
+  atrule(node, semicolon) {
+    let raws = node.raws
+    let name = '@' + node.name
+    let params = node.params ? this.rawValue(node, 'params') : ''
+
+    if (typeof raws.afterName !== 'undefined') {
+      name += raws.afterName
+    } else if (params) {
+      name += ' '
+    }
+
+    if (node.nodes) {
+      this.block(node, name + params)
+    } else {
+      let end = (raws.between || '') + (semicolon ? ';' : '')
+      this.builder(escapeHTMLInCSS(name + params + end), node)
+    }
+  }
+
+  beforeAfter(node, detect) {
+    let value
+    if (node.type === 'decl') {
+      value = this.raw(node, null, 'beforeDecl')
+    } else if (node.type === 'comment') {
+      value = this.raw(node, null, 'beforeComment')
+    } else if (detect === 'before') {
+      value = this.raw(node, null, 'beforeRule')
+    } else {
+      value = this.raw(node, null, 'beforeClose')
+    }
+
+    let buf = node.parent
+    let depth = 0
+    while (buf && buf.type !== 'root') {
+      depth += 1
+      buf = buf.parent
+    }
+
+    if (value.includes('\n')) {
+      let indent = this.raw(node, null, 'indent')
+      if (indent.length) {
+        for (let step = 0; step < depth; step++) value += indent
+      }
+    }
+
+    return value
+  }
+
+  block(node, start) {
+    let between = this.raw(node, 'between', 'beforeOpen')
+    this.builder(escapeHTMLInCSS(start + between) + '{', node, 'start')
+
+    let after
+    if (node.nodes && node.nodes.length) {
+      this.body(node)
+      after = this.raw(node, 'after')
+    } else {
+      after = this.raw(node, 'after', 'emptyBody')
+    }
+
+    if (after) this.builder(escapeHTMLInCSS(after))
+    this.builder('}', node, 'end')
+  }
+
+  body(node) {
+    let nodes = node.nodes
+    let last = nodes.length - 1
+    while (last > 0) {
+      if (nodes[last].type !== 'comment') break
+      last -= 1
+    }
+
+    let semicolon = this.raw(node, 'semicolon')
+    let isDocument = node.type === 'document'
+    for (let i = 0; i < nodes.length; i++) {
+      let child = nodes[i]
+      let before = this.raw(child, 'before')
+      if (before) this.builder(isDocument ? before : escapeHTMLInCSS(before))
+      this.stringify(child, last !== i || semicolon)
+    }
+  }
+
+  comment(node) {
+    let left = this.raw(node, 'left', 'commentLeft')
+    let right = this.raw(node, 'right', 'commentRight')
+    this.builder(escapeHTMLInCSS('/*' + left + node.text + right + '*/'), node)
+  }
+
+  decl(node, semicolon) {
+    let raws = node.raws
+    let between = this.raw(node, 'between', 'colon')
+
+    let string = node.prop + between + this.rawValue(node, 'value')
+
+    if (node.important) {
+      string += raws.important || ' !important'
+    }
+
+    if (semicolon) string += ';'
+    this.builder(escapeHTMLInCSS(string), node)
+  }
+
+  document(node) {
+    this.body(node)
+  }
+
+  raw(node, own, detect) {
+    let value
+    if (!detect) detect = own
+
+    // Already had
+    if (own) {
+      value = node.raws[own]
+      if (typeof value !== 'undefined') return value
+    }
+
+    let parent = node.parent
+
+    if (detect === 'before') {
+      // Hack for first rule in CSS
+      if (!parent || (parent.type === 'root' && parent.first === node)) {
+        return ''
+      }
+
+      // `root` nodes in `document` should use only their own raws
+      if (parent && parent.type === 'document') {
+        return ''
+      }
+    }
+
+    // Floating child without parent
+    if (!parent) return DEFAULT_RAW[detect]
+
+    // Detect style by other nodes
+    let root = node.root()
+    let cache = root.rawCache || (root.rawCache = {})
+    if (typeof cache[detect] !== 'undefined') {
+      return cache[detect]
+    }
+
+    if (detect === 'before' || detect === 'after') {
+      return this.beforeAfter(node, detect)
+    } else {
+      let method = 'raw' + capitalize(detect)
+      if (this[method]) {
+        value = this[method](root, node)
+      } else {
+        root.walk(i => {
+          value = i.raws[own]
+          if (typeof value !== 'undefined') return false
+        })
+      }
+    }
+
+    if (typeof value === 'undefined') value = DEFAULT_RAW[detect]
+
+    cache[detect] = value
+    return value
+  }
+
+  rawBeforeClose(root) {
+    let value
+    root.walk(i => {
+      if (i.nodes && i.nodes.length > 0) {
+        if (typeof i.raws.after !== 'undefined') {
+          value = i.raws.after
+          if (value.includes('\n')) {
+            value = value.replace(/[^\n]+$/, '')
+          }
+          return false
+        }
+      }
+    })
+    if (value) value = value.replace(/\S/g, '')
+    return value
+  }
+
+  rawBeforeComment(root, node) {
+    let value
+    root.walkComments(i => {
+      if (typeof i.raws.before !== 'undefined') {
+        value = i.raws.before
+        if (value.includes('\n')) {
+          value = value.replace(/[^\n]+$/, '')
+        }
+        return false
+      }
+    })
+    if (typeof value === 'undefined') {
+      value = this.raw(node, null, 'beforeDecl')
+    } else if (value) {
+      value = value.replace(/\S/g, '')
+    }
+    return value
+  }
+
+  rawBeforeDecl(root, node) {
+    let value
+    root.walkDecls(i => {
+      if (typeof i.raws.before !== 'undefined') {
+        value = i.raws.before
+        if (value.includes('\n')) {
+          value = value.replace(/[^\n]+$/, '')
+        }
+        return false
+      }
+    })
+    if (typeof value === 'undefined') {
+      value = this.raw(node, null, 'beforeRule')
+    } else if (value) {
+      value = value.replace(/\S/g, '')
+    }
+    return value
+  }
+
+  rawBeforeOpen(root) {
+    let value
+    root.walk(i => {
+      if (i.type !== 'decl') {
+        value = i.raws.between
+        if (typeof value !== 'undefined') return false
+      }
+    })
+    return value
+  }
+
+  rawBeforeRule(root) {
+    let value
+    root.walk(i => {
+      if (i.nodes && (i.parent !== root || root.first !== i)) {
+        if (typeof i.raws.before !== 'undefined') {
+          value = i.raws.before
+          if (value.includes('\n')) {
+            value = value.replace(/[^\n]+$/, '')
+          }
+          return false
+        }
+      }
+    })
+    if (value) value = value.replace(/\S/g, '')
+    return value
+  }
+
+  rawColon(root) {
+    let value
+    root.walkDecls(i => {
+      if (typeof i.raws.between !== 'undefined') {
+        value = i.raws.between.replace(/[^\s:]/g, '')
+        return false
+      }
+    })
+    return value
+  }
+
+  rawEmptyBody(root) {
+    let value
+    root.walk(i => {
+      if (i.nodes && i.nodes.length === 0) {
+        value = i.raws.after
+        if (typeof value !== 'undefined') return false
+      }
+    })
+    return value
+  }
+
+  rawIndent(root) {
+    if (root.raws.indent) return root.raws.indent
+    let value
+    root.walk(i => {
+      let p = i.parent
+      if (p && p !== root && p.parent && p.parent === root) {
+        if (typeof i.raws.before !== 'undefined') {
+          let parts = i.raws.before.split('\n')
+          value = parts[parts.length - 1]
+          value = value.replace(/\S/g, '')
+          return false
+        }
+      }
+    })
+    return value
+  }
+
+  rawSemicolon(root) {
+    let value
+    root.walk(i => {
+      if (i.nodes && i.nodes.length && i.last.type === 'decl') {
+        value = i.raws.semicolon
+        if (typeof value !== 'undefined') return false
+      }
+    })
+    return value
+  }
+
+  rawValue(node, prop) {
+    let value = node[prop]
+    let raw = node.raws[prop]
+    if (raw && raw.value === value) {
+      return raw.raw
+    }
+
+    return value
+  }
+
+  root(node) {
+    this.body(node)
+    if (node.raws.after) {
+      let after = node.raws.after
+      let isDocument = node.parent && node.parent.type === 'document'
+      this.builder(isDocument ? after : escapeHTMLInCSS(after))
+    }
+  }
+
+  rule(node) {
+    this.block(node, this.rawValue(node, 'selector'))
+    if (node.raws.ownSemicolon) {
+      this.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, 'end')
+    }
+  }
+
+  stringify(node, semicolon) {
+    /* c8 ignore start */
+    if (!this[node.type]) {
+      throw new Error(
+        'Unknown AST node type ' +
+          node.type +
+          '. ' +
+          'Maybe you need to change PostCSS stringifier.'
+      )
+    }
+    /* c8 ignore stop */
+    this[node.type](node, semicolon)
+  }
+}
+
+module.exports = Stringifier
+Stringifier.default = Stringifier
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringify.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringify.d.ts
new file mode 100644
index 0000000..82131bf
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringify.d.ts
@@ -0,0 +1,9 @@
+import { Stringifier } from './postcss.js'
+
+interface Stringify extends Stringifier {
+  default: Stringify
+}
+
+declare let stringify: Stringify
+
+export = stringify
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringify.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringify.js
new file mode 100644
index 0000000..77bd017
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/stringify.js
@@ -0,0 +1,11 @@
+'use strict'
+
+let Stringifier = require('./stringifier')
+
+function stringify(node, builder) {
+  let str = new Stringifier(builder)
+  str.stringify(node)
+}
+
+module.exports = stringify
+stringify.default = stringify
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/symbols.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/symbols.js
new file mode 100644
index 0000000..a142c26
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/symbols.js
@@ -0,0 +1,5 @@
+'use strict'
+
+module.exports.isClean = Symbol('isClean')
+
+module.exports.my = Symbol('my')
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/terminal-highlight.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/terminal-highlight.js
new file mode 100644
index 0000000..6196c9d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/terminal-highlight.js
@@ -0,0 +1,70 @@
+'use strict'
+
+let pico = require('picocolors')
+
+let tokenizer = require('./tokenize')
+
+let Input
+
+function registerInput(dependant) {
+  Input = dependant
+}
+
+const HIGHLIGHT_THEME = {
+  ';': pico.yellow,
+  ':': pico.yellow,
+  '(': pico.cyan,
+  ')': pico.cyan,
+  '[': pico.yellow,
+  ']': pico.yellow,
+  '{': pico.yellow,
+  '}': pico.yellow,
+  'at-word': pico.cyan,
+  'brackets': pico.cyan,
+  'call': pico.cyan,
+  'class': pico.yellow,
+  'comment': pico.gray,
+  'hash': pico.magenta,
+  'string': pico.green
+}
+
+function getTokenType([type, value], processor) {
+  if (type === 'word') {
+    if (value[0] === '.') {
+      return 'class'
+    }
+    if (value[0] === '#') {
+      return 'hash'
+    }
+  }
+
+  if (!processor.endOfFile()) {
+    let next = processor.nextToken()
+    processor.back(next)
+    if (next[0] === 'brackets' || next[0] === '(') return 'call'
+  }
+
+  return type
+}
+
+function terminalHighlight(css) {
+  let processor = tokenizer(new Input(css), { ignoreErrors: true })
+  let result = ''
+  while (!processor.endOfFile()) {
+    let token = processor.nextToken()
+    let color = HIGHLIGHT_THEME[getTokenType(token, processor)]
+    if (color) {
+      result += token[1]
+        .split(/\r?\n/)
+        .map(i => color(i))
+        .join('\n')
+    } else {
+      result += token[1]
+    }
+  }
+  return result
+}
+
+terminalHighlight.registerInput = registerInput
+
+module.exports = terminalHighlight
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/tokenize.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/tokenize.js
new file mode 100644
index 0000000..229095d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/tokenize.js
@@ -0,0 +1,270 @@
+'use strict'
+
+const SINGLE_QUOTE = "'".charCodeAt(0)
+const DOUBLE_QUOTE = '"'.charCodeAt(0)
+const BACKSLASH = '\\'.charCodeAt(0)
+const SLASH = '/'.charCodeAt(0)
+const NEWLINE = '\n'.charCodeAt(0)
+const SPACE = ' '.charCodeAt(0)
+const FEED = '\f'.charCodeAt(0)
+const TAB = '\t'.charCodeAt(0)
+const CR = '\r'.charCodeAt(0)
+const OPEN_SQUARE = '['.charCodeAt(0)
+const CLOSE_SQUARE = ']'.charCodeAt(0)
+const OPEN_PARENTHESES = '('.charCodeAt(0)
+const CLOSE_PARENTHESES = ')'.charCodeAt(0)
+const OPEN_CURLY = '{'.charCodeAt(0)
+const CLOSE_CURLY = '}'.charCodeAt(0)
+const SEMICOLON = ';'.charCodeAt(0)
+const ASTERISK = '*'.charCodeAt(0)
+const COLON = ':'.charCodeAt(0)
+const AT = '@'.charCodeAt(0)
+
+const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g
+const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g
+const RE_BAD_BRACKET = /.[\r\n"'(/\\]/
+const RE_HEX_ESCAPE = /[\da-f]/i
+
+module.exports = function tokenizer(input, options = {}) {
+  let css = input.css.valueOf()
+  let ignore = options.ignoreErrors
+
+  let code, content, escape, next, quote
+  let currentToken, escaped, escapePos, n, prev
+
+  let length = css.length
+  let pos = 0
+  let buffer = []
+  let returned = []
+  let lastBadParen = -1
+
+  function position() {
+    return pos
+  }
+
+  function unclosed(what) {
+    throw input.error('Unclosed ' + what, pos)
+  }
+
+  function endOfFile() {
+    return returned.length === 0 && pos >= length
+  }
+
+  function nextToken(opts) {
+    if (returned.length) return returned.pop()
+    if (pos >= length) return
+
+    let ignoreUnclosed = opts ? opts.ignoreUnclosed : false
+
+    code = css.charCodeAt(pos)
+
+    switch (code) {
+      case NEWLINE:
+      case SPACE:
+      case TAB:
+      case CR:
+      case FEED: {
+        next = pos
+        do {
+          next += 1
+          code = css.charCodeAt(next)
+        } while (
+          code === SPACE ||
+          code === NEWLINE ||
+          code === TAB ||
+          code === CR ||
+          code === FEED
+        )
+
+        currentToken = ['space', css.slice(pos, next)]
+        pos = next - 1
+        break
+      }
+
+      case OPEN_SQUARE:
+      case CLOSE_SQUARE:
+      case OPEN_CURLY:
+      case CLOSE_CURLY:
+      case COLON:
+      case SEMICOLON:
+      case CLOSE_PARENTHESES: {
+        let controlChar = String.fromCharCode(code)
+        currentToken = [controlChar, controlChar, pos]
+        break
+      }
+
+      case OPEN_PARENTHESES: {
+        prev = buffer.length ? buffer.pop()[1] : ''
+        n = css.charCodeAt(pos + 1)
+        if (
+          prev === 'url' &&
+          n !== SINGLE_QUOTE &&
+          n !== DOUBLE_QUOTE &&
+          n !== SPACE &&
+          n !== NEWLINE &&
+          n !== TAB &&
+          n !== FEED &&
+          n !== CR
+        ) {
+          next = pos
+          do {
+            escaped = false
+            next = css.indexOf(')', next + 1)
+            if (next === -1) {
+              if (ignore || ignoreUnclosed) {
+                next = pos
+                break
+              } else {
+                unclosed('bracket')
+              }
+            }
+            escapePos = next
+            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+              escapePos -= 1
+              escaped = !escaped
+            }
+          } while (escaped)
+
+          currentToken = ['brackets', css.slice(pos, next + 1), pos, next]
+
+          pos = next
+        } else if (pos <= lastBadParen) {
+          currentToken = ['(', '(', pos]
+        } else {
+          next = css.indexOf(')', pos + 1)
+          content = css.slice(pos, next + 1)
+
+          if (next === -1 || RE_BAD_BRACKET.test(content)) {
+            lastBadParen = next === -1 ? length : next
+            currentToken = ['(', '(', pos]
+          } else {
+            currentToken = ['brackets', content, pos, next]
+            pos = next
+          }
+        }
+
+        break
+      }
+
+      case SINGLE_QUOTE:
+      case DOUBLE_QUOTE: {
+        quote = code === SINGLE_QUOTE ? "'" : '"'
+        next = pos
+        do {
+          escaped = false
+          next = css.indexOf(quote, next + 1)
+          if (next === -1) {
+            if (ignore || ignoreUnclosed) {
+              next = pos + 1
+              break
+            } else {
+              unclosed('string')
+            }
+          }
+          escapePos = next
+          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+            escapePos -= 1
+            escaped = !escaped
+          }
+        } while (escaped)
+
+        currentToken = ['string', css.slice(pos, next + 1), pos, next]
+        pos = next
+        break
+      }
+
+      case AT: {
+        RE_AT_END.lastIndex = pos + 1
+        RE_AT_END.test(css)
+        if (RE_AT_END.lastIndex === 0) {
+          next = css.length - 1
+        } else {
+          next = RE_AT_END.lastIndex - 2
+        }
+
+        currentToken = ['at-word', css.slice(pos, next + 1), pos, next]
+
+        pos = next
+        break
+      }
+
+      case BACKSLASH: {
+        next = pos
+        escape = true
+        while (css.charCodeAt(next + 1) === BACKSLASH) {
+          next += 1
+          escape = !escape
+        }
+        code = css.charCodeAt(next + 1)
+        if (
+          escape &&
+          code !== SLASH &&
+          code !== SPACE &&
+          code !== NEWLINE &&
+          code !== TAB &&
+          code !== CR &&
+          code !== FEED
+        ) {
+          next += 1
+          if (RE_HEX_ESCAPE.test(css.charAt(next))) {
+            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
+              next += 1
+            }
+            if (css.charCodeAt(next + 1) === SPACE) {
+              next += 1
+            }
+          }
+        }
+
+        currentToken = ['word', css.slice(pos, next + 1), pos, next]
+
+        pos = next
+        break
+      }
+
+      default: {
+        if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
+          next = css.indexOf('*/', pos + 2) + 1
+          if (next === 0) {
+            if (ignore || ignoreUnclosed) {
+              next = css.length
+            } else {
+              unclosed('comment')
+            }
+          }
+
+          currentToken = ['comment', css.slice(pos, next + 1), pos, next]
+          pos = next
+        } else {
+          RE_WORD_END.lastIndex = pos + 1
+          RE_WORD_END.test(css)
+          if (RE_WORD_END.lastIndex === 0) {
+            next = css.length - 1
+          } else {
+            next = RE_WORD_END.lastIndex - 2
+          }
+
+          currentToken = ['word', css.slice(pos, next + 1), pos, next]
+          buffer.push(currentToken)
+          pos = next
+        }
+
+        break
+      }
+    }
+
+    pos++
+    return currentToken
+  }
+
+  function back(token) {
+    returned.push(token)
+  }
+
+  return {
+    back,
+    endOfFile,
+    nextToken,
+    position
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/warn-once.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/warn-once.js
new file mode 100644
index 0000000..316e1cf
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/warn-once.js
@@ -0,0 +1,13 @@
+/* eslint-disable no-console */
+'use strict'
+
+let printed = {}
+
+module.exports = function warnOnce(message) {
+  if (printed[message]) return
+  printed[message] = true
+
+  if (typeof console !== 'undefined' && console.warn) {
+    console.warn(message)
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/warning.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/warning.d.ts
new file mode 100644
index 0000000..64413e4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/warning.d.ts
@@ -0,0 +1,146 @@
+import { RangePosition } from './css-syntax-error.js'
+import Node from './node.js'
+
+declare namespace Warning {
+  export interface WarningOptions {
+    /**
+     * End position, exclusive, in CSS node string that caused the warning.
+     */
+    end?: RangePosition
+
+    /**
+     * End index, exclusive, in CSS node string that caused the warning.
+     */
+    endIndex?: number
+
+    /**
+     * Start index, inclusive, in CSS node string that caused the warning.
+     */
+    index?: number
+
+    /**
+     * CSS node that caused the warning.
+     */
+    node?: Node
+
+    /**
+     * Name of the plugin that created this warning. `Result#warn` fills
+     * this property automatically.
+     */
+    plugin?: string
+
+    /**
+     * Start position, inclusive, in CSS node string that caused the warning.
+     */
+    start?: RangePosition
+
+    /**
+     * Word in CSS source that caused the warning.
+     */
+    word?: string
+  }
+
+  export { Warning_ as default }
+}
+
+/**
+ * Represents a plugin’s warning. It can be created using `Node#warn`.
+ *
+ * ```js
+ * if (decl.important) {
+ *   decl.warn(result, 'Avoid !important', { word: '!important' })
+ * }
+ * ```
+ */
+declare class Warning_ {
+  /**
+   * Column for inclusive start position in the input file with this warning’s source.
+   *
+   * ```js
+   * warning.column //=> 6
+   * ```
+   */
+  column: number
+
+  /**
+   * Column for exclusive end position in the input file with this warning’s source.
+   *
+   * ```js
+   * warning.endColumn //=> 4
+   * ```
+   */
+  endColumn?: number
+
+  /**
+   * Line for exclusive end position in the input file with this warning’s source.
+   *
+   * ```js
+   * warning.endLine //=> 6
+   * ```
+   */
+  endLine?: number
+
+  /**
+   * Line for inclusive start position in the input file with this warning’s source.
+   *
+   * ```js
+   * warning.line //=> 5
+   * ```
+   */
+  line: number
+
+  /**
+   * Contains the CSS node that caused the warning.
+   *
+   * ```js
+   * warning.node.toString() //=> 'color: white !important'
+   * ```
+   */
+  node: Node
+
+  /**
+   * The name of the plugin that created this warning.
+   * When you call `Node#warn` it will fill this property automatically.
+   *
+   * ```js
+   * warning.plugin //=> 'postcss-important'
+   * ```
+   */
+  plugin: string
+
+  /**
+   * The warning message.
+   *
+   * ```js
+   * warning.text //=> 'Try to avoid !important'
+   * ```
+   */
+  text: string
+
+  /**
+   * Type to filter warnings from `Result#messages`.
+   * Always equal to `"warning"`.
+   */
+  type: 'warning'
+
+  /**
+   * @param text Warning message.
+   * @param opts Warning options.
+   */
+  constructor(text: string, opts?: Warning.WarningOptions)
+
+  /**
+   * Returns a warning position and message.
+   *
+   * ```js
+   * warning.toString() //=> 'postcss-lint:a.css:10:14: Avoid !important'
+   * ```
+   *
+   * @return Warning position and message.
+   */
+  toString(): string
+}
+
+declare class Warning extends Warning_ {}
+
+export = Warning
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/warning.js b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/warning.js
new file mode 100644
index 0000000..3a3d79c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/lib/warning.js
@@ -0,0 +1,37 @@
+'use strict'
+
+class Warning {
+  constructor(text, opts = {}) {
+    this.type = 'warning'
+    this.text = text
+
+    if (opts.node && opts.node.source) {
+      let range = opts.node.rangeBy(opts)
+      this.line = range.start.line
+      this.column = range.start.column
+      this.endLine = range.end.line
+      this.endColumn = range.end.column
+    }
+
+    for (let opt in opts) this[opt] = opts[opt]
+  }
+
+  toString() {
+    if (this.node) {
+      return this.node.error(this.text, {
+        index: this.index,
+        plugin: this.plugin,
+        word: this.word
+      }).message
+    }
+
+    if (this.plugin) {
+      return this.plugin + ': ' + this.text
+    }
+
+    return this.text
+  }
+}
+
+module.exports = Warning
+Warning.default = Warning
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/package.json
new file mode 100644
index 0000000..a5ff911
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/postcss/package.json
@@ -0,0 +1,88 @@
+{
+  "name": "postcss",
+  "version": "8.5.14",
+  "description": "Tool for transforming styles with JS plugins",
+  "keywords": [
+    "css",
+    "manipulation",
+    "parser",
+    "postcss",
+    "preprocessor",
+    "rework",
+    "source map",
+    "transform",
+    "transpiler"
+  ],
+  "homepage": "https://postcss.org/",
+  "bugs": {
+    "url": "https://github.com/postcss/postcss/issues"
+  },
+  "license": "MIT",
+  "author": "Andrey Sitnik <andrey@sitnik.es>",
+  "repository": "postcss/postcss",
+  "funding": [
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/postcss/"
+    },
+    {
+      "type": "tidelift",
+      "url": "https://tidelift.com/funding/github/npm/postcss"
+    },
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/ai"
+    }
+  ],
+  "main": "./lib/postcss.js",
+  "browser": {
+    "./lib/terminal-highlight": false,
+    "source-map-js": false,
+    "path": false,
+    "url": false,
+    "fs": false
+  },
+  "types": "./lib/postcss.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/postcss.mjs",
+      "require": "./lib/postcss.js"
+    },
+    "./lib/at-rule": "./lib/at-rule.js",
+    "./lib/comment": "./lib/comment.js",
+    "./lib/container": "./lib/container.js",
+    "./lib/css-syntax-error": "./lib/css-syntax-error.js",
+    "./lib/declaration": "./lib/declaration.js",
+    "./lib/fromJSON": "./lib/fromJSON.js",
+    "./lib/input": "./lib/input.js",
+    "./lib/lazy-result": "./lib/lazy-result.js",
+    "./lib/no-work-result": "./lib/no-work-result.js",
+    "./lib/list": "./lib/list.js",
+    "./lib/map-generator": "./lib/map-generator.js",
+    "./lib/node": "./lib/node.js",
+    "./lib/parse": "./lib/parse.js",
+    "./lib/parser": "./lib/parser.js",
+    "./lib/postcss": "./lib/postcss.js",
+    "./lib/previous-map": "./lib/previous-map.js",
+    "./lib/processor": "./lib/processor.js",
+    "./lib/result": "./lib/result.js",
+    "./lib/root": "./lib/root.js",
+    "./lib/rule": "./lib/rule.js",
+    "./lib/stringifier": "./lib/stringifier.js",
+    "./lib/stringify": "./lib/stringify.js",
+    "./lib/symbols": "./lib/symbols.js",
+    "./lib/terminal-highlight": "./lib/terminal-highlight.js",
+    "./lib/tokenize": "./lib/tokenize.js",
+    "./lib/warn-once": "./lib/warn-once.js",
+    "./lib/warning": "./lib/warning.js",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "nanoid": "^3.3.11",
+    "picocolors": "^1.1.1",
+    "source-map-js": "^1.2.1"
+  },
+  "engines": {
+    "node": "^10 || ^12 || >=14"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/LICENSE
new file mode 100644
index 0000000..afc0cdb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/LICENSE
@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2024-present VoidZero Inc. & 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.
+
+end of terms and conditions
+
+The licenses of externally maintained libraries from which parts of the Software is derived are listed [here](https://github.com/rolldown/rolldown/blob/main/THIRD-PARTY-LICENSE).
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/README.md
new file mode 100644
index 0000000..e1c9c29
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/README.md
@@ -0,0 +1,11 @@
+# Rolldown
+
+> Fast Rust-based bundler for JavaScript with Rollup-compatible API
+
+- ⚡️ Lightning Fast Performance
+- 🔌 Rollup-Compatible APIs
+- ⏩ esbuild Feature Parity
+
+Rolldown is primarily designed to serve as the underlying bundler in [Vite](https://vite.dev/), with the goal to replace esbuild and Rollup with one unified build tool. Although designed for Vite, Rolldown is also fully capable of being used as a standalone, general-purpose bundler. It can serve as a drop-in replacement for Rollup in most cases, and can also be used as an esbuild alternative when better chunking control is needed.
+
+[Read the Docs to Learn More](https://rolldown.rs).
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/bin/cli.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/bin/cli.mjs
new file mode 100644
index 0000000..814234a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/bin/cli.mjs
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli.mjs';
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/cli.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/cli.d.mts
new file mode 100644
index 0000000..619fbdd
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/cli.d.mts
@@ -0,0 +1 @@
+export { };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/cli.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/cli.mjs
new file mode 100644
index 0000000..bea5691
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/cli.mjs
@@ -0,0 +1,1191 @@
+import { n as onExit, t as watch } from "./shared/watch-RBs0UNYA.mjs";
+import { C as version, S as description } from "./shared/bindingify-input-options-BnfFBV6b.mjs";
+import { t as arraify } from "./shared/misc-DJYbNKZX.mjs";
+import { a as getInputCliKeys, i as getCliSchemaInfo, l as styleText, o as getOutputCliKeys, r as logger, s as validateCliOptions } from "./shared/rolldown-build-BVD3dIdE.mjs";
+import { t as rolldown } from "./shared/rolldown-CWsV1rrO.mjs";
+import { t as loadConfig } from "./shared/load-config-CYoi2Wo1.mjs";
+import path from "node:path";
+import process$1 from "node:process";
+import { performance } from "node:perf_hooks";
+//#region ../../node_modules/.pnpm/cac@7.0.0/node_modules/cac/dist/index.js
+function toArr(any) {
+	return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+	var x, old = out[key], nxt = !!~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : !!~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+	out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function lib_default(args, opts) {
+	args = args || [];
+	opts = opts || {};
+	var k, arr, arg, name, val, out = { _: [] };
+	var i = 0, j = 0, idx = 0, len = args.length;
+	const alibi = opts.alias !== void 0;
+	const strict = opts.unknown !== void 0;
+	const defaults = opts.default !== void 0;
+	opts.alias = opts.alias || {};
+	opts.string = toArr(opts.string);
+	opts.boolean = toArr(opts.boolean);
+	if (alibi) for (k in opts.alias) {
+		arr = opts.alias[k] = toArr(opts.alias[k]);
+		for (i = 0; i < arr.length; i++) (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+	}
+	for (i = opts.boolean.length; i-- > 0;) {
+		arr = opts.alias[opts.boolean[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.boolean.push(arr[j]);
+	}
+	for (i = opts.string.length; i-- > 0;) {
+		arr = opts.alias[opts.string[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.string.push(arr[j]);
+	}
+	if (defaults) for (k in opts.default) {
+		name = typeof opts.default[k];
+		arr = opts.alias[k] = opts.alias[k] || [];
+		if (opts[name] !== void 0) {
+			opts[name].push(k);
+			for (i = 0; i < arr.length; i++) opts[name].push(arr[i]);
+		}
+	}
+	const keys = strict ? Object.keys(opts.alias) : [];
+	for (i = 0; i < len; i++) {
+		arg = args[i];
+		if (arg === "--") {
+			out._ = out._.concat(args.slice(++i));
+			break;
+		}
+		for (j = 0; j < arg.length; j++) if (arg.charCodeAt(j) !== 45) break;
+		if (j === 0) out._.push(arg);
+		else if (arg.substring(j, j + 3) === "no-") {
+			name = arg.substring(j + 3);
+			if (strict && !~keys.indexOf(name)) return opts.unknown(arg);
+			out[name] = false;
+		} else {
+			for (idx = j + 1; idx < arg.length; idx++) if (arg.charCodeAt(idx) === 61) break;
+			name = arg.substring(j, idx);
+			val = arg.substring(++idx) || i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
+			arr = j === 2 ? [name] : name;
+			for (idx = 0; idx < arr.length; idx++) {
+				name = arr[idx];
+				if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+				toVal(out, name, idx + 1 < arr.length || val, opts);
+			}
+		}
+	}
+	if (defaults) {
+		for (k in opts.default) if (out[k] === void 0) out[k] = opts.default[k];
+	}
+	if (alibi) for (k in out) {
+		arr = opts.alias[k] || [];
+		while (arr.length > 0) out[arr.shift()] = out[k];
+	}
+	return out;
+}
+function removeBrackets(v) {
+	return v.replace(/[<[].+/, "").trim();
+}
+function findAllBrackets(v) {
+	const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+	const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+	const res = [];
+	const parse = (match) => {
+		let variadic = false;
+		let value = match[1];
+		if (value.startsWith("...")) {
+			value = value.slice(3);
+			variadic = true;
+		}
+		return {
+			required: match[0].startsWith("<"),
+			value,
+			variadic
+		};
+	};
+	let angledMatch;
+	while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) res.push(parse(angledMatch));
+	let squareMatch;
+	while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) res.push(parse(squareMatch));
+	return res;
+}
+function getMriOptions(options) {
+	const result = {
+		alias: {},
+		boolean: []
+	};
+	for (const [index, option] of options.entries()) {
+		if (option.names.length > 1) result.alias[option.names[0]] = option.names.slice(1);
+		if (option.isBoolean) if (option.negated) {
+			if (!options.some((o, i) => {
+				return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+			})) result.boolean.push(option.names[0]);
+		} else result.boolean.push(option.names[0]);
+	}
+	return result;
+}
+function findLongest(arr) {
+	return arr.sort((a, b) => {
+		return a.length > b.length ? -1 : 1;
+	})[0];
+}
+function padRight(str, length) {
+	return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+}
+function camelcase(input) {
+	return input.replaceAll(/([a-z])-([a-z])/g, (_, p1, p2) => {
+		return p1 + p2.toUpperCase();
+	});
+}
+function setDotProp(obj, keys, val) {
+	let current = obj;
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (i === keys.length - 1) {
+			current[key] = val;
+			return;
+		}
+		if (current[key] == null) {
+			const nextKeyIsArrayIndex = +keys[i + 1] > -1;
+			current[key] = nextKeyIsArrayIndex ? [] : {};
+		}
+		current = current[key];
+	}
+}
+function setByType(obj, transforms) {
+	for (const key of Object.keys(transforms)) {
+		const transform = transforms[key];
+		if (transform.shouldTransform) {
+			obj[key] = [obj[key]].flat();
+			if (typeof transform.transformFunction === "function") obj[key] = obj[key].map(transform.transformFunction);
+		}
+	}
+}
+function getFileName(input) {
+	const m = /([^\\/]+)$/.exec(input);
+	return m ? m[1] : "";
+}
+function camelcaseOptionName(name) {
+	return name.split(".").map((v, i) => {
+		return i === 0 ? camelcase(v) : v;
+	}).join(".");
+}
+var CACError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CACError";
+		if (typeof Error.captureStackTrace !== "function") this.stack = new Error(message).stack;
+	}
+};
+var Option = class {
+	rawName;
+	description;
+	/** Option name */
+	name;
+	/** Option name and aliases */
+	names;
+	isBoolean;
+	required;
+	config;
+	negated;
+	constructor(rawName, description, config) {
+		this.rawName = rawName;
+		this.description = description;
+		this.config = Object.assign({}, config);
+		rawName = rawName.replaceAll(".*", "");
+		this.negated = false;
+		this.names = removeBrackets(rawName).split(",").map((v) => {
+			let name = v.trim().replace(/^-{1,2}/, "");
+			if (name.startsWith("no-")) {
+				this.negated = true;
+				name = name.replace(/^no-/, "");
+			}
+			return camelcaseOptionName(name);
+		}).sort((a, b) => a.length > b.length ? 1 : -1);
+		this.name = this.names.at(-1);
+		if (this.negated && this.config.default == null) this.config.default = true;
+		if (rawName.includes("<")) this.required = true;
+		else if (rawName.includes("[")) this.required = false;
+		else this.isBoolean = true;
+	}
+};
+let runtimeProcessArgs;
+let runtimeInfo;
+if (typeof process !== "undefined") {
+	let runtimeName;
+	if (typeof Deno !== "undefined" && typeof Deno.version?.deno === "string") runtimeName = "deno";
+	else if (typeof Bun !== "undefined" && typeof Bun.version === "string") runtimeName = "bun";
+	else runtimeName = "node";
+	runtimeInfo = `${process.platform}-${process.arch} ${runtimeName}-${process.version}`;
+	runtimeProcessArgs = process.argv;
+} else if (typeof navigator === "undefined") runtimeInfo = `unknown`;
+else runtimeInfo = `${navigator.platform} ${navigator.userAgent}`;
+var Command = class {
+	rawName;
+	description;
+	config;
+	cli;
+	options;
+	aliasNames;
+	name;
+	args;
+	commandAction;
+	usageText;
+	versionNumber;
+	examples;
+	helpCallback;
+	globalCommand;
+	constructor(rawName, description, config = {}, cli) {
+		this.rawName = rawName;
+		this.description = description;
+		this.config = config;
+		this.cli = cli;
+		this.options = [];
+		this.aliasNames = [];
+		this.name = removeBrackets(rawName);
+		this.args = findAllBrackets(rawName);
+		this.examples = [];
+	}
+	usage(text) {
+		this.usageText = text;
+		return this;
+	}
+	allowUnknownOptions() {
+		this.config.allowUnknownOptions = true;
+		return this;
+	}
+	ignoreOptionDefaultValue() {
+		this.config.ignoreOptionDefaultValue = true;
+		return this;
+	}
+	version(version, customFlags = "-v, --version") {
+		this.versionNumber = version;
+		this.option(customFlags, "Display version number");
+		return this;
+	}
+	example(example) {
+		this.examples.push(example);
+		return this;
+	}
+	/**
+	* Add a option for this command
+	* @param rawName Raw option name(s)
+	* @param description Option description
+	* @param config Option config
+	*/
+	option(rawName, description, config) {
+		const option = new Option(rawName, description, config);
+		this.options.push(option);
+		return this;
+	}
+	alias(name) {
+		this.aliasNames.push(name);
+		return this;
+	}
+	action(callback) {
+		this.commandAction = callback;
+		return this;
+	}
+	/**
+	* Check if a command name is matched by this command
+	* @param name Command name
+	*/
+	isMatched(name) {
+		return this.name === name || this.aliasNames.includes(name);
+	}
+	get isDefaultCommand() {
+		return this.name === "" || this.aliasNames.includes("!");
+	}
+	get isGlobalCommand() {
+		return this instanceof GlobalCommand;
+	}
+	/**
+	* Check if an option is registered in this command
+	* @param name Option name
+	*/
+	hasOption(name) {
+		name = name.split(".")[0];
+		return this.options.find((option) => {
+			return option.names.includes(name);
+		});
+	}
+	outputHelp() {
+		const { name, commands } = this.cli;
+		const { versionNumber, options: globalOptions, helpCallback } = this.cli.globalCommand;
+		let sections = [{ body: `${name}${versionNumber ? `/${versionNumber}` : ""}` }];
+		sections.push({
+			title: "Usage",
+			body: `  $ ${name} ${this.usageText || this.rawName}`
+		});
+		if ((this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0) {
+			const longestCommandName = findLongest(commands.map((command) => command.rawName));
+			sections.push({
+				title: "Commands",
+				body: commands.map((command) => {
+					return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+				}).join("\n")
+			}, {
+				title: `For more info, run any command with the \`--help\` flag`,
+				body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+			});
+		}
+		let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+		if (!this.isGlobalCommand && !this.isDefaultCommand) options = options.filter((option) => option.name !== "version");
+		if (options.length > 0) {
+			const longestOptionName = findLongest(options.map((option) => option.rawName));
+			sections.push({
+				title: "Options",
+				body: options.map((option) => {
+					return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
+				}).join("\n")
+			});
+		}
+		if (this.examples.length > 0) sections.push({
+			title: "Examples",
+			body: this.examples.map((example) => {
+				if (typeof example === "function") return example(name);
+				return example;
+			}).join("\n")
+		});
+		if (helpCallback) sections = helpCallback(sections) || sections;
+		console.info(sections.map((section) => {
+			return section.title ? `${section.title}:\n${section.body}` : section.body;
+		}).join("\n\n"));
+	}
+	outputVersion() {
+		const { name } = this.cli;
+		const { versionNumber } = this.cli.globalCommand;
+		if (versionNumber) console.info(`${name}/${versionNumber} ${runtimeInfo}`);
+	}
+	checkRequiredArgs() {
+		const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+		if (this.cli.args.length < minimalArgsCount) throw new CACError(`missing required args for command \`${this.rawName}\``);
+	}
+	/**
+	* Check if the parsed options contain any unknown options
+	*
+	* Exit and output error when true
+	*/
+	checkUnknownOptions() {
+		const { options, globalCommand } = this.cli;
+		if (!this.config.allowUnknownOptions) {
+			for (const name of Object.keys(options)) if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+		}
+	}
+	/**
+	* Check if the required string-type options exist
+	*/
+	checkOptionValue() {
+		const { options: parsedOptions, globalCommand } = this.cli;
+		const options = [...globalCommand.options, ...this.options];
+		for (const option of options) {
+			const value = parsedOptions[option.name.split(".")[0]];
+			if (option.required) {
+				const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+				if (value === true || value === false && !hasNegated) throw new CACError(`option \`${option.rawName}\` value is missing`);
+			}
+		}
+	}
+	/**
+	* Check if the number of args is more than expected
+	*/
+	checkUnusedArgs() {
+		const maximumArgsCount = this.args.some((arg) => arg.variadic) ? Infinity : this.args.length;
+		if (maximumArgsCount < this.cli.args.length) throw new CACError(`Unused args: ${this.cli.args.slice(maximumArgsCount).map((arg) => `\`${arg}\``).join(", ")}`);
+	}
+};
+var GlobalCommand = class extends Command {
+	constructor(cli) {
+		super("@@global@@", "", {}, cli);
+	}
+};
+var CAC = class extends EventTarget {
+	/** The program name to display in help and version message */
+	name;
+	commands;
+	globalCommand;
+	matchedCommand;
+	matchedCommandName;
+	/**
+	* Raw CLI arguments
+	*/
+	rawArgs;
+	/**
+	* Parsed CLI arguments
+	*/
+	args;
+	/**
+	* Parsed CLI options, camelCased
+	*/
+	options;
+	showHelpOnExit;
+	showVersionOnExit;
+	/**
+	* @param name The program name to display in help and version message
+	*/
+	constructor(name = "") {
+		super();
+		this.name = name;
+		this.commands = [];
+		this.rawArgs = [];
+		this.args = [];
+		this.options = {};
+		this.globalCommand = new GlobalCommand(this);
+		this.globalCommand.usage("<command> [options]");
+	}
+	/**
+	* Add a global usage text.
+	*
+	* This is not used by sub-commands.
+	*/
+	usage(text) {
+		this.globalCommand.usage(text);
+		return this;
+	}
+	/**
+	* Add a sub-command
+	*/
+	command(rawName, description, config) {
+		const command = new Command(rawName, description || "", config, this);
+		command.globalCommand = this.globalCommand;
+		this.commands.push(command);
+		return command;
+	}
+	/**
+	* Add a global CLI option.
+	*
+	* Which is also applied to sub-commands.
+	*/
+	option(rawName, description, config) {
+		this.globalCommand.option(rawName, description, config);
+		return this;
+	}
+	/**
+	* Show help message when `-h, --help` flags appear.
+	*
+	*/
+	help(callback) {
+		this.globalCommand.option("-h, --help", "Display this message");
+		this.globalCommand.helpCallback = callback;
+		this.showHelpOnExit = true;
+		return this;
+	}
+	/**
+	* Show version number when `-v, --version` flags appear.
+	*
+	*/
+	version(version, customFlags = "-v, --version") {
+		this.globalCommand.version(version, customFlags);
+		this.showVersionOnExit = true;
+		return this;
+	}
+	/**
+	* Add a global example.
+	*
+	* This example added here will not be used by sub-commands.
+	*/
+	example(example) {
+		this.globalCommand.example(example);
+		return this;
+	}
+	/**
+	* Output the corresponding help message
+	* When a sub-command is matched, output the help message for the command
+	* Otherwise output the global one.
+	*
+	*/
+	outputHelp() {
+		if (this.matchedCommand) this.matchedCommand.outputHelp();
+		else this.globalCommand.outputHelp();
+	}
+	/**
+	* Output the version number.
+	*
+	*/
+	outputVersion() {
+		this.globalCommand.outputVersion();
+	}
+	setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+		this.args = args;
+		this.options = options;
+		if (matchedCommand) this.matchedCommand = matchedCommand;
+		if (matchedCommandName) this.matchedCommandName = matchedCommandName;
+		return this;
+	}
+	unsetMatchedCommand() {
+		this.matchedCommand = void 0;
+		this.matchedCommandName = void 0;
+	}
+	/**
+	* Parse argv
+	*/
+	parse(argv, { run = true } = {}) {
+		if (!argv) {
+			if (!runtimeProcessArgs) throw new Error("No argv provided and runtime process argv is not available.");
+			argv = runtimeProcessArgs;
+		}
+		this.rawArgs = argv;
+		if (!this.name) this.name = argv[1] ? getFileName(argv[1]) : "cli";
+		let shouldParse = true;
+		for (const command of this.commands) {
+			const parsed = this.mri(argv.slice(2), command);
+			const commandName = parsed.args[0];
+			if (command.isMatched(commandName)) {
+				shouldParse = false;
+				const parsedInfo = {
+					...parsed,
+					args: parsed.args.slice(1)
+				};
+				this.setParsedInfo(parsedInfo, command, commandName);
+				this.dispatchEvent(new CustomEvent(`command:${commandName}`, { detail: command }));
+			}
+		}
+		if (shouldParse) {
+			for (const command of this.commands) if (command.isDefaultCommand) {
+				shouldParse = false;
+				const parsed = this.mri(argv.slice(2), command);
+				this.setParsedInfo(parsed, command);
+				this.dispatchEvent(new CustomEvent("command:!", { detail: command }));
+			}
+		}
+		if (shouldParse) {
+			const parsed = this.mri(argv.slice(2));
+			this.setParsedInfo(parsed);
+		}
+		if (this.options.help && this.showHelpOnExit) {
+			this.outputHelp();
+			run = false;
+			this.unsetMatchedCommand();
+		}
+		if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+			this.outputVersion();
+			run = false;
+			this.unsetMatchedCommand();
+		}
+		const parsedArgv = {
+			args: this.args,
+			options: this.options
+		};
+		if (run) this.runMatchedCommand();
+		if (!this.matchedCommand && this.args[0]) this.dispatchEvent(new CustomEvent("command:*", { detail: this.args[0] }));
+		return parsedArgv;
+	}
+	mri(argv, command) {
+		const cliOptions = [...this.globalCommand.options, ...command ? command.options : []];
+		const mriOptions = getMriOptions(cliOptions);
+		let argsAfterDoubleDashes = [];
+		const doubleDashesIndex = argv.indexOf("--");
+		if (doubleDashesIndex !== -1) {
+			argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+			argv = argv.slice(0, doubleDashesIndex);
+		}
+		let parsed = lib_default(argv, mriOptions);
+		parsed = Object.keys(parsed).reduce((res, name) => {
+			return {
+				...res,
+				[camelcaseOptionName(name)]: parsed[name]
+			};
+		}, { _: [] });
+		const args = parsed._;
+		const options = { "--": argsAfterDoubleDashes };
+		const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+		const transforms = Object.create(null);
+		for (const cliOption of cliOptions) {
+			if (!ignoreDefault && cliOption.config.default !== void 0) for (const name of cliOption.names) options[name] = cliOption.config.default;
+			if (Array.isArray(cliOption.config.type) && transforms[cliOption.name] === void 0) {
+				transforms[cliOption.name] = Object.create(null);
+				transforms[cliOption.name].shouldTransform = true;
+				transforms[cliOption.name].transformFunction = cliOption.config.type[0];
+			}
+		}
+		for (const key of Object.keys(parsed)) if (key !== "_") {
+			setDotProp(options, key.split("."), parsed[key]);
+			setByType(options, transforms);
+		}
+		return {
+			args,
+			options
+		};
+	}
+	runMatchedCommand() {
+		const { args, options, matchedCommand: command } = this;
+		if (!command || !command.commandAction) return;
+		command.checkUnknownOptions();
+		command.checkOptionValue();
+		command.checkRequiredArgs();
+		command.checkUnusedArgs();
+		const actionArgs = [];
+		command.args.forEach((arg, index) => {
+			if (arg.variadic) actionArgs.push(args.slice(index));
+			else actionArgs.push(args[index]);
+		});
+		actionArgs.push(options);
+		return command.commandAction.apply(this, actionArgs);
+	}
+};
+/**
+* @param name The program name to display in help and version message
+*/
+const cac = (name = "") => new CAC(name);
+//#endregion
+//#region src/cli/arguments/alias.ts
+const alias = {
+	config: {
+		abbreviation: "c",
+		hint: "filename"
+	},
+	help: { abbreviation: "h" },
+	version: { abbreviation: "v" },
+	watch: { abbreviation: "w" },
+	dir: {
+		abbreviation: "d",
+		requireValue: true
+	},
+	file: {
+		abbreviation: "o",
+		requireValue: true
+	},
+	external: { abbreviation: "e" },
+	format: { abbreviation: "f" },
+	name: { abbreviation: "n" },
+	globals: { abbreviation: "g" },
+	sourcemap: { abbreviation: "s" },
+	minify: { abbreviation: "m" },
+	platform: { abbreviation: "p" },
+	assetFileNames: { hint: "name" },
+	chunkFileNames: { hint: "name" },
+	entryFileNames: { hint: "name" },
+	externalLiveBindings: { reverse: true },
+	treeshake: { reverse: true },
+	preserveEntrySignatures: { reverse: true },
+	moduleTypes: { hint: "types" }
+};
+//#endregion
+//#region src/cli/arguments/utils.ts
+function setNestedProperty(obj, path, value) {
+	const keys = path.split(".");
+	let current = obj;
+	for (let i = 0; i < keys.length - 1; i++) {
+		if (!current[keys[i]]) current[keys[i]] = {};
+		current = current[keys[i]];
+	}
+	const finalKey = keys[keys.length - 1];
+	Object.defineProperty(current, finalKey, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+function camelCaseToKebabCase(str) {
+	return str.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+//#endregion
+//#region src/cli/arguments/normalize.ts
+const reservedKeys = new Set([
+	"help",
+	"version",
+	"config",
+	"watch",
+	"environment"
+]);
+function normalizeCliOptions(cliOptions, positionals) {
+	const [data, errors] = validateCliOptions(cliOptions);
+	if (errors?.length) {
+		errors.forEach((error) => {
+			logger.error(`${error}. You can use \`rolldown -h\` to see the help.`);
+		});
+		process.exit(1);
+	}
+	const options = data ?? {};
+	const result = {
+		input: {},
+		output: {},
+		help: options.help ?? false,
+		version: options.version ?? false,
+		watch: options.watch ?? false
+	};
+	if (typeof options.config === "string") result.config = options.config;
+	else if (options.config === true) result.config = "";
+	if (options.environment !== void 0) result.environment = options.environment;
+	const keysOfInput = new Set(getInputCliKeys());
+	const keysOfOutput = new Set(getOutputCliKeys());
+	for (let [key, value] of Object.entries(options)) {
+		const [primary] = key.split(".");
+		if (keysOfInput.has(primary)) setNestedProperty(result.input, key, value);
+		else if (keysOfOutput.has(primary)) setNestedProperty(result.output, key, value);
+		else if (!reservedKeys.has(key)) {
+			logger.error(`Unknown option: ${key}`);
+			process.exit(1);
+		}
+	}
+	if (!result.config && positionals.length > 0) if (Array.isArray(result.input.input)) result.input.input.push(...positionals);
+	else result.input.input = positionals;
+	return result;
+}
+//#endregion
+//#region src/cli/arguments/index.ts
+const schemaInfo = getCliSchemaInfo();
+const options = Object.fromEntries(Object.entries(schemaInfo).filter(([_key, info]) => info.type !== "never").map(([key, info]) => {
+	const config = alias[key];
+	let description = info?.description ?? config?.description ?? "";
+	if (config?.reverse) {
+		if (description.startsWith("enable")) description = description.replace("enable", "disable");
+		else if (!description.startsWith("Avoid")) description = `disable ${description}`;
+	}
+	const result = {
+		type: info.type === "boolean" ? "boolean" : "string",
+		description
+	};
+	if (config?.abbreviation) result.short = config.abbreviation;
+	if (config?.hint) result.hint = config.hint;
+	const kebabKey = camelCaseToKebabCase(key);
+	return [config?.reverse ? `no-${kebabKey}` : kebabKey, result];
+}));
+const knownKeys = new Set(Object.keys(schemaInfo));
+for (const key of Object.keys(schemaInfo)) {
+	const dotIdx = key.indexOf(".");
+	if (dotIdx > 0) knownKeys.add(key.substring(0, dotIdx));
+}
+const shortAliases = /* @__PURE__ */ new Set();
+for (const config of Object.values(alias)) if (config?.abbreviation) shortAliases.add(config.abbreviation);
+function parseCliArguments() {
+	const cli = cac("rolldown");
+	for (const [key, info] of Object.entries(schemaInfo)) {
+		if (info.type === "never") continue;
+		const config = alias[key];
+		let rawName = "";
+		if (config?.abbreviation) rawName += `-${config.abbreviation}, `;
+		if (config?.reverse) rawName += `--no-${key}`;
+		else rawName += `--${key}`;
+		if (info.type !== "boolean" && !config?.reverse) if (config?.requireValue) rawName += ` <${config?.hint ?? key}>`;
+		else rawName += ` [${config?.hint ?? key}]`;
+		cli.option(rawName, info.description ?? config?.description ?? "");
+	}
+	let parsedInput = [];
+	let parsedOptions = {};
+	const cmd = cli.command("[...input]", "");
+	cmd.allowUnknownOptions();
+	cmd.ignoreOptionDefaultValue();
+	cmd.action((input, opts) => {
+		parsedInput = input;
+		parsedOptions = opts;
+	});
+	try {
+		cli.parse(process.argv, { run: true });
+	} catch (err) {
+		if (err?.name === "CACError") {
+			const match = err.message.match(/option `(.+?)` value is missing/);
+			if (match) {
+				const optName = match[1].replace(/ [<[].*/, "").replace(/^-\w, /, "");
+				logger.error(`Option \`${optName}\` requires a value but none was provided.`);
+			} else logger.error(err.message);
+			process.exit(1);
+		}
+		throw err;
+	}
+	delete parsedOptions["--"];
+	for (const short of shortAliases) delete parsedOptions[short];
+	for (const key of Object.keys(parsedOptions)) if (key === "__proto__" || key === "constructor" || key === "prototype" || key.startsWith("__proto__.") || key.startsWith("constructor.") || key.startsWith("prototype.")) delete parsedOptions[key];
+	const unknownKeys = Object.keys(parsedOptions).filter((k) => !knownKeys.has(k));
+	if (unknownKeys.length > 0) {
+		unknownKeys.sort();
+		const single = unknownKeys.length === 1;
+		logger.warn(`Option \`${unknownKeys.join(",")}\` ${single ? "is" : "are"} unrecognized. We will ignore ${single ? "this" : "those"} option${single ? "" : "s"}.`);
+	}
+	const rawArgs = { ...parsedOptions };
+	for (const key of unknownKeys) delete parsedOptions[key];
+	for (const [key, value] of Object.entries(parsedOptions)) {
+		const type = schemaInfo[key]?.type;
+		if (Array.isArray(value)) {
+			if (type !== "array" && type !== "object") parsedOptions[key] = value[value.length - 1];
+		} else if (type === "array" && typeof value === "string") parsedOptions[key] = [value];
+	}
+	for (const [schemaKey, info] of Object.entries(schemaInfo)) {
+		if (info.type !== "object") continue;
+		const parts = schemaKey.split(".");
+		let parent = parsedOptions;
+		for (let i = 0; i < parts.length - 1; i++) parent = parent?.[parts[i]];
+		const leafKey = parts[parts.length - 1];
+		const value = parent?.[leafKey];
+		if (value === void 0) continue;
+		const values = Array.isArray(value) ? value : [value];
+		if (typeof values[0] !== "string") continue;
+		let usedDeprecatedSyntax = false;
+		const result = {};
+		for (const v of values) for (const pair of String(v).split(",")) {
+			const colonIdx = pair.indexOf(":");
+			const eqIdx = pair.indexOf("=");
+			let k;
+			let val;
+			if (colonIdx > 0 && (eqIdx === -1 || colonIdx < eqIdx)) {
+				k = pair.slice(0, colonIdx);
+				val = pair.slice(colonIdx + 1);
+			} else if (eqIdx > 0) {
+				k = pair.slice(0, eqIdx);
+				val = pair.slice(eqIdx + 1);
+				usedDeprecatedSyntax = true;
+			} else continue;
+			result[k] = val;
+		}
+		if (usedDeprecatedSyntax) {
+			const optionName = camelCaseToKebabCase(schemaKey);
+			logger.warn(`Using \`key=value\` syntax for \`--${optionName}\` is deprecated. Use \`key:value\` instead.`);
+		}
+		parent[leafKey] = result;
+	}
+	return {
+		...normalizeCliOptions(parsedOptions, parsedInput),
+		rawArgs
+	};
+}
+//#endregion
+//#region src/utils/clear-screen.ts
+const CLEAR_SCREEN = "\x1Bc";
+function getClearScreenFunction(options) {
+	const isTTY = process.stdout.isTTY;
+	const isAnyOptionNotAllowingClearScreen = arraify(options).some(({ watch }) => watch === false || watch?.clearScreen === false);
+	if (isTTY && !isAnyOptionNotAllowingClearScreen) return () => {
+		process.stdout.write(CLEAR_SCREEN);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.130.0/helpers/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region src/cli/commands/bundle.ts
+async function bundleWithConfig(configPath, cliOptions, rawArgs = {}) {
+	if (cliOptions.watch) {
+		process.env.ROLLUP_WATCH = "true";
+		process.env.ROLLDOWN_WATCH = "true";
+	}
+	const config = await loadConfig(configPath);
+	const resolvedConfig = typeof config === "function" ? await config(rawArgs) : config;
+	if (typeof resolvedConfig !== "object" || resolvedConfig === null) {
+		logger.error(`Invalid configuration from ${configPath}: expected object or array, got ${resolvedConfig}`);
+		process.exit(1);
+	}
+	if (cliOptions.watch) await watchInner(resolvedConfig, cliOptions);
+	else await bundleInner(resolvedConfig, cliOptions);
+}
+async function bundleWithCliOptions(cliOptions) {
+	try {
+		var _usingCtx$1 = _usingCtx();
+		if (cliOptions.output.dir || cliOptions.output.file) {
+			await (cliOptions.watch ? watchInner : bundleInner)({}, cliOptions);
+			return;
+		}
+		if (cliOptions.watch) {
+			logger.error("You must specify `output.dir` to use watch mode");
+			process.exit(1);
+		}
+		const { output: outputs } = await _usingCtx$1.a(await rolldown(cliOptions.input)).generate(cliOptions.output);
+		if (outputs.length === 0) {
+			logger.error("No output generated");
+			process.exit(1);
+		}
+		for (const file of outputs) {
+			if (outputs.length > 1) logger.log(`\n${styleText(["cyan", "bold"], `|→ ${file.fileName}:`)}\n`);
+			console.log(file.type === "asset" ? file.source : file.code);
+		}
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		await _usingCtx$1.d();
+	}
+}
+async function watchInner(config, cliOptions) {
+	let normalizedConfig = arraify(config).map((option) => {
+		return {
+			...option,
+			...cliOptions.input,
+			output: arraify(option.output || {}).map((output) => {
+				return {
+					...output,
+					...cliOptions.output
+				};
+			})
+		};
+	});
+	const watcher = watch(normalizedConfig);
+	onExit((code) => {
+		Promise.resolve(watcher.close()).finally(() => {
+			process.exit(typeof code === "number" ? code : 0);
+		});
+		return true;
+	});
+	const changedFile = [];
+	watcher.on("change", (id, event) => {
+		if (event.event === "update") changedFile.push(id);
+	});
+	const clearScreen = getClearScreenFunction(normalizedConfig);
+	watcher.on("event", async (event) => {
+		switch (event.code) {
+			case "START":
+				clearScreen?.();
+				break;
+			case "BUNDLE_START":
+				if (changedFile.length > 0) logger.log(`Found ${styleText("bold", changedFile.map(relativeId).join(", "))} changed, rebuilding...`);
+				changedFile.length = 0;
+				break;
+			case "BUNDLE_END":
+				await event.result.close();
+				logger.success(`Rebuilt ${styleText("bold", relativeId(event.output[0]))} in ${styleText("green", ms(event.duration))}.`);
+				break;
+			case "ERROR":
+				await event.result.close();
+				logger.error(event.error);
+				break;
+			default: break;
+		}
+	});
+	logger.log(`Waiting for changes...`);
+}
+async function bundleInner(config, cliOptions) {
+	const startTime = performance.now();
+	const result = [];
+	const configList = arraify(config);
+	for (const config of configList) {
+		const outputList = arraify(config.output || {});
+		const build = await rolldown({
+			...config,
+			...cliOptions.input
+		});
+		try {
+			for (const output of outputList) result.push(await build.write({
+				...output,
+				...cliOptions.output
+			}));
+		} finally {
+			await build.close();
+		}
+	}
+	result.forEach(printBundleOutputPretty);
+	logger.log(``);
+	const duration = performance.now() - startTime;
+	logger.success(`rolldown v${version} Finished in ${styleText("green", ms(duration))}`);
+}
+function printBundleOutputPretty(output) {
+	const outputEntries = collectOutputEntries(output.output);
+	printOutputEntries(outputEntries, collectOutputLayoutAdjustmentSizes(outputEntries), "<DIR>");
+}
+function collectOutputEntries(output) {
+	return output.map((chunk) => ({
+		type: chunk.type,
+		fileName: chunk.fileName,
+		size: chunk.type === "chunk" ? Buffer.byteLength(chunk.code) : Buffer.byteLength(chunk.source)
+	}));
+}
+function collectOutputLayoutAdjustmentSizes(entries) {
+	let longest = 0;
+	let biggestSize = 0;
+	for (const entry of entries) {
+		if (entry.fileName.length > longest) longest = entry.fileName.length;
+		if (entry.size > biggestSize) biggestSize = entry.size;
+	}
+	const sizePad = displaySize(biggestSize).length;
+	return {
+		longest,
+		biggestSize,
+		sizePad
+	};
+}
+const numberFormatter = new Intl.NumberFormat("en", {
+	maximumFractionDigits: 2,
+	minimumFractionDigits: 2
+});
+function displaySize(bytes) {
+	return `${numberFormatter.format(bytes / 1e3)} kB`;
+}
+const CHUNK_GROUPS = [{
+	type: "asset",
+	color: "green"
+}, {
+	type: "chunk",
+	color: "cyan"
+}];
+function printOutputEntries(entries, sizeAdjustment, distPath) {
+	for (const group of CHUNK_GROUPS) {
+		const filtered = entries.filter((e) => e.type === group.type);
+		if (!filtered.length) continue;
+		for (const entry of filtered.sort((a, z) => a.size - z.size)) {
+			let log = styleText("dim", withTrailingSlash(distPath));
+			log += styleText(group.color, entry.fileName.padEnd(sizeAdjustment.longest + 2));
+			log += styleText("dim", entry.type);
+			log += styleText("dim", ` │ size: ${displaySize(entry.size).padStart(sizeAdjustment.sizePad)}`);
+			logger.log(log);
+		}
+	}
+}
+function withTrailingSlash(path) {
+	if (path[path.length - 1] !== "/") return `${path}/`;
+	return path;
+}
+function ms(duration) {
+	return duration < 1e3 ? `${duration.toFixed(2)} ms` : `${(duration / 1e3).toFixed(2)} s`;
+}
+function relativeId(id) {
+	if (!path.isAbsolute(id)) return id;
+	return path.relative(path.resolve(), id);
+}
+//#endregion
+//#region src/cli/commands/help.ts
+const examples = [
+	{
+		title: "Bundle with a config file `rolldown.config.mjs`",
+		command: "rolldown -c rolldown.config.mjs"
+	},
+	{
+		title: "Bundle the `src/main.ts` to `dist` with `cjs` format",
+		command: "rolldown src/main.ts -d dist -f cjs"
+	},
+	{
+		title: "Bundle the `src/main.ts` and handle the `.png` assets to Data URL",
+		command: "rolldown src/main.ts -d dist --moduleTypes .png=dataurl"
+	},
+	{
+		title: "Bundle the `src/main.tsx` and minify the output with sourcemap",
+		command: "rolldown src/main.tsx -d dist -m -s"
+	},
+	{
+		title: "Create self-executing IIFE using external jQuery as `$` and `_`",
+		command: "rolldown src/main.ts -d dist -n bundle -f iife -e jQuery,window._ -g jQuery=$"
+	}
+];
+const notes = ["CLI options will override the configuration file.", "For more information, please visit https://rolldown.rs/."];
+/**
+* Generates the CLI help text as a string.
+*/
+function generateHelpText() {
+	const lines = [];
+	lines.push(`${styleText("gray", `${description} (rolldown v${version})`)}`);
+	lines.push("");
+	lines.push(`${styleText(["bold", "underline"], "USAGE")} ${styleText("cyan", "rolldown -c <config>")} or ${styleText("cyan", "rolldown <input> <options>")}`);
+	lines.push("");
+	lines.push(`${styleText(["bold", "underline"], "OPTIONS")}`);
+	lines.push("");
+	lines.push(Object.entries(options).sort(([a], [b]) => {
+		if (options[a].short && !options[b].short) return -1;
+		if (!options[a].short && options[b].short) return 1;
+		if (options[a].short && options[b].short) return options[a].short.localeCompare(options[b].short);
+		return a.localeCompare(b);
+	}).map(([option, { type, short, hint, description }]) => {
+		let optionStr = `  --${option} `;
+		option = camelCaseToKebabCase(option);
+		if (short) optionStr += `-${short}, `;
+		if (type === "string") optionStr += `<${hint ?? option}>`;
+		if (description && description.length > 0) description = description[0].toUpperCase() + description.slice(1);
+		return styleText("cyan", optionStr.padEnd(30)) + description + (description && description?.endsWith(".") ? "" : ".");
+	}).join("\n"));
+	lines.push("");
+	lines.push(`${styleText(["bold", "underline"], "EXAMPLES")}`);
+	lines.push("");
+	examples.forEach(({ title, command }, ord) => {
+		lines.push(`  ${ord + 1}. ${title}:`);
+		lines.push(`    ${styleText("cyan", command)}`);
+		lines.push("");
+	});
+	lines.push(`${styleText(["bold", "underline"], "NOTES")}`);
+	lines.push("");
+	notes.forEach((note) => {
+		lines.push(`  * ${styleText("gray", note)}`);
+	});
+	return lines.join("\n");
+}
+function showHelp() {
+	logger.log(generateHelpText());
+}
+//#endregion
+//#region src/cli/version-check.ts
+function checkNodeVersion(nodeVersion) {
+	const currentVersion = nodeVersion.split(".");
+	const major = parseInt(currentVersion[0], 10);
+	const minor = parseInt(currentVersion[1], 10);
+	return major === 20 && minor >= 19 || major === 22 && minor >= 12 || major > 22;
+}
+//#endregion
+//#region src/cli/index.ts
+if (!checkNodeVersion(process$1.versions.node)) logger.warn(`You are using Node.js ${process$1.versions.node}. Rolldown requires Node.js version 20.19+ or 22.12+. Please upgrade your Node.js version.`);
+async function main() {
+	const { rawArgs, ...cliOptions } = parseCliArguments();
+	if (cliOptions.environment) {
+		const environment = Array.isArray(cliOptions.environment) ? cliOptions.environment : [cliOptions.environment];
+		for (const argument of environment) for (const pair of argument.split(",")) {
+			const [key, ...value] = pair.split(":");
+			process$1.env[key] = value.length === 0 ? String(true) : value.join(":");
+		}
+	}
+	if (cliOptions.help) {
+		showHelp();
+		return;
+	}
+	if (cliOptions.version) {
+		logger.log(`rolldown v${version}`);
+		return;
+	}
+	if (cliOptions.config || cliOptions.config === "") {
+		await bundleWithConfig(cliOptions.config, cliOptions, rawArgs);
+		return;
+	}
+	if ("input" in cliOptions.input) {
+		await bundleWithCliOptions(cliOptions);
+		return;
+	}
+	showHelp();
+}
+main().catch((err) => {
+	logger.error(err);
+	process$1.exit(1);
+});
+//#endregion
+export {};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/config.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/config.d.mts
new file mode 100644
index 0000000..371b942
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/config.d.mts
@@ -0,0 +1,14 @@
+import { I as VERSION, r as defineConfig, t as ConfigExport } from "./shared/define-config-CeKzMIcs.mjs";
+
+//#region src/utils/load-config.d.ts
+/**
+* Load config from a file in a way that Rolldown does.
+*
+* @param configPath The path to the config file. If empty, it will look for `rolldown.config` with supported extensions in the current working directory.
+* @returns The loaded config export
+*
+* @category Config
+*/
+declare function loadConfig(configPath: string): Promise<ConfigExport>;
+//#endregion
+export { VERSION, defineConfig, loadConfig };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/config.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/config.mjs
new file mode 100644
index 0000000..ceda50c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/config.mjs
@@ -0,0 +1,4 @@
+import { x as VERSION } from "./shared/bindingify-input-options-BnfFBV6b.mjs";
+import { t as defineConfig } from "./shared/define-config-DJOr6Iwt.mjs";
+import { t as loadConfig } from "./shared/load-config-CYoi2Wo1.mjs";
+export { VERSION, defineConfig, loadConfig };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/experimental-index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/experimental-index.d.mts
new file mode 100644
index 0000000..dbb40d9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/experimental-index.d.mts
@@ -0,0 +1,253 @@
+import { B as ResolveResult, C as BindingViteManifestPluginConfig, G as isolatedDeclaration, I as NapiResolveOptions, K as isolatedDeclarationSync, M as IsolatedDeclarationsResult, O as BindingViteTransformPluginConfig, V as ResolverFactory, _ as BindingTsconfigRawOptions, f as BindingRebuildStrategy, g as BindingTsconfigCompilerOptions, i as BindingClientHmrUpdate, j as IsolatedDeclarationsOptions, n as BindingBundleAnalyzerPluginConfig, q as moduleRunnerTransform, r as BindingBundleState } from "./shared/binding-zH1vcmbM.mjs";
+import { Jt as RolldownOutput, P as BuiltinPlugin, Xt as freeExternalMemory, Z as defineParallelPlugin, ct as NormalizedOutputOptions, l as InputOptions, zt as OutputOptions } from "./shared/define-config-CeKzMIcs.mjs";
+import { a as MinifyOptions$1, c as minifySync$1, d as parse$1, f as parseSync$1, i as transformSync$1, l as ParseResult$1, m as resolveTsconfig, n as TransformResult$1, o as MinifyResult$1, p as TsconfigCache$1, r as transform$1, s as minify$1, t as TransformOptions$1, u as ParserOptions$1 } from "./shared/transform-DgZ3paSD.mjs";
+import { a as viteDynamicImportVarsPlugin, c as viteLoadFallbackPlugin, d as viteReporterPlugin, f as viteResolvePlugin, i as viteBuildImportAnalysisPlugin, l as viteModulePreloadPolyfillPlugin, m as viteWebWorkerPostPlugin, n as isolatedDeclarationPlugin, o as viteImportGlobPlugin, p as viteWasmFallbackPlugin, r as oxcRuntimePlugin, s as viteJsonPlugin, u as viteReactRefreshWrapperPlugin } from "./shared/constructors-DAnSz-_I.mjs";
+
+//#region src/api/dev/dev-options.d.ts
+type DevOnHmrUpdates = (result: Error | {
+  updates: BindingClientHmrUpdate[];
+  changedFiles: string[];
+}) => void | Promise<void>;
+type DevOnOutput = (result: Error | RolldownOutput) => void | Promise<void>;
+interface DevWatchOptions {
+  /**
+  * If `true`, files are not written to disk.
+  * @default false
+  */
+  skipWrite?: boolean;
+  /**
+  * If `true`, use polling instead of native file system events for watching.
+  * @default false
+  */
+  usePolling?: boolean;
+  /**
+  * Poll interval in milliseconds (only used when usePolling is true).
+  * @default 100
+  */
+  pollInterval?: number;
+  /**
+  * If `true`, use debounced watcher. If `false`, use non-debounced watcher for immediate responses.
+  * @default true
+  */
+  useDebounce?: boolean;
+  /**
+  * Debounce duration in milliseconds (only used when useDebounce is true).
+  * @default 10
+  */
+  debounceDuration?: number;
+  /**
+  * Whether to compare file contents for poll-based watchers (only used when usePolling is true).
+  * When enabled, poll watchers will check file contents to determine if they actually changed.
+  * @default false
+  */
+  compareContentsForPolling?: boolean;
+  /**
+  * Tick rate in milliseconds for debounced watchers (only used when useDebounce is true).
+  * Controls how frequently the debouncer checks for events to process.
+  * When not specified, the debouncer will auto-select an appropriate tick rate (1/4 of the debounce duration).
+  * @default undefined (auto-select)
+  */
+  debounceTickRate?: number;
+}
+interface DevOptions {
+  onHmrUpdates?: DevOnHmrUpdates;
+  onOutput?: DevOnOutput;
+  /**
+  * Strategy for triggering rebuilds after HMR updates.
+  * - `'always'`: Always trigger a rebuild after HMR updates
+  * - `'auto'`: Trigger rebuild only if HMR updates contain full reload updates
+  * - `'never'`: Never trigger rebuild after HMR updates (default)
+  * @default 'auto'
+  */
+  rebuildStrategy?: "always" | "auto" | "never";
+  watch?: DevWatchOptions;
+}
+//#endregion
+//#region src/api/dev/dev-engine.d.ts
+declare class DevEngine {
+  #private;
+  static create(inputOptions: InputOptions, outputOptions?: OutputOptions, devOptions?: DevOptions): Promise<DevEngine>;
+  private constructor();
+  run(): Promise<void>;
+  ensureCurrentBuildFinish(): Promise<void>;
+  getBundleState(): Promise<BindingBundleState>;
+  ensureLatestBuildOutput(): Promise<void>;
+  invalidate(file: string, firstInvalidatedBy?: string): Promise<BindingClientHmrUpdate[]>;
+  registerModules(clientId: string, modules: string[]): Promise<void>;
+  removeClient(clientId: string): Promise<void>;
+  close(): Promise<void>;
+  /**
+  * Compile a lazy entry module and return HMR-style patch code.
+  *
+  * This is called when a dynamically imported module is first requested at runtime.
+  * The module was previously stubbed with a proxy, and now we need to compile the
+  * actual module and its dependencies.
+  *
+  * @param moduleId - The absolute file path of the module to compile
+  * @param clientId - The client ID requesting this compilation
+  * @returns The compiled JavaScript code as a string (HMR patch format)
+  */
+  compileEntry(moduleId: string, clientId: string): Promise<string>;
+}
+//#endregion
+//#region src/api/dev/index.d.ts
+declare const dev: typeof DevEngine.create;
+//#endregion
+//#region src/api/experimental.d.ts
+/**
+* This is an experimental API. Its behavior may change in the future.
+*
+* - Calling this API will only execute the `scan/build` stage of rolldown.
+* - `scan` will clean up all resources automatically, but if you want to ensure timely cleanup, you need to wait for the returned promise to resolve.
+*
+* @example To ensure cleanup of resources, use the returned promise to wait for the scan to complete.
+* ```ts
+* import { scan } from 'rolldown/api/experimental';
+*
+* const cleanupPromise = await scan(...);
+* await cleanupPromise;
+* // Now all resources have been cleaned up.
+* ```
+*/
+declare const scan: (rawInputOptions: InputOptions, rawOutputOptions?: {}) => Promise<Promise<void>>;
+//#endregion
+//#region src/builtin-plugin/alias-plugin.d.ts
+type ViteAliasPluginConfig = {
+  entries: {
+    find: string | RegExp;
+    replacement: string;
+  }[];
+};
+declare function viteAliasPlugin(config: ViteAliasPluginConfig): BuiltinPlugin;
+//#endregion
+//#region src/builtin-plugin/bundle-analyzer-plugin.d.ts
+/**
+* A plugin that analyzes bundle composition and generates detailed reports.
+*
+* The plugin outputs a file containing detailed information about:
+* - All chunks and their relationships
+* - Modules bundled in each chunk
+* - Import dependencies between chunks
+* - Reachable modules from each entry point
+*
+* @example
+* ```js
+* import { bundleAnalyzerPlugin } from 'rolldown/experimental';
+*
+* export default {
+*   plugins: [
+*     bundleAnalyzerPlugin()
+*   ]
+* }
+* ```
+*
+* @example
+* **Custom filename**
+* ```js
+* import { bundleAnalyzerPlugin } from 'rolldown/experimental';
+*
+* export default {
+*   plugins: [
+*     bundleAnalyzerPlugin({
+*       fileName: 'bundle-analysis.json'
+*     })
+*   ]
+* }
+* ```
+*
+* @example
+* **LLM-friendly markdown output**
+* ```js
+* import { bundleAnalyzerPlugin } from 'rolldown/experimental';
+*
+* export default {
+*   plugins: [
+*     bundleAnalyzerPlugin({
+*       format: 'md'
+*     })
+*   ]
+* }
+* ```
+*/
+declare function bundleAnalyzerPlugin(config?: BindingBundleAnalyzerPluginConfig): BuiltinPlugin;
+//#endregion
+//#region src/builtin-plugin/transform-plugin.d.ts
+type TransformPattern = string | RegExp | readonly (RegExp | string)[];
+type TransformPluginConfig = Omit<BindingViteTransformPluginConfig, "include" | "exclude" | "jsxRefreshInclude" | "jsxRefreshExclude" | "yarnPnp"> & {
+  include?: TransformPattern;
+  exclude?: TransformPattern;
+  jsxRefreshInclude?: TransformPattern;
+  jsxRefreshExclude?: TransformPattern;
+};
+declare function viteTransformPlugin(config: TransformPluginConfig): BuiltinPlugin;
+//#endregion
+//#region src/builtin-plugin/vite-manifest-plugin.d.ts
+type ViteManifestPluginConfig = Omit<BindingViteManifestPluginConfig, "isLegacy"> & {
+  isOutputOptionsForLegacyChunks?: (outputOptions: NormalizedOutputOptions) => boolean;
+};
+declare function viteManifestPlugin(config: ViteManifestPluginConfig): BuiltinPlugin;
+//#endregion
+//#region src/experimental-index.d.ts
+/**
+* In-memory file system for browser builds.
+*
+* This is a re-export of the {@link https://github.com/streamich/memfs | memfs} package used by the WASI runtime.
+* It allows you to read and write files to a virtual filesystem when using rolldown in browser environments.
+*
+* - `fs`: A Node.js-compatible filesystem API (`IFs` from memfs)
+* - `volume`: The underlying `Volume` instance that stores the filesystem state
+*
+* Returns `undefined` in Node.js builds (only available in browser builds via `@rolldown/browser`).
+*
+* @example
+* ```typescript
+* import { memfs } from 'rolldown/experimental';
+*
+* // Write files to virtual filesystem before bundling
+* memfs?.volume.fromJSON({
+*   '/src/index.js': 'export const foo = 42;',
+*   '/package.json': '{"name": "my-app"}'
+* });
+*
+* // Read files from the virtual filesystem
+* const content = memfs?.fs.readFileSync('/src/index.js', 'utf8');
+* ```
+*
+* @see {@link https://github.com/streamich/memfs} for more information on the memfs API.
+*/
+declare const memfs: {
+  fs: any;
+  volume: any;
+} | undefined;
+/** @deprecated Use from `rolldown/utils` instead. */
+declare const parse: typeof parse$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+declare const parseSync: typeof parseSync$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+type ParseResult = ParseResult$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+type ParserOptions = ParserOptions$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+declare const minify: typeof minify$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+declare const minifySync: typeof minifySync$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+type MinifyOptions = MinifyOptions$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+type MinifyResult = MinifyResult$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+declare const transform: typeof transform$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+declare const transformSync: typeof transformSync$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+type TransformOptions = TransformOptions$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+type TransformResult = TransformResult$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+declare const TsconfigCache: typeof TsconfigCache$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+type TsconfigRawOptions = BindingTsconfigRawOptions;
+/** @deprecated Use from `rolldown/utils` instead. */
+type TsconfigCompilerOptions = BindingTsconfigCompilerOptions;
+//#endregion
+export { type BindingClientHmrUpdate, BindingRebuildStrategy, DevEngine, type DevOptions, type DevWatchOptions, type IsolatedDeclarationsOptions, type IsolatedDeclarationsResult, MinifyOptions, MinifyResult, ParseResult, ParserOptions, type NapiResolveOptions as ResolveOptions, type ResolveResult, ResolverFactory, TransformOptions, TransformResult, TsconfigCache, TsconfigCompilerOptions, TsconfigRawOptions, bundleAnalyzerPlugin, defineParallelPlugin, dev, viteDynamicImportVarsPlugin as dynamicImportVarsPlugin, viteDynamicImportVarsPlugin, freeExternalMemory, viteImportGlobPlugin as importGlobPlugin, viteImportGlobPlugin, isolatedDeclaration, isolatedDeclarationPlugin, isolatedDeclarationSync, memfs, minify, minifySync, moduleRunnerTransform, oxcRuntimePlugin, parse, parseSync, resolveTsconfig, scan, transform, transformSync, viteAliasPlugin, viteBuildImportAnalysisPlugin, viteJsonPlugin, viteLoadFallbackPlugin, viteManifestPlugin, viteModulePreloadPolyfillPlugin, viteReactRefreshWrapperPlugin, viteReporterPlugin, viteResolvePlugin, viteTransformPlugin, viteWasmFallbackPlugin, viteWebWorkerPostPlugin };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/experimental-index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/experimental-index.mjs
new file mode 100644
index 0000000..d55d787
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/experimental-index.mjs
@@ -0,0 +1,320 @@
+import { n as __toESM, t as require_binding } from "./shared/binding-C9S351wt.mjs";
+import { n as BuiltinPlugin, t as normalizedStringOrRegex } from "./shared/normalize-string-or-regex-C-WttzRA.mjs";
+import { o as transformToRollupOutput } from "./shared/bindingify-input-options-BnfFBV6b.mjs";
+import { c as validateOption, n as createBundlerOptions, t as RolldownBuild, u as PluginDriver } from "./shared/rolldown-build-BVD3dIdE.mjs";
+import { i as unwrapBindingResult, r as normalizeBindingResult } from "./shared/error-CkdMJ9ps.mjs";
+import { n as parseSync$1, t as parse$1 } from "./shared/parse-Ch28GO2f.mjs";
+import { a as viteDynamicImportVarsPlugin, c as viteLoadFallbackPlugin, d as viteReporterPlugin, f as viteResolvePlugin, i as viteBuildImportAnalysisPlugin, l as viteModulePreloadPolyfillPlugin, m as viteWebWorkerPostPlugin, n as isolatedDeclarationPlugin, o as viteImportGlobPlugin, p as viteWasmFallbackPlugin, r as oxcRuntimePlugin, s as viteJsonPlugin, u as viteReactRefreshWrapperPlugin } from "./shared/constructors-Ciqn_yS7.mjs";
+import { a as minify$1, i as transformSync$1, n as resolveTsconfig, o as minifySync$1, r as transform$1, t as TsconfigCache$1 } from "./shared/resolve-tsconfig-DkVV0OYf.mjs";
+import { pathToFileURL } from "node:url";
+//#region src/api/dev/dev-engine.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+var DevEngine = class DevEngine {
+	#inner;
+	#cachedBuildFinishPromise = null;
+	static async create(inputOptions, outputOptions = {}, devOptions = {}) {
+		inputOptions = await PluginDriver.callOptionsHook(inputOptions);
+		const options = await createBundlerOptions(inputOptions, outputOptions, false);
+		const userOnHmrUpdates = devOptions.onHmrUpdates;
+		const bindingOnHmrUpdates = userOnHmrUpdates ? function(rawResult) {
+			const result = normalizeBindingResult(rawResult);
+			if (result instanceof Error) {
+				userOnHmrUpdates(result);
+				return;
+			}
+			const [updates, changedFiles] = result;
+			userOnHmrUpdates({
+				updates,
+				changedFiles
+			});
+		} : void 0;
+		const userOnOutput = devOptions.onOutput;
+		const bindingDevOptions = {
+			onHmrUpdates: bindingOnHmrUpdates,
+			onOutput: userOnOutput ? function(rawResult) {
+				const result = normalizeBindingResult(rawResult);
+				if (result instanceof Error) {
+					userOnOutput(result);
+					return;
+				}
+				userOnOutput(transformToRollupOutput(result));
+			} : void 0,
+			rebuildStrategy: devOptions.rebuildStrategy ? devOptions.rebuildStrategy === "always" ? import_binding.BindingRebuildStrategy.Always : devOptions.rebuildStrategy === "auto" ? import_binding.BindingRebuildStrategy.Auto : import_binding.BindingRebuildStrategy.Never : void 0,
+			watch: devOptions.watch && {
+				skipWrite: devOptions.watch.skipWrite,
+				usePolling: devOptions.watch.usePolling,
+				pollInterval: devOptions.watch.pollInterval,
+				useDebounce: devOptions.watch.useDebounce,
+				debounceDuration: devOptions.watch.debounceDuration,
+				compareContentsForPolling: devOptions.watch.compareContentsForPolling,
+				debounceTickRate: devOptions.watch.debounceTickRate
+			}
+		};
+		return new DevEngine(new import_binding.BindingDevEngine(options.bundlerOptions, bindingDevOptions));
+	}
+	constructor(inner) {
+		this.#inner = inner;
+	}
+	async run() {
+		await this.#inner.run();
+	}
+	async ensureCurrentBuildFinish() {
+		if (this.#cachedBuildFinishPromise) return this.#cachedBuildFinishPromise;
+		const promise = this.#inner.ensureCurrentBuildFinish().then(() => {
+			this.#cachedBuildFinishPromise = null;
+		});
+		this.#cachedBuildFinishPromise = promise;
+		return promise;
+	}
+	async getBundleState() {
+		return this.#inner.getBundleState();
+	}
+	async ensureLatestBuildOutput() {
+		await this.#inner.ensureLatestBuildOutput();
+	}
+	async invalidate(file, firstInvalidatedBy) {
+		return this.#inner.invalidate(file, firstInvalidatedBy);
+	}
+	async registerModules(clientId, modules) {
+		await this.#inner.registerModules(clientId, modules);
+	}
+	async removeClient(clientId) {
+		await this.#inner.removeClient(clientId);
+	}
+	async close() {
+		await this.#inner.close();
+	}
+	/**
+	* Compile a lazy entry module and return HMR-style patch code.
+	*
+	* This is called when a dynamically imported module is first requested at runtime.
+	* The module was previously stubbed with a proxy, and now we need to compile the
+	* actual module and its dependencies.
+	*
+	* @param moduleId - The absolute file path of the module to compile
+	* @param clientId - The client ID requesting this compilation
+	* @returns The compiled JavaScript code as a string (HMR patch format)
+	*/
+	async compileEntry(moduleId, clientId) {
+		return this.#inner.compileEntry(moduleId, clientId);
+	}
+};
+//#endregion
+//#region src/api/dev/index.ts
+const dev = (...args) => DevEngine.create(...args);
+//#endregion
+//#region src/types/external-memory-handle.ts
+const symbolForExternalMemoryHandle = "__rolldown_external_memory_handle__";
+/**
+* Frees the external memory held by the given handle.
+*
+* This is useful when you want to manually release memory held by Rust objects
+* (like `OutputChunk` or `OutputAsset`) before they are garbage collected.
+*
+* @param handle - The object with external memory to free
+* @param keepDataAlive - If true, evaluates all lazy fields before freeing memory (default: false).
+*   This will take time to copy data from Rust to JavaScript, but prevents errors
+*   when accessing properties after the memory is freed.
+* @returns Status object with `freed` boolean and optional `reason` string.
+*   - `{ freed: true }` if memory was successfully freed
+*   - `{ freed: false, reason: "..." }` if memory couldn't be freed (e.g., already freed or other references exist)
+*
+* @example
+* ```typescript
+* import { freeExternalMemory } from 'rolldown/experimental';
+*
+* const output = await bundle.generate();
+* const chunk = output.output[0];
+*
+* // Use the chunk...
+*
+* // Manually free the memory (fast, but accessing properties after will throw)
+* const status = freeExternalMemory(chunk); // { freed: true }
+* const statusAgain = freeExternalMemory(chunk); // { freed: false, reason: "Memory has already been freed" }
+*
+* // Keep data alive before freeing (slower, but data remains accessible)
+* freeExternalMemory(chunk, true); // Evaluates all lazy fields first
+* console.log(chunk.code); // OK - data was copied to JavaScript before freeing
+*
+* // Without keepDataAlive, accessing chunk properties after freeing will throw an error
+* ```
+*/
+function freeExternalMemory(handle, keepDataAlive = false) {
+	return handle[symbolForExternalMemoryHandle](keepDataAlive);
+}
+//#endregion
+//#region src/api/experimental.ts
+/**
+* This is an experimental API. Its behavior may change in the future.
+*
+* - Calling this API will only execute the `scan/build` stage of rolldown.
+* - `scan` will clean up all resources automatically, but if you want to ensure timely cleanup, you need to wait for the returned promise to resolve.
+*
+* @example To ensure cleanup of resources, use the returned promise to wait for the scan to complete.
+* ```ts
+* import { scan } from 'rolldown/api/experimental';
+*
+* const cleanupPromise = await scan(...);
+* await cleanupPromise;
+* // Now all resources have been cleaned up.
+* ```
+*/
+const scan = async (rawInputOptions, rawOutputOptions = {}) => {
+	validateOption("input", rawInputOptions);
+	validateOption("output", rawOutputOptions);
+	const ret = await createBundlerOptions(await PluginDriver.callOptionsHook(rawInputOptions), rawOutputOptions, false);
+	const bundler = new import_binding.BindingBundler();
+	if (RolldownBuild.asyncRuntimeShutdown) (0, import_binding.startAsyncRuntime)();
+	async function cleanup() {
+		await bundler.close();
+		await ret.stopWorkers?.();
+		(0, import_binding.shutdownAsyncRuntime)();
+		RolldownBuild.asyncRuntimeShutdown = true;
+	}
+	let cleanupPromise = Promise.resolve();
+	try {
+		unwrapBindingResult(await bundler.scan(ret.bundlerOptions));
+	} catch (err) {
+		await cleanup();
+		throw err;
+	} finally {
+		cleanupPromise = cleanup();
+	}
+	return cleanupPromise;
+};
+//#endregion
+//#region src/plugin/parallel-plugin.ts
+function defineParallelPlugin(pluginPath) {
+	return (options) => {
+		return { _parallel: {
+			fileUrl: pathToFileURL(pluginPath).href,
+			options
+		} };
+	};
+}
+//#endregion
+//#region src/builtin-plugin/alias-plugin.ts
+function viteAliasPlugin(config) {
+	return new BuiltinPlugin("builtin:vite-alias", config);
+}
+//#endregion
+//#region src/builtin-plugin/bundle-analyzer-plugin.ts
+/**
+* A plugin that analyzes bundle composition and generates detailed reports.
+*
+* The plugin outputs a file containing detailed information about:
+* - All chunks and their relationships
+* - Modules bundled in each chunk
+* - Import dependencies between chunks
+* - Reachable modules from each entry point
+*
+* @example
+* ```js
+* import { bundleAnalyzerPlugin } from 'rolldown/experimental';
+*
+* export default {
+*   plugins: [
+*     bundleAnalyzerPlugin()
+*   ]
+* }
+* ```
+*
+* @example
+* **Custom filename**
+* ```js
+* import { bundleAnalyzerPlugin } from 'rolldown/experimental';
+*
+* export default {
+*   plugins: [
+*     bundleAnalyzerPlugin({
+*       fileName: 'bundle-analysis.json'
+*     })
+*   ]
+* }
+* ```
+*
+* @example
+* **LLM-friendly markdown output**
+* ```js
+* import { bundleAnalyzerPlugin } from 'rolldown/experimental';
+*
+* export default {
+*   plugins: [
+*     bundleAnalyzerPlugin({
+*       format: 'md'
+*     })
+*   ]
+* }
+* ```
+*/
+function bundleAnalyzerPlugin(config) {
+	return new BuiltinPlugin("builtin:bundle-analyzer", config);
+}
+//#endregion
+//#region src/builtin-plugin/transform-plugin.ts
+function viteTransformPlugin(config) {
+	return new BuiltinPlugin("builtin:vite-transform", {
+		...config,
+		include: normalizedStringOrRegex(config.include),
+		exclude: normalizedStringOrRegex(config.exclude),
+		jsxRefreshInclude: normalizedStringOrRegex(config.jsxRefreshInclude),
+		jsxRefreshExclude: normalizedStringOrRegex(config.jsxRefreshExclude),
+		yarnPnp: typeof process === "object" && !!process.versions?.pnp
+	});
+}
+//#endregion
+//#region src/builtin-plugin/vite-manifest-plugin.ts
+function viteManifestPlugin(config) {
+	return new BuiltinPlugin("builtin:vite-manifest", config);
+}
+//#endregion
+//#region src/experimental-index.ts
+/**
+* In-memory file system for browser builds.
+*
+* This is a re-export of the {@link https://github.com/streamich/memfs | memfs} package used by the WASI runtime.
+* It allows you to read and write files to a virtual filesystem when using rolldown in browser environments.
+*
+* - `fs`: A Node.js-compatible filesystem API (`IFs` from memfs)
+* - `volume`: The underlying `Volume` instance that stores the filesystem state
+*
+* Returns `undefined` in Node.js builds (only available in browser builds via `@rolldown/browser`).
+*
+* @example
+* ```typescript
+* import { memfs } from 'rolldown/experimental';
+*
+* // Write files to virtual filesystem before bundling
+* memfs?.volume.fromJSON({
+*   '/src/index.js': 'export const foo = 42;',
+*   '/package.json': '{"name": "my-app"}'
+* });
+*
+* // Read files from the virtual filesystem
+* const content = memfs?.fs.readFileSync('/src/index.js', 'utf8');
+* ```
+*
+* @see {@link https://github.com/streamich/memfs} for more information on the memfs API.
+*/
+const memfs = void 0;
+/** @deprecated Use from `rolldown/utils` instead. */
+const parse = parse$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+const parseSync = parseSync$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+const minify = minify$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+const minifySync = minifySync$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+const transform = transform$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+const transformSync = transformSync$1;
+/** @deprecated Use from `rolldown/utils` instead. */
+const TsconfigCache = TsconfigCache$1;
+//#endregion
+var BindingRebuildStrategy = import_binding.BindingRebuildStrategy;
+var ResolverFactory = import_binding.ResolverFactory;
+var isolatedDeclaration = import_binding.isolatedDeclaration;
+var isolatedDeclarationSync = import_binding.isolatedDeclarationSync;
+var moduleRunnerTransform = import_binding.moduleRunnerTransform;
+export { BindingRebuildStrategy, DevEngine, ResolverFactory, TsconfigCache, bundleAnalyzerPlugin, defineParallelPlugin, dev, viteDynamicImportVarsPlugin as dynamicImportVarsPlugin, viteDynamicImportVarsPlugin, freeExternalMemory, viteImportGlobPlugin as importGlobPlugin, viteImportGlobPlugin, isolatedDeclaration, isolatedDeclarationPlugin, isolatedDeclarationSync, memfs, minify, minifySync, moduleRunnerTransform, oxcRuntimePlugin, parse, parseSync, resolveTsconfig, scan, transform, transformSync, viteAliasPlugin, viteBuildImportAnalysisPlugin, viteJsonPlugin, viteLoadFallbackPlugin, viteManifestPlugin, viteModulePreloadPolyfillPlugin, viteReactRefreshWrapperPlugin, viteReporterPlugin, viteResolvePlugin, viteTransformPlugin, viteWasmFallbackPlugin, viteWebWorkerPostPlugin };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/experimental-runtime-types.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/experimental-runtime-types.d.ts
new file mode 100644
index 0000000..224ceb6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/experimental-runtime-types.d.ts
@@ -0,0 +1,107 @@
+/**
+ * @typedef {{ type: 'hmr:module-registered', modules: string[] }} DevRuntimeMessage
+ * @typedef {{ send(message: DevRuntimeMessage): void }} Messenger
+ */
+export class DevRuntime {
+    /**
+     * @param {Messenger} messenger
+     * @param {string} clientId
+     */
+    constructor(messenger: Messenger, clientId: string);
+    /**
+     * Client ID generated at runtime initialization, used for lazy compilation requests.
+     * @type {string}
+     */
+    clientId: string;
+    messenger: Messenger;
+    /**
+     * @type {Record<string, Module>}
+     */
+    modules: Record<string, Module>;
+    /**
+     * @param {string} _moduleId
+     */
+    createModuleHotContext(_moduleId: string): void;
+    /**
+     * @param {[string, string][]} _boundaries
+     */
+    applyUpdates(_boundaries: [string, string][]): void;
+    /**
+     * @param {string} id
+     * @param {{ exports: any }} exportsHolder
+     */
+    registerModule(id: string, exportsHolder: {
+        exports: any;
+    }): void;
+    /**
+     * @param {string} id
+     */
+    loadExports(id: string): any;
+    /**
+     * __esmMin
+     *
+     * When `dedup` is truthy and `id` is already registered on the runtime,
+     * skip the factory: another lazy blob got there first. HMR patches pass
+     * no `dedup` so they always re-run the factory and replace the registered
+     * exports.
+     *
+     * @type {<T>(id: string, fn: any, dedup: any, res: T) => () => T}
+     * @internal
+     */
+    createEsmInitializer: <T>(id: string, fn: any, dedup: any, res: T) => () => T;
+    /**
+     * __commonJSMin
+     *
+     * Same dedup gate as createEsmInitializer. With `dedup` truthy and `id`
+     * registered, reuse the registered exports object; otherwise run the
+     * factory.
+     *
+     * @type {<T extends { exports: any }>(id: string, cb: any, dedup: any, mod: { exports: any }, registered: any) => () => T}
+     * @internal
+     */
+    createCjsInitializer: <T extends {
+        exports: any;
+    }>(id: string, cb: any, dedup: any, mod: {
+        exports: any;
+    }, registered: any) => () => T;
+    /** @internal */
+    __toESM: any;
+    /** @internal */
+    __toCommonJS: any;
+    /** @internal */
+    __exportAll: any;
+    /**
+     * @param {boolean} [isNodeMode]
+     * @returns {(mod: any) => any}
+     * @internal
+     */
+    __toDynamicImportESM: (isNodeMode?: boolean) => (mod: any) => any;
+    /** @internal */
+    __reExport: any;
+    sendModuleRegisteredMessage: (module: string) => void;
+}
+export type DevRuntimeMessage = {
+    type: "hmr:module-registered";
+    modules: string[];
+};
+export type Messenger = {
+    send(message: DevRuntimeMessage): void;
+};
+declare class Module {
+    /**
+     * @param {string} id
+     */
+    constructor(id: string);
+    /**
+     * @type {{ exports: any }}
+     */
+    exportsHolder: {
+        exports: any;
+    };
+    /**
+     * @type {string}
+     */
+    id: string;
+    get exports(): any;
+}
+export {};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/filter-index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/filter-index.d.mts
new file mode 100644
index 0000000..8f62ff2
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/filter-index.d.mts
@@ -0,0 +1,196 @@
+import { N as withFilter } from "./shared/define-config-CeKzMIcs.mjs";
+
+//#region ../../node_modules/.pnpm/@rolldown+pluginutils@1.0.0/node_modules/@rolldown/pluginutils/dist/filter/composable-filters.d.ts
+type StringOrRegExp = string | RegExp;
+type PluginModuleType = 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | (string & {});
+type FilterExpressionKind = FilterExpression['kind'];
+type FilterExpression = And | Or | Not | Id | ImporterId | ModuleType | Code | Query;
+type TopLevelFilterExpression = Include | Exclude;
+declare class And {
+  kind: 'and';
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Or {
+  kind: 'or';
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Not {
+  kind: 'not';
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+interface QueryFilterObject {
+  [key: string]: StringOrRegExp | boolean;
+}
+interface IdParams {
+  cleanUrl?: boolean;
+}
+declare class Id {
+  kind: 'id';
+  pattern: StringOrRegExp;
+  params: IdParams;
+  constructor(pattern: StringOrRegExp, params?: IdParams);
+}
+declare class ImporterId {
+  kind: 'importerId';
+  pattern: StringOrRegExp;
+  params: IdParams;
+  constructor(pattern: StringOrRegExp, params?: IdParams);
+}
+declare class ModuleType {
+  kind: 'moduleType';
+  pattern: PluginModuleType;
+  constructor(pattern: PluginModuleType);
+}
+declare class Code {
+  kind: 'code';
+  pattern: StringOrRegExp;
+  constructor(expr: StringOrRegExp);
+}
+declare class Query {
+  kind: 'query';
+  key: string;
+  pattern: StringOrRegExp | boolean;
+  constructor(key: string, pattern: StringOrRegExp | boolean);
+}
+declare class Include {
+  kind: 'include';
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare class Exclude {
+  kind: 'exclude';
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare function and(...args: FilterExpression[]): And;
+declare function or(...args: FilterExpression[]): Or;
+declare function not(expr: FilterExpression): Not;
+declare function id(pattern: StringOrRegExp, params?: IdParams): Id;
+declare function importerId(pattern: StringOrRegExp, params?: IdParams): ImporterId;
+declare function moduleType(pattern: PluginModuleType): ModuleType;
+declare function code(pattern: StringOrRegExp): Code;
+declare function query(key: string, pattern: StringOrRegExp | boolean): Query;
+declare function include(expr: FilterExpression): Include;
+declare function exclude(expr: FilterExpression): Exclude;
+/**
+ * convert a queryObject to FilterExpression like
+ * ```js
+ *   and(query(k1, v1), query(k2, v2))
+ * ```
+ * @param queryFilterObject The query filter object needs to be matched.
+ * @returns a `And` FilterExpression
+ */
+declare function queries(queryFilter: QueryFilterObject): And;
+declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string): boolean;
+interface InterpreterCtx {
+  urlSearchParamsCache?: URLSearchParams;
+}
+declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
+declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
+//#endregion
+//#region ../../node_modules/.pnpm/@rolldown+pluginutils@1.0.0/node_modules/@rolldown/pluginutils/dist/filter/filter-vite-plugins.d.ts
+/**
+ * Filters out Vite plugins that have `apply: 'serve'` set.
+ *
+ * Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
+ * are intended only for Vite's dev server and should be excluded from the build process.
+ *
+ * @param plugins - Array of plugins (can include nested arrays)
+ * @returns Filtered array with serve-only plugins removed
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'rolldown';
+ * import { filterVitePlugins } from '@rolldown/pluginutils';
+ * import viteReact from '@vitejs/plugin-react';
+ *
+ * export default defineConfig({
+ *   plugins: filterVitePlugins([
+ *     viteReact(),
+ *     {
+ *       name: 'dev-only',
+ *       apply: 'serve', // This will be filtered out
+ *       // ...
+ *     }
+ *   ])
+ * });
+ * ```
+ */
+declare function filterVitePlugins<T = any>(plugins: T | T[] | null | undefined | false): T[];
+//#endregion
+//#region ../../node_modules/.pnpm/@rolldown+pluginutils@1.0.0/node_modules/@rolldown/pluginutils/dist/filter/simple-filters.d.ts
+/**
+ * Constructs a RegExp that matches the exact string specified.
+ *
+ * This is useful for plugin hook filters.
+ *
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ *
+ * @example
+ * ```ts
+ * import { exactRegex } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   resolveId: {
+ *     filter: { id: exactRegex('foo') },
+ *     handler(id) {} // will only be called for `foo`
+ *   }
+ * }
+ * ```
+ */
+declare function exactRegex(str: string, flags?: string): RegExp;
+/**
+ * Constructs a RegExp that matches a value that has the specified prefix.
+ *
+ * This is useful for plugin hook filters.
+ *
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ *
+ * @example
+ * ```ts
+ * import { prefixRegex } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   resolveId: {
+ *     filter: { id: prefixRegex('foo') },
+ *     handler(id) {} // will only be called for IDs starting with `foo`
+ *   }
+ * }
+ * ```
+ */
+declare function prefixRegex(str: string, flags?: string): RegExp;
+type WidenString<T> = T extends string ? string : T;
+/**
+ * Converts a id filter to match with an id with a query.
+ *
+ * @param input the id filters to convert.
+ *
+ * @example
+ * ```ts
+ * import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   transform: {
+ *     filter: { id: makeIdFiltersToMatchWithQuery(['**' + '/*.js', /\.ts$/]) },
+ *     // The handler will be called for IDs like:
+ *     // - foo.js
+ *     // - foo.js?foo
+ *     // - foo.txt?foo.js
+ *     // - foo.ts
+ *     // - foo.ts?foo
+ *     // - foo.txt?foo.ts
+ *     handler(code, id) {}
+ *   }
+ * }
+ * ```
+ */
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: T): WidenString<T>;
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: readonly T[]): WidenString<T>[];
+declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[];
+//#endregion
+export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query, withFilter };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/filter-index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/filter-index.mjs
new file mode 100644
index 0000000..4c309e8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/filter-index.mjs
@@ -0,0 +1,386 @@
+import { n as isPromiseLike, t as arraify } from "./shared/misc-DJYbNKZX.mjs";
+//#region ../../node_modules/.pnpm/@rolldown+pluginutils@1.0.0/node_modules/@rolldown/pluginutils/dist/utils.js
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function extractQueryWithoutFragment(url) {
+	const questionMarkIndex = url.indexOf("?");
+	if (questionMarkIndex === -1) return "";
+	const fragmentIndex = url.indexOf("#", questionMarkIndex);
+	if (fragmentIndex === -1) return url.substring(questionMarkIndex);
+	else return url.substring(questionMarkIndex, fragmentIndex);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@rolldown+pluginutils@1.0.0/node_modules/@rolldown/pluginutils/dist/filter/composable-filters.js
+var And = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`And` expects at least one operand");
+		this.args = args;
+		this.kind = "and";
+	}
+};
+var Or = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`Or` expects at least one operand");
+		this.args = args;
+		this.kind = "or";
+	}
+};
+var Not = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "not";
+	}
+};
+var Id = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "id";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ImporterId = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "importerId";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ModuleType = class {
+	kind;
+	pattern;
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.kind = "moduleType";
+	}
+};
+var Code = class {
+	kind;
+	pattern;
+	constructor(expr) {
+		this.pattern = expr;
+		this.kind = "code";
+	}
+};
+var Query = class {
+	kind;
+	key;
+	pattern;
+	constructor(key, pattern) {
+		this.pattern = pattern;
+		this.key = key;
+		this.kind = "query";
+	}
+};
+var Include = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "include";
+	}
+};
+var Exclude = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "exclude";
+	}
+};
+function and(...args) {
+	return new And(...args);
+}
+function or(...args) {
+	return new Or(...args);
+}
+function not(expr) {
+	return new Not(expr);
+}
+function id(pattern, params) {
+	return new Id(pattern, params);
+}
+function importerId(pattern, params) {
+	return new ImporterId(pattern, params);
+}
+function moduleType(pattern) {
+	return new ModuleType(pattern);
+}
+function code(pattern) {
+	return new Code(pattern);
+}
+function query(key, pattern) {
+	return new Query(key, pattern);
+}
+function include(expr) {
+	return new Include(expr);
+}
+function exclude(expr) {
+	return new Exclude(expr);
+}
+/**
+* convert a queryObject to FilterExpression like
+* ```js
+*   and(query(k1, v1), query(k2, v2))
+* ```
+* @param queryFilterObject The query filter object needs to be matched.
+* @returns a `And` FilterExpression
+*/
+function queries(queryFilter) {
+	return and(...Object.entries(queryFilter).map(([key, value]) => {
+		return new Query(key, value);
+	}));
+}
+function interpreter(exprs, code, id, moduleType, importerId) {
+	let arr = [];
+	if (Array.isArray(exprs)) arr = exprs;
+	else arr = [exprs];
+	return interpreterImpl(arr, code, id, moduleType, importerId);
+}
+function interpreterImpl(expr, code, id, moduleType, importerId, ctx = {}) {
+	let hasInclude = false;
+	for (const e of expr) switch (e.kind) {
+		case "include":
+			hasInclude = true;
+			if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return true;
+			break;
+		case "exclude":
+			if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return false;
+			break;
+	}
+	return !hasInclude;
+}
+function exprInterpreter(expr, code, id, moduleType, importerId, ctx = {}) {
+	switch (expr.kind) {
+		case "and": return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "or": return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "not": return !exprInterpreter(expr.expr, code, id, moduleType, importerId, ctx);
+		case "id": {
+			if (id === void 0) throw new Error("`id` is required for `id` expression");
+			let idToMatch = id;
+			if (expr.params.cleanUrl) idToMatch = cleanUrl(idToMatch);
+			return typeof expr.pattern === "string" ? idToMatch === expr.pattern : expr.pattern.test(idToMatch);
+		}
+		case "importerId": {
+			if (importerId === void 0) return false;
+			let importerIdToMatch = importerId;
+			if (expr.params.cleanUrl) importerIdToMatch = cleanUrl(importerIdToMatch);
+			return typeof expr.pattern === "string" ? importerIdToMatch === expr.pattern : expr.pattern.test(importerIdToMatch);
+		}
+		case "moduleType":
+			if (moduleType === void 0) throw new Error("`moduleType` is required for `moduleType` expression");
+			return moduleType === expr.pattern;
+		case "code":
+			if (code === void 0) throw new Error("`code` is required for `code` expression");
+			return typeof expr.pattern === "string" ? code.includes(expr.pattern) : expr.pattern.test(code);
+		case "query": {
+			if (id === void 0) throw new Error("`id` is required for `Query` expression");
+			if (!ctx.urlSearchParamsCache) {
+				let queryString = extractQueryWithoutFragment(id);
+				ctx.urlSearchParamsCache = new URLSearchParams(queryString);
+			}
+			let urlParams = ctx.urlSearchParamsCache;
+			if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key);
+			else return !urlParams.has(expr.key);
+			else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern;
+			else return expr.pattern.test(urlParams.get(expr.key) ?? "");
+		}
+		default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@rolldown+pluginutils@1.0.0/node_modules/@rolldown/pluginutils/dist/filter/filter-vite-plugins.js
+/**
+* Filters out Vite plugins that have `apply: 'serve'` set.
+*
+* Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
+* are intended only for Vite's dev server and should be excluded from the build process.
+*
+* @param plugins - Array of plugins (can include nested arrays)
+* @returns Filtered array with serve-only plugins removed
+*
+* @example
+* ```ts
+* import { defineConfig } from 'rolldown';
+* import { filterVitePlugins } from '@rolldown/pluginutils';
+* import viteReact from '@vitejs/plugin-react';
+*
+* export default defineConfig({
+*   plugins: filterVitePlugins([
+*     viteReact(),
+*     {
+*       name: 'dev-only',
+*       apply: 'serve', // This will be filtered out
+*       // ...
+*     }
+*   ])
+* });
+* ```
+*/
+function filterVitePlugins(plugins) {
+	if (!plugins) return [];
+	const pluginArray = Array.isArray(plugins) ? plugins : [plugins];
+	const result = [];
+	for (const plugin of pluginArray) {
+		if (!plugin) continue;
+		if (Array.isArray(plugin)) {
+			result.push(...filterVitePlugins(plugin));
+			continue;
+		}
+		const pluginWithApply = plugin;
+		if ("apply" in pluginWithApply) {
+			const applyValue = pluginWithApply.apply;
+			if (typeof applyValue === "function") try {
+				if (applyValue({}, {
+					command: "build",
+					mode: "production"
+				})) result.push(plugin);
+			} catch {
+				result.push(plugin);
+			}
+			else if (applyValue === "serve") continue;
+			else result.push(plugin);
+		} else result.push(plugin);
+	}
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@rolldown+pluginutils@1.0.0/node_modules/@rolldown/pluginutils/dist/filter/simple-filters.js
+/**
+* Constructs a RegExp that matches the exact string specified.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*
+* @example
+* ```ts
+* import { exactRegex } from '@rolldown/pluginutils';
+* const plugin = {
+*   name: 'plugin',
+*   resolveId: {
+*     filter: { id: exactRegex('foo') },
+*     handler(id) {} // will only be called for `foo`
+*   }
+* }
+* ```
+*/
+function exactRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}$`, flags);
+}
+/**
+* Constructs a RegExp that matches a value that has the specified prefix.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*
+* @example
+* ```ts
+* import { prefixRegex } from '@rolldown/pluginutils';
+* const plugin = {
+*   name: 'plugin',
+*   resolveId: {
+*     filter: { id: prefixRegex('foo') },
+*     handler(id) {} // will only be called for IDs starting with `foo`
+*   }
+* }
+* ```
+*/
+function prefixRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+	return str.replace(escapeRegexRE, "\\$&");
+}
+function makeIdFiltersToMatchWithQuery(input) {
+	if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input);
+	return input.map((i) => makeIdFilterToMatchWithQuery(i));
+}
+function makeIdFilterToMatchWithQuery(input) {
+	if (typeof input === "string") return `${input}{?*,}`;
+	return makeRegexIdFilterToMatchWithQuery(input);
+}
+function makeRegexIdFilterToMatchWithQuery(input) {
+	return new RegExp(input.source.replace(/(?<!\\)\$/g, "(?:\\?.*)?$"), input.flags);
+}
+//#endregion
+//#region src/plugin/with-filter.ts
+function withFilterImpl(pluginOption, filterObjectList) {
+	if (isPromiseLike(pluginOption)) return pluginOption.then((p) => withFilter(p, filterObjectList));
+	if (pluginOption == false || pluginOption == null) return pluginOption;
+	if (Array.isArray(pluginOption)) return pluginOption.map((p) => withFilter(p, filterObjectList));
+	let plugin = pluginOption;
+	let filterObjectIndex = findMatchedFilterObject(plugin.name, filterObjectList);
+	if (filterObjectIndex === -1) return plugin;
+	let filterObject = filterObjectList[filterObjectIndex];
+	Object.keys(plugin).forEach((key) => {
+		switch (key) {
+			case "transform":
+			case "resolveId":
+			case "load":
+				if (!plugin[key]) return;
+				if (typeof plugin[key] === "object") plugin[key].filter = filterObject[key] ?? plugin[key].filter;
+				else plugin[key] = {
+					handler: plugin[key],
+					filter: filterObject[key]
+				};
+				break;
+			default: break;
+		}
+	});
+	return plugin;
+}
+/**
+* A helper function to add plugin hook filters to a plugin or an array of plugins.
+*
+* @example
+* ```ts
+* import yaml from '@rollup/plugin-yaml';
+* import { defineConfig } from 'rolldown';
+* import { withFilter } from 'rolldown/filter';
+*
+* export default defineConfig({
+*   plugins: [
+*     // Run the transform hook of the `yaml` plugin
+*     // only for modules which end in `.yaml`
+*     withFilter(
+*       yaml({}),
+*       { transform: { id: /\.yaml$/ } },
+*     ),
+*   ],
+* });
+* ```
+*
+* @category Config
+*/
+function withFilter(pluginOption, filterObject) {
+	return withFilterImpl(pluginOption, arraify(filterObject));
+}
+function findMatchedFilterObject(pluginName, overrideFilterObjectList) {
+	if (overrideFilterObjectList.length === 1 && overrideFilterObjectList[0].pluginNamePattern === void 0) return 0;
+	for (let i = 0; i < overrideFilterObjectList.length; i++) for (let j = 0; j < (overrideFilterObjectList[i].pluginNamePattern ?? []).length; j++) {
+		let pattern = overrideFilterObjectList[i].pluginNamePattern[j];
+		if (typeof pattern === "string" && pattern === pluginName) return i;
+		else if (pattern instanceof RegExp && pattern.test(pluginName)) return i;
+	}
+	return -1;
+}
+//#endregion
+export { and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query, withFilter };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/get-log-filter.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/get-log-filter.d.mts
new file mode 100644
index 0000000..f42b91d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/get-log-filter.d.mts
@@ -0,0 +1,3 @@
+import { a as RolldownLog } from "./shared/logging-C6h4g8dA.mjs";
+import { n as getLogFilter, t as GetLogFilter } from "./shared/get-log-filter-semyr3Lj.mjs";
+export { GetLogFilter, RolldownLog, RolldownLog as RollupLog, getLogFilter as default };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/get-log-filter.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/get-log-filter.mjs
new file mode 100644
index 0000000..802927c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/get-log-filter.mjs
@@ -0,0 +1,68 @@
+//#region src/get-log-filter.ts
+/**
+* A helper function to generate log filters using the same syntax as the CLI.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'rolldown';
+* import { getLogFilter } from 'rolldown/getLogFilter';
+*
+* const logFilter = getLogFilter(['code:FOO', 'code:BAR']);
+*
+* export default defineConfig({
+* 	input: 'main.js',
+* 	onLog(level, log, handler) {
+* 		if (logFilter(log)) {
+* 			handler(level, log);
+* 		}
+* 	}
+* });
+* ```
+*
+* @category Config
+*/
+const getLogFilter = (filters) => {
+	if (filters.length === 0) return () => true;
+	const normalizedFilters = filters.map((filter) => filter.split("&").map((subFilter) => {
+		const inverted = subFilter.startsWith("!");
+		if (inverted) subFilter = subFilter.slice(1);
+		const [key, ...value] = subFilter.split(":");
+		return {
+			inverted,
+			key: key.split("."),
+			parts: value.join(":").split("*")
+		};
+	}));
+	return (log) => {
+		nextIntersectedFilter: for (const intersectedFilters of normalizedFilters) {
+			for (const { inverted, key, parts } of intersectedFilters) {
+				const isFilterSatisfied = testFilter(log, key, parts);
+				if (inverted ? isFilterSatisfied : !isFilterSatisfied) continue nextIntersectedFilter;
+			}
+			return true;
+		}
+		return false;
+	};
+};
+const testFilter = (log, key, parts) => {
+	let rawValue = log;
+	for (let index = 0; index < key.length; index++) {
+		if (!rawValue) return false;
+		const part = key[index];
+		if (!(part in rawValue)) return false;
+		rawValue = rawValue[part];
+	}
+	let value = typeof rawValue === "object" ? JSON.stringify(rawValue) : String(rawValue);
+	if (parts.length === 1) return value === parts[0];
+	if (!value.startsWith(parts[0])) return false;
+	const lastPartIndex = parts.length - 1;
+	for (let index = 1; index < lastPartIndex; index++) {
+		const part = parts[index];
+		const position = value.indexOf(part);
+		if (position === -1) return false;
+		value = value.slice(position + part.length);
+	}
+	return value.endsWith(parts[lastPartIndex]);
+};
+//#endregion
+export { getLogFilter as default };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/index.d.mts
new file mode 100644
index 0000000..a483844
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/index.d.mts
@@ -0,0 +1,4 @@
+import { a as RolldownLog, i as RolldownError, n as LogLevelOption, o as RolldownLogWithString, r as LogOrStringHandler, t as LogLevel } from "./shared/logging-C6h4g8dA.mjs";
+import { z as PreRenderedChunk } from "./shared/binding-zH1vcmbM.mjs";
+import { $ as PluginContextMeta, A as RolldownPluginOption, At as CodeSplittingGroup, B as OutputBundle, Bt as PreRenderedAsset, C as ParallelPluginHooks, Ct as build, D as ResolveIdResult, Dt as BuiltinModuleTag, E as ResolveIdExtraOptions, Et as AdvancedChunksOptions, F as RUNTIME_MODULE_ID, Ft as GeneratedCodePreset, G as EmittedFile, Gt as OutputChunk, H as TransformPluginContext, Ht as PartialNull, I as VERSION, It as GlobalsFunction, J as PluginContext, Jt as RolldownOutput, K as EmittedPrebuiltChunk, Kt as RenderedChunk, L as BundleError, Lt as MinifyOptions, M as TransformResult, Mt as CodeSplittingOptions, Nt as CommentsOptions, O as ResolvedId, Ot as ChunkFileNamesFunction, Pt as GeneratedCodeOptions, Q as MinimalPluginContext, Qt as SourcemapIgnoreListOption, R as ExistingRawSourceMap, Rt as ModuleFormat, S as ObjectHook, St as BuildOptions, T as Plugin, Tt as AdvancedChunksGroup, U as EmittedAsset, V as TreeshakingOptions, W as EmittedChunk, Wt as OutputAsset, X as DefineParallelPluginResult, Y as PluginContextResolveOptions, Yt as SourceMap, Zt as ModuleInfo, _ as HookFilterExtension, _t as RolldownWatcherEvent, a as ChunkOptimizationOptions, at as RolldownFileStats, b as ModuleOptions, bt as rolldown, c as InputOption, ct as NormalizedOutputOptions, d as OptimizationOptions, dt as ChecksOptions, et as GeneralHookFilter, f as WatcherFileWatcherOptions, ft as LoggingFunction, g as FunctionPluginHooks, gt as RolldownWatcher, h as CustomPluginOptions, ht as watch, i as RolldownOptions, it as RolldownDirectoryEntry, j as SourceDescription, jt as CodeSplittingNameFunction, k as RolldownPlugin, kt as ChunkingContext, l as InputOptions, lt as NormalizedInputOptions, m as AsyncPluginHooks, mt as RolldownMagicString, n as RolldownOptionsFunction, nt as ModuleTypeFilter, o as ExternalOption, ot as RolldownFsModule, p as WatcherOptions, pt as WarningHandlerWithDefault, q as GetModuleInfo, qt as RenderedModule, r as defineConfig, rt as BufferEncoding, s as ExternalOptionFunction, st as InternalModuleFormat, t as ConfigExport, tt as HookFilter, u as ModuleTypes, ut as TransformOptions, v as ImportKind, vt as RolldownWatcherWatcherEventMap, w as PartialResolvedId, wt as AddonFunction, x as ModuleType, xt as RolldownBuild, y as LoadResult, yt as WatchOptions, z as SourceMapInput, zt as OutputOptions } from "./shared/define-config-CeKzMIcs.mjs";
+export { AddonFunction, AdvancedChunksGroup, AdvancedChunksOptions, AsyncPluginHooks, BufferEncoding, BuildOptions, BuiltinModuleTag, BundleError, ChecksOptions, ChunkFileNamesFunction, ChunkOptimizationOptions, ChunkingContext, CodeSplittingGroup, CodeSplittingNameFunction, CodeSplittingOptions, CommentsOptions, ConfigExport, CustomPluginOptions, DefineParallelPluginResult, EmittedAsset, EmittedChunk, EmittedFile, EmittedPrebuiltChunk, ExistingRawSourceMap, ExternalOption, ExternalOptionFunction, FunctionPluginHooks, GeneralHookFilter, GeneratedCodeOptions, GeneratedCodePreset, GetModuleInfo, GlobalsFunction, HookFilter, HookFilterExtension, ImportKind, InputOption, InputOptions, InternalModuleFormat, LoadResult, LogLevel, LogLevelOption, LogOrStringHandler, LoggingFunction, MinifyOptions, MinimalPluginContext, ModuleFormat, ModuleInfo, ModuleOptions, ModuleType, ModuleTypeFilter, ModuleTypes, NormalizedInputOptions, NormalizedOutputOptions, ObjectHook, OptimizationOptions, OutputAsset, OutputBundle, OutputChunk, OutputOptions, ParallelPluginHooks, PartialNull, PartialResolvedId, Plugin, PluginContext, PluginContextMeta, PluginContextResolveOptions, PreRenderedAsset, PreRenderedChunk, RUNTIME_MODULE_ID, RenderedChunk, RenderedModule, ResolveIdExtraOptions, ResolveIdResult, ResolvedId, RolldownBuild, RolldownDirectoryEntry, RolldownError, RolldownError as RollupError, RolldownFileStats, RolldownFsModule, RolldownLog, RolldownLog as RollupLog, RolldownLogWithString, RolldownLogWithString as RollupLogWithString, RolldownMagicString, RolldownOptions, RolldownOptionsFunction, RolldownOutput, RolldownPlugin, RolldownPluginOption, RolldownWatcher, RolldownWatcherEvent, RolldownWatcherWatcherEventMap, SourceDescription, SourceMap, SourceMapInput, SourcemapIgnoreListOption, TransformOptions, TransformPluginContext, TransformResult, TreeshakingOptions, VERSION, WarningHandlerWithDefault, WatchOptions, WatcherFileWatcherOptions, WatcherOptions, build, defineConfig, rolldown, watch };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/index.mjs
new file mode 100644
index 0000000..9be03e7
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/index.mjs
@@ -0,0 +1,50 @@
+import { n as __toESM, t as require_binding } from "./shared/binding-C9S351wt.mjs";
+import { n as onExit, t as watch } from "./shared/watch-RBs0UNYA.mjs";
+import { a as RolldownMagicString, b as RUNTIME_MODULE_ID, x as VERSION } from "./shared/bindingify-input-options-BnfFBV6b.mjs";
+import { t as rolldown } from "./shared/rolldown-CWsV1rrO.mjs";
+import { t as defineConfig } from "./shared/define-config-DJOr6Iwt.mjs";
+import { isMainThread } from "node:worker_threads";
+//#region src/setup.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+if (isMainThread) {
+	const subscriberGuard = (0, import_binding.initTraceSubscriber)();
+	onExit(() => {
+		subscriberGuard?.close();
+	});
+}
+//#endregion
+//#region src/api/build.ts
+/**
+* The API similar to esbuild's `build` function.
+*
+* @example
+* ```js
+* import { build } from 'rolldown';
+*
+* const result = await build({
+*   input: 'src/main.js',
+*   output: {
+*     file: 'bundle.js',
+*   },
+* });
+* console.log(result);
+* ```
+*
+* @experimental
+* @category Programmatic APIs
+*/
+async function build(options) {
+	if (Array.isArray(options)) return Promise.all(options.map((opts) => build(opts)));
+	else {
+		const { output, write = true, ...inputOptions } = options;
+		const build = await rolldown(inputOptions);
+		try {
+			if (write) return await build.write(output);
+			else return await build.generate(output);
+		} finally {
+			await build.close();
+		}
+	}
+}
+//#endregion
+export { RUNTIME_MODULE_ID, RolldownMagicString, VERSION, build, defineConfig, rolldown, watch };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin-worker.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin-worker.d.mts
new file mode 100644
index 0000000..619fbdd
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin-worker.d.mts
@@ -0,0 +1 @@
+export { };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin-worker.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin-worker.mjs
new file mode 100644
index 0000000..fcc85f6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin-worker.mjs
@@ -0,0 +1,28 @@
+import { n as __toESM, t as require_binding } from "./shared/binding-C9S351wt.mjs";
+import { n as PluginContextData, r as bindingifyPlugin } from "./shared/bindingify-input-options-BnfFBV6b.mjs";
+import { parentPort, workerData } from "node:worker_threads";
+//#region src/parallel-plugin-worker.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+const { registryId, pluginInfos, threadNumber } = workerData;
+(async () => {
+	try {
+		(0, import_binding.registerPlugins)(registryId, await Promise.all(pluginInfos.map(async (pluginInfo) => {
+			const definePluginImpl = (await import(pluginInfo.fileUrl)).default;
+			const plugin = await definePluginImpl(pluginInfo.options, { threadNumber });
+			return {
+				index: pluginInfo.index,
+				plugin: bindingifyPlugin(plugin, {}, {}, new PluginContextData(() => {}, {}, [], []), [], () => {}, "info", false)
+			};
+		})));
+		parentPort.postMessage({ type: "success" });
+	} catch (error) {
+		parentPort.postMessage({
+			type: "error",
+			error
+		});
+	} finally {
+		parentPort.unref();
+	}
+})();
+//#endregion
+export {};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin.d.mts
new file mode 100644
index 0000000..9155790
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin.d.mts
@@ -0,0 +1,13 @@
+import { T as Plugin, Vt as MaybePromise } from "./shared/define-config-CeKzMIcs.mjs";
+
+//#region src/plugin/parallel-plugin-implementation.d.ts
+type ParallelPluginImplementation = Plugin;
+type Context = {
+  /**
+  * Thread number
+  */
+  threadNumber: number;
+};
+declare function defineParallelPluginImplementation<Options>(plugin: (Options: Options, context: Context) => MaybePromise<ParallelPluginImplementation>): (Options: Options, context: Context) => MaybePromise<ParallelPluginImplementation>;
+//#endregion
+export { type Context, type ParallelPluginImplementation, defineParallelPluginImplementation };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin.mjs
new file mode 100644
index 0000000..488aeec
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parallel-plugin.mjs
@@ -0,0 +1,6 @@
+//#region src/plugin/parallel-plugin-implementation.ts
+function defineParallelPluginImplementation(plugin) {
+	return plugin;
+}
+//#endregion
+export { defineParallelPluginImplementation };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parse-ast-index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parse-ast-index.d.mts
new file mode 100644
index 0000000..1b00a3f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parse-ast-index.d.mts
@@ -0,0 +1,32 @@
+import { L as ParseResult$1, R as ParserOptions$1 } from "./shared/binding-zH1vcmbM.mjs";
+import { Program } from "@oxc-project/types";
+
+//#region src/parse-ast-index.d.ts
+/**
+* @hidden
+*/
+type ParseResult = ParseResult$1;
+/**
+* @hidden
+*/
+type ParserOptions = ParserOptions$1;
+/**
+* Parse code synchronously and return the AST.
+*
+* This function is similar to Rollup's `parseAst` function.
+* Prefer using {@linkcode parseSync} instead of this function as it has more information in the return value.
+*
+* @category Utilities
+*/
+declare function parseAst(sourceText: string, options?: ParserOptions | null, filename?: string): Program;
+/**
+* Parse code asynchronously and return the AST.
+*
+* This function is similar to Rollup's `parseAstAsync` function.
+* Prefer using {@linkcode parseAsync} instead of this function as it has more information in the return value.
+*
+* @category Utilities
+*/
+declare function parseAstAsync(sourceText: string, options?: ParserOptions | null, filename?: string): Promise<Program>;
+//#endregion
+export { ParseResult, ParserOptions, parseAst, parseAstAsync };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parse-ast-index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parse-ast-index.mjs
new file mode 100644
index 0000000..dbcd853
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/parse-ast-index.mjs
@@ -0,0 +1,60 @@
+import { l as locate, n as error, s as logParseError, t as augmentCodeLocation, u as getCodeFrame } from "./shared/logs-D80CXhvg.mjs";
+import { n as parseSync, t as parse } from "./shared/parse-Ch28GO2f.mjs";
+//#region src/parse-ast-index.ts
+function wrap(result, filename, sourceText) {
+	if (result.errors.length > 0) return normalizeParseError(filename, sourceText, result.errors);
+	return result.program;
+}
+function normalizeParseError(filename, sourceText, errors) {
+	let message = `Parse failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
+	const pos = errors[0]?.labels?.[0]?.start;
+	for (let i = 0; i < errors.length; i++) {
+		if (i >= 5) {
+			message += "\n...";
+			break;
+		}
+		const e = errors[i];
+		message += e.message + "\n" + e.labels.map((label) => {
+			const location = locate(sourceText, label.start, { offsetLine: 1 });
+			if (!location) return;
+			return getCodeFrame(sourceText, location.line, location.column);
+		}).filter(Boolean).join("\n");
+	}
+	const log = logParseError(message, filename, pos);
+	if (pos !== void 0 && filename) augmentCodeLocation(log, pos, sourceText, filename);
+	return error(log);
+}
+const defaultParserOptions = {
+	lang: "js",
+	preserveParens: false
+};
+/**
+* Parse code synchronously and return the AST.
+*
+* This function is similar to Rollup's `parseAst` function.
+* Prefer using {@linkcode parseSync} instead of this function as it has more information in the return value.
+*
+* @category Utilities
+*/
+function parseAst(sourceText, options, filename) {
+	return wrap(parseSync(filename ?? "file.js", sourceText, {
+		...defaultParserOptions,
+		...options
+	}), filename, sourceText);
+}
+/**
+* Parse code asynchronously and return the AST.
+*
+* This function is similar to Rollup's `parseAstAsync` function.
+* Prefer using {@linkcode parseAsync} instead of this function as it has more information in the return value.
+*
+* @category Utilities
+*/
+async function parseAstAsync(sourceText, options, filename) {
+	return wrap(await parse(filename ?? "file.js", sourceText, {
+		...defaultParserOptions,
+		...options
+	}), filename, sourceText);
+}
+//#endregion
+export { parseAst, parseAstAsync };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/plugins-index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/plugins-index.d.mts
new file mode 100644
index 0000000..fc3db0a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/plugins-index.d.mts
@@ -0,0 +1,33 @@
+import { m as BindingReplacePluginConfig } from "./shared/binding-zH1vcmbM.mjs";
+import { P as BuiltinPlugin } from "./shared/define-config-CeKzMIcs.mjs";
+import { t as esmExternalRequirePlugin } from "./shared/constructors-DAnSz-_I.mjs";
+
+//#region src/builtin-plugin/replace-plugin.d.ts
+/**
+* Replaces targeted strings in files while bundling.
+*
+* @example
+* **Basic usage**
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*    __buildVersion: 15
+* })
+* ```
+* @example
+* **With options**
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*   __buildVersion: 15
+* }, {
+*   preventAssignment: false,
+* })
+* ```
+*
+* @see https://rolldown.rs/builtin-plugins/replace
+* @category Builtin Plugins
+*/
+declare function replacePlugin(values?: BindingReplacePluginConfig["values"], options?: Omit<BindingReplacePluginConfig, "values">): BuiltinPlugin;
+//#endregion
+export { esmExternalRequirePlugin, replacePlugin };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/plugins-index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/plugins-index.mjs
new file mode 100644
index 0000000..a7d879b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/plugins-index.mjs
@@ -0,0 +1,40 @@
+import { a as makeBuiltinPluginCallable, n as BuiltinPlugin } from "./shared/normalize-string-or-regex-C-WttzRA.mjs";
+import { t as esmExternalRequirePlugin } from "./shared/constructors-Ciqn_yS7.mjs";
+//#region src/builtin-plugin/replace-plugin.ts
+/**
+* Replaces targeted strings in files while bundling.
+*
+* @example
+* **Basic usage**
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*    __buildVersion: 15
+* })
+* ```
+* @example
+* **With options**
+* ```js
+* replacePlugin({
+*   'process.env.NODE_ENV': JSON.stringify('production'),
+*   __buildVersion: 15
+* }, {
+*   preventAssignment: false,
+* })
+* ```
+*
+* @see https://rolldown.rs/builtin-plugins/replace
+* @category Builtin Plugins
+*/
+function replacePlugin(values = {}, options = {}) {
+	Object.keys(values).forEach((key) => {
+		const value = values[key];
+		if (typeof value !== "string") values[key] = String(value);
+	});
+	return makeBuiltinPluginCallable(new BuiltinPlugin("builtin:replace", {
+		...options,
+		values
+	}));
+}
+//#endregion
+export { esmExternalRequirePlugin, replacePlugin };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/binding-C9S351wt.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/binding-C9S351wt.mjs
new file mode 100644
index 0000000..1dacec9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/binding-C9S351wt.mjs
@@ -0,0 +1,582 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/webcontainer-fallback.cjs
+var require_webcontainer_fallback = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("node:fs");
+	const childProcess = __require("node:child_process");
+	const version = JSON.parse(fs.readFileSync(__require.resolve("rolldown/package.json"), "utf-8")).version;
+	const baseDir = `/tmp/rolldown-${version}`;
+	const bindingEntry = `${baseDir}/node_modules/@rolldown/binding-wasm32-wasi/rolldown-binding.wasi.cjs`;
+	if (!fs.existsSync(bindingEntry)) {
+		const bindingPkg = `@rolldown/binding-wasm32-wasi@${version}`;
+		fs.rmSync(baseDir, {
+			recursive: true,
+			force: true
+		});
+		fs.mkdirSync(baseDir, { recursive: true });
+		console.log(`[rolldown] Downloading ${bindingPkg} on WebContainer...`);
+		childProcess.execFileSync("pnpm", ["i", bindingPkg], {
+			cwd: baseDir,
+			stdio: "inherit"
+		});
+	}
+	module.exports = __require(bindingEntry);
+}));
+//#endregion
+//#region src/binding.cjs
+var require_binding = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { readFileSync } = __require("node:fs");
+	let nativeBinding = null;
+	const loadErrors = [];
+	const isMusl = () => {
+		let musl = false;
+		if (process.platform === "linux") {
+			musl = isMuslFromFilesystem();
+			if (musl === null) musl = isMuslFromReport();
+			if (musl === null) musl = isMuslFromChildProcess();
+		}
+		return musl;
+	};
+	const isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+	const isMuslFromFilesystem = () => {
+		try {
+			return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+		} catch {
+			return null;
+		}
+	};
+	const isMuslFromReport = () => {
+		let report = null;
+		if (typeof process.report?.getReport === "function") {
+			process.report.excludeNetwork = true;
+			report = process.report.getReport();
+		}
+		if (!report) return null;
+		if (report.header && report.header.glibcVersionRuntime) return false;
+		if (Array.isArray(report.sharedObjects)) {
+			if (report.sharedObjects.some(isFileMusl)) return true;
+		}
+		return false;
+	};
+	const isMuslFromChildProcess = () => {
+		try {
+			return __require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+		} catch (e) {
+			return false;
+		}
+	};
+	function requireNative() {
+		if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) try {
+			return __require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+		} catch (err) {
+			loadErrors.push(err);
+		}
+		else if (process.platform === "android") if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.android-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-android-arm64");
+				const bindingPackageVersion = __require("@rolldown/binding-android-arm64/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm") {
+			try {
+				return __require("./rolldown-binding.android-arm-eabi.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-android-arm-eabi");
+				const bindingPackageVersion = __require("@rolldown/binding-android-arm-eabi/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on Android ${process.arch}`));
+		else if (process.platform === "win32") if (process.arch === "x64") if (process.config?.variables?.shlib_suffix === "dll.a" || process.config?.variables?.node_target_type === "shared_library") {
+			try {
+				return __require("./rolldown-binding.win32-x64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-win32-x64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-win32-x64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.win32-x64-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-win32-x64-msvc");
+				const bindingPackageVersion = __require("@rolldown/binding-win32-x64-msvc/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "ia32") {
+			try {
+				return __require("./rolldown-binding.win32-ia32-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-win32-ia32-msvc");
+				const bindingPackageVersion = __require("@rolldown/binding-win32-ia32-msvc/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.win32-arm64-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-win32-arm64-msvc");
+				const bindingPackageVersion = __require("@rolldown/binding-win32-arm64-msvc/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on Windows: ${process.arch}`));
+		else if (process.platform === "darwin") {
+			try {
+				return __require("./rolldown-binding.darwin-universal.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-darwin-universal");
+				const bindingPackageVersion = __require("@rolldown/binding-darwin-universal/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			if (process.arch === "x64") {
+				try {
+					return __require("./rolldown-binding.darwin-x64.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = __require("@rolldown/binding-darwin-x64");
+					const bindingPackageVersion = __require("@rolldown/binding-darwin-x64/package.json").version;
+					if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else if (process.arch === "arm64") {
+				try {
+					return __require("./rolldown-binding.darwin-arm64.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = __require("@rolldown/binding-darwin-arm64");
+					const bindingPackageVersion = __require("@rolldown/binding-darwin-arm64/package.json").version;
+					if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on macOS: ${process.arch}`));
+		} else if (process.platform === "freebsd") if (process.arch === "x64") {
+			try {
+				return __require("./rolldown-binding.freebsd-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-freebsd-x64");
+				const bindingPackageVersion = __require("@rolldown/binding-freebsd-x64/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.freebsd-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-freebsd-arm64");
+				const bindingPackageVersion = __require("@rolldown/binding-freebsd-arm64/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+		else if (process.platform === "linux") if (process.arch === "x64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-x64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-x64-musl");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-x64-musl/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("../rolldown-binding.linux-x64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-x64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-x64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "arm64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-arm64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-arm64-musl");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-arm64-musl/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-arm64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-arm64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-arm64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "arm") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-arm-musleabihf.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-arm-musleabihf");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-arm-musleabihf/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-arm-gnueabihf.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-arm-gnueabihf");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-arm-gnueabihf/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "loong64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-loong64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-loong64-musl");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-loong64-musl/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-loong64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-loong64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-loong64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "riscv64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-riscv64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-riscv64-musl");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-riscv64-musl/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-riscv64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-riscv64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-riscv64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "ppc64") {
+			try {
+				return __require("./rolldown-binding.linux-ppc64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-ppc64-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-ppc64-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "s390x") {
+			try {
+				return __require("./rolldown-binding.linux-s390x-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-linux-s390x-gnu");
+				const bindingPackageVersion = __require("@rolldown/binding-linux-s390x-gnu/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on Linux: ${process.arch}`));
+		else if (process.platform === "openharmony") if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.openharmony-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-openharmony-arm64");
+				const bindingPackageVersion = __require("@rolldown/binding-openharmony-arm64/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "x64") {
+			try {
+				return __require("./rolldown-binding.openharmony-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-openharmony-x64");
+				const bindingPackageVersion = __require("@rolldown/binding-openharmony-x64/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm") {
+			try {
+				return __require("./rolldown-binding.openharmony-arm.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = __require("@rolldown/binding-openharmony-arm");
+				const bindingPackageVersion = __require("@rolldown/binding-openharmony-arm/package.json").version;
+				if (bindingPackageVersion !== "1.0.1" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 1.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+		else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+	}
+	nativeBinding = requireNative();
+	if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+		let wasiBinding = null;
+		let wasiBindingError = null;
+		try {
+			wasiBinding = __require("../rolldown-binding.wasi.cjs");
+			nativeBinding = wasiBinding;
+		} catch (err) {
+			if (process.env.NAPI_RS_FORCE_WASI) wasiBindingError = err;
+		}
+		if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) try {
+			wasiBinding = __require("@rolldown/binding-wasm32-wasi");
+			nativeBinding = wasiBinding;
+		} catch (err) {
+			if (process.env.NAPI_RS_FORCE_WASI) {
+				if (!wasiBindingError) wasiBindingError = err;
+				else wasiBindingError.cause = err;
+				loadErrors.push(err);
+			}
+		}
+		if (process.env.NAPI_RS_FORCE_WASI === "error" && !wasiBinding) {
+			const error = /* @__PURE__ */ new Error("WASI binding not found and NAPI_RS_FORCE_WASI is set to error");
+			error.cause = wasiBindingError;
+			throw error;
+		}
+	}
+	if (!nativeBinding && globalThis.process?.versions?.["webcontainer"]) try {
+		nativeBinding = require_webcontainer_fallback();
+	} catch (err) {
+		loadErrors.push(err);
+	}
+	if (!nativeBinding) {
+		if (loadErrors.length > 0) throw new Error("Cannot find native binding. npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). Please try `npm i` again after removing both package-lock.json and node_modules directory.", { cause: loadErrors.reduce((err, cur) => {
+			cur.cause = err;
+			return cur;
+		}) });
+		throw new Error(`Failed to load native binding`);
+	}
+	module.exports = nativeBinding;
+	module.exports.minify = nativeBinding.minify;
+	module.exports.minifySync = nativeBinding.minifySync;
+	module.exports.Severity = nativeBinding.Severity;
+	module.exports.ParseResult = nativeBinding.ParseResult;
+	module.exports.ExportExportNameKind = nativeBinding.ExportExportNameKind;
+	module.exports.ExportImportNameKind = nativeBinding.ExportImportNameKind;
+	module.exports.ExportLocalNameKind = nativeBinding.ExportLocalNameKind;
+	module.exports.ImportNameKind = nativeBinding.ImportNameKind;
+	module.exports.parse = nativeBinding.parse;
+	module.exports.parseSync = nativeBinding.parseSync;
+	module.exports.rawTransferSupported = nativeBinding.rawTransferSupported;
+	module.exports.ResolverFactory = nativeBinding.ResolverFactory;
+	module.exports.EnforceExtension = nativeBinding.EnforceExtension;
+	module.exports.ModuleType = nativeBinding.ModuleType;
+	module.exports.sync = nativeBinding.sync;
+	module.exports.HelperMode = nativeBinding.HelperMode;
+	module.exports.isolatedDeclaration = nativeBinding.isolatedDeclaration;
+	module.exports.isolatedDeclarationSync = nativeBinding.isolatedDeclarationSync;
+	module.exports.moduleRunnerTransform = nativeBinding.moduleRunnerTransform;
+	module.exports.moduleRunnerTransformSync = nativeBinding.moduleRunnerTransformSync;
+	module.exports.transform = nativeBinding.transform;
+	module.exports.transformSync = nativeBinding.transformSync;
+	module.exports.BindingBundleEndEventData = nativeBinding.BindingBundleEndEventData;
+	module.exports.BindingBundleErrorEventData = nativeBinding.BindingBundleErrorEventData;
+	module.exports.BindingBundler = nativeBinding.BindingBundler;
+	module.exports.BindingCallableBuiltinPlugin = nativeBinding.BindingCallableBuiltinPlugin;
+	module.exports.BindingChunkingContext = nativeBinding.BindingChunkingContext;
+	module.exports.BindingDecodedMap = nativeBinding.BindingDecodedMap;
+	module.exports.BindingDevEngine = nativeBinding.BindingDevEngine;
+	module.exports.BindingLoadPluginContext = nativeBinding.BindingLoadPluginContext;
+	module.exports.BindingMagicString = nativeBinding.BindingMagicString;
+	module.exports.BindingModuleInfo = nativeBinding.BindingModuleInfo;
+	module.exports.BindingNormalizedOptions = nativeBinding.BindingNormalizedOptions;
+	module.exports.BindingOutputAsset = nativeBinding.BindingOutputAsset;
+	module.exports.BindingOutputChunk = nativeBinding.BindingOutputChunk;
+	module.exports.BindingPluginContext = nativeBinding.BindingPluginContext;
+	module.exports.BindingRenderedChunk = nativeBinding.BindingRenderedChunk;
+	module.exports.BindingRenderedChunkMeta = nativeBinding.BindingRenderedChunkMeta;
+	module.exports.BindingRenderedModule = nativeBinding.BindingRenderedModule;
+	module.exports.BindingSourceMap = nativeBinding.BindingSourceMap;
+	module.exports.BindingTransformPluginContext = nativeBinding.BindingTransformPluginContext;
+	module.exports.BindingWatcher = nativeBinding.BindingWatcher;
+	module.exports.BindingWatcherBundler = nativeBinding.BindingWatcherBundler;
+	module.exports.BindingWatcherChangeData = nativeBinding.BindingWatcherChangeData;
+	module.exports.BindingWatcherEvent = nativeBinding.BindingWatcherEvent;
+	module.exports.ParallelJsPluginRegistry = nativeBinding.ParallelJsPluginRegistry;
+	module.exports.ScheduledBuild = nativeBinding.ScheduledBuild;
+	module.exports.TraceSubscriberGuard = nativeBinding.TraceSubscriberGuard;
+	module.exports.TsconfigCache = nativeBinding.TsconfigCache;
+	module.exports.BindingAttachDebugInfo = nativeBinding.BindingAttachDebugInfo;
+	module.exports.BindingBuiltinPluginName = nativeBinding.BindingBuiltinPluginName;
+	module.exports.BindingChunkModuleOrderBy = nativeBinding.BindingChunkModuleOrderBy;
+	module.exports.BindingLogLevel = nativeBinding.BindingLogLevel;
+	module.exports.BindingPluginOrder = nativeBinding.BindingPluginOrder;
+	module.exports.BindingPropertyReadSideEffects = nativeBinding.BindingPropertyReadSideEffects;
+	module.exports.BindingPropertyWriteSideEffects = nativeBinding.BindingPropertyWriteSideEffects;
+	module.exports.BindingRebuildStrategy = nativeBinding.BindingRebuildStrategy;
+	module.exports.collapseSourcemaps = nativeBinding.collapseSourcemaps;
+	module.exports.enhancedTransform = nativeBinding.enhancedTransform;
+	module.exports.enhancedTransformSync = nativeBinding.enhancedTransformSync;
+	module.exports.FilterTokenKind = nativeBinding.FilterTokenKind;
+	module.exports.initTraceSubscriber = nativeBinding.initTraceSubscriber;
+	module.exports.registerPlugins = nativeBinding.registerPlugins;
+	module.exports.resolveTsconfig = nativeBinding.resolveTsconfig;
+	module.exports.shutdownAsyncRuntime = nativeBinding.shutdownAsyncRuntime;
+	module.exports.startAsyncRuntime = nativeBinding.startAsyncRuntime;
+}));
+//#endregion
+export { __toESM as n, require_binding as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/binding-zH1vcmbM.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/binding-zH1vcmbM.d.mts
new file mode 100644
index 0000000..1412cad
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/binding-zH1vcmbM.d.mts
@@ -0,0 +1,1899 @@
+import * as _$_oxc_project_types0 from "@oxc-project/types";
+
+//#region src/binding.d.cts
+type MaybePromise<T> = T | Promise<T>;
+type VoidNullable<T = void> = T | null | undefined | void;
+type BindingStringOrRegex = string | RegExp;
+interface CodegenOptions {
+  /**
+   * Remove whitespace.
+   *
+   * @default true
+   */
+  removeWhitespace?: boolean;
+}
+interface CompressOptions {
+  /**
+   * Set desired EcmaScript standard version for output.
+   *
+   * Set `esnext` to enable all target highering.
+   *
+   * Example:
+   *
+   * * `'es2015'`
+   * * `['es2020', 'chrome58', 'edge16', 'firefox57', 'node12', 'safari11']`
+   *
+   * @default 'esnext'
+   *
+   * @see [esbuild#target](https://esbuild.github.io/api/#target)
+   */
+  target?: string | Array<string>;
+  /**
+   * Pass true to discard calls to `console.*`.
+   *
+   * @default false
+   */
+  dropConsole?: boolean;
+  /**
+   * Remove `debugger;` statements.
+   *
+   * @default true
+   */
+  dropDebugger?: boolean;
+  /**
+   * Pass `true` to drop unreferenced functions and variables.
+   *
+   * Simple direct variable assignments do not count as references unless set to `keep_assign`.
+   * @default true
+   */
+  unused?: boolean | 'keep_assign';
+  /** Keep function / class names. */
+  keepNames?: CompressOptionsKeepNames;
+  /**
+   * Join consecutive var, let and const statements.
+   *
+   * @default true
+   */
+  joinVars?: boolean;
+  /**
+   * Join consecutive simple statements using the comma operator.
+   *
+   * `a; b` -> `a, b`
+   *
+   * @default true
+   */
+  sequences?: boolean;
+  /**
+   * Set of label names to drop from the code.
+   *
+   * Labeled statements matching these names will be removed during minification.
+   *
+   * @default []
+   */
+  dropLabels?: Array<string>;
+  /** Limit the maximum number of iterations for debugging purpose. */
+  maxIterations?: number;
+  /** Treeshake options. */
+  treeshake?: TreeShakeOptions;
+}
+interface CompressOptionsKeepNames {
+  /**
+   * Keep function names so that `Function.prototype.name` is preserved.
+   *
+   * This does not guarantee that the `undefined` name is preserved.
+   *
+   * @default false
+   */
+  function: boolean;
+  /**
+   * Keep class names so that `Class.prototype.name` is preserved.
+   *
+   * This does not guarantee that the `undefined` name is preserved.
+   *
+   * @default false
+   */
+  class: boolean;
+}
+interface MangleOptions {
+  /**
+   * Pass `true` to mangle names declared in the top level scope.
+   *
+   * @default true for modules and commonjs, otherwise false
+   */
+  toplevel?: boolean;
+  /**
+   * Preserve `name` property for functions and classes.
+   *
+   * @default false
+   */
+  keepNames?: boolean | MangleOptionsKeepNames;
+  /** Debug mangled names. */
+  debug?: boolean;
+}
+interface MangleOptionsKeepNames {
+  /**
+   * Preserve `name` property for functions.
+   *
+   * @default false
+   */
+  function: boolean;
+  /**
+   * Preserve `name` property for classes.
+   *
+   * @default false
+   */
+  class: boolean;
+}
+interface MinifyOptions {
+  /** Use when minifying an ES module. */
+  module?: boolean;
+  compress?: boolean | CompressOptions;
+  mangle?: boolean | MangleOptions;
+  codegen?: boolean | CodegenOptions;
+  sourcemap?: boolean;
+}
+interface MinifyResult {
+  code: string;
+  map?: SourceMap;
+  errors: Array<OxcError>;
+}
+interface TreeShakeOptions {
+  /**
+   * Whether to respect the pure annotations.
+   *
+   * Pure annotations are comments that mark an expression as pure.
+   * For example: @__PURE__ or #__NO_SIDE_EFFECTS__.
+   *
+   * @default true
+   */
+  annotations?: boolean;
+  /**
+   * Whether to treat this function call as pure.
+   *
+   * This function is called for normal function calls, new calls, and
+   * tagged template calls.
+   */
+  manualPureFunctions?: Array<string>;
+  /**
+   * Whether property read accesses have side effects.
+   *
+   * @default 'always'
+   */
+  propertyReadSideEffects?: boolean | 'always';
+  /**
+   * Whether property write accesses (assignments to member expressions) have side effects.
+   *
+   * When false, assignments like `obj.prop = value` are considered side-effect-free
+   * (assuming the object and value expressions themselves are side-effect-free).
+   *
+   * @default true
+   */
+  propertyWriteSideEffects?: boolean;
+  /**
+   * Whether accessing a global variable has side effects.
+   *
+   * Accessing a non-existing global variable will throw an error.
+   * Global variable may be a getter that has side effects.
+   *
+   * @default true
+   */
+  unknownGlobalSideEffects?: boolean;
+  /**
+   * Whether invalid import statements have side effects.
+   *
+   * Accessing a non-existing import name will throw an error.
+   * Also import statements that cannot be resolved will throw an error.
+   *
+   * @default true
+   */
+  invalidImportSideEffects?: boolean;
+}
+interface Comment {
+  type: 'Line' | 'Block';
+  value: string;
+  start: number;
+  end: number;
+}
+interface ErrorLabel {
+  message: string | null;
+  start: number;
+  end: number;
+}
+interface OxcError {
+  severity: Severity;
+  message: string;
+  labels: Array<ErrorLabel>;
+  helpMessage: string | null;
+  codeframe: string | null;
+}
+type Severity = 'Error' | 'Warning' | 'Advice';
+declare class ParseResult {
+  get program(): _$_oxc_project_types0.Program;
+  get module(): EcmaScriptModule;
+  get comments(): Array<Comment>;
+  get errors(): Array<OxcError>;
+}
+interface DynamicImport {
+  start: number;
+  end: number;
+  moduleRequest: Span;
+}
+interface EcmaScriptModule {
+  /**
+   * Has ESM syntax.
+   *
+   * i.e. `import` and `export` statements, and `import.meta`.
+   *
+   * Dynamic imports `import('foo')` are ignored since they can be used in non-ESM files.
+   */
+  hasModuleSyntax: boolean;
+  /** Import statements. */
+  staticImports: Array<StaticImport>;
+  /** Export statements. */
+  staticExports: Array<StaticExport>;
+  /** Dynamic import expressions. */
+  dynamicImports: Array<DynamicImport>;
+  /** Span positions` of `import.meta` */
+  importMetas: Array<Span>;
+}
+interface ExportExportName {
+  kind: ExportExportNameKind;
+  name: string | null;
+  start: number | null;
+  end: number | null;
+}
+type ExportExportNameKind = /** `export { name } */'Name' | /** `export default expression` */'Default' | /** `export * from "mod" */'None';
+interface ExportImportName {
+  kind: ExportImportNameKind;
+  name: string | null;
+  start: number | null;
+  end: number | null;
+}
+type ExportImportNameKind = /** `export { name } */'Name' | /** `export * as ns from "mod"` */'All' | /** `export * from "mod"` */'AllButDefault' | /** Does not have a specifier. */'None';
+interface ExportLocalName {
+  kind: ExportLocalNameKind;
+  name: string | null;
+  start: number | null;
+  end: number | null;
+}
+type ExportLocalNameKind = /** `export { name } */'Name' | /** `export default expression` */'Default' |
+/**
+ * If the exported value is not locally accessible from within the module.
+ * `export default function () {}`
+ */
+'None';
+interface ImportName {
+  kind: ImportNameKind;
+  name: string | null;
+  start: number | null;
+  end: number | null;
+}
+type ImportNameKind = /** `import { x } from "mod"` */'Name' | /** `import * as ns from "mod"` */'NamespaceObject' | /** `import defaultExport from "mod"` */'Default';
+interface ParserOptions {
+  /** Treat the source text as `js`, `jsx`, `ts`, `tsx` or `dts`. */
+  lang?: 'js' | 'jsx' | 'ts' | 'tsx' | 'dts';
+  /** Treat the source text as `script` or `module` code. */
+  sourceType?: 'script' | 'module' | 'commonjs' | 'unambiguous' | undefined;
+  /**
+   * Return an AST which includes TypeScript-related properties, or excludes them.
+   *
+   * `'js'` is default for JS / JSX files.
+   * `'ts'` is default for TS / TSX files.
+   * The type of the file is determined from `lang` option, or extension of provided `filename`.
+   */
+  astType?: 'js' | 'ts';
+  /**
+   * Controls whether the `range` property is included on AST nodes.
+   * The `range` property is a `[number, number]` which indicates the start/end offsets
+   * of the node in the file contents.
+   *
+   * @default false
+   */
+  range?: boolean;
+  /**
+   * Emit `ParenthesizedExpression` and `TSParenthesizedType` in AST.
+   *
+   * If this option is true, parenthesized expressions are represented by
+   * (non-standard) `ParenthesizedExpression` and `TSParenthesizedType` nodes that
+   * have a single `expression` property containing the expression inside parentheses.
+   *
+   * @default true
+   */
+  preserveParens?: boolean;
+  /**
+   * Produce semantic errors with an additional AST pass.
+   * Semantic errors depend on symbols and scopes, where the parser does not construct.
+   * This adds a small performance overhead.
+   *
+   * @default false
+   */
+  showSemanticErrors?: boolean;
+}
+interface Span {
+  start: number;
+  end: number;
+}
+interface StaticExport {
+  start: number;
+  end: number;
+  entries: Array<StaticExportEntry>;
+}
+interface StaticExportEntry {
+  start: number;
+  end: number;
+  moduleRequest: ValueSpan | null;
+  /** The name under which the desired binding is exported by the module`. */
+  importName: ExportImportName;
+  /** The name used to export this binding by this module. */
+  exportName: ExportExportName;
+  /** The name that is used to locally access the exported value from within the importing module. */
+  localName: ExportLocalName;
+  /**
+   * Whether the export is a TypeScript `export type`.
+   *
+   * Examples:
+   *
+   * ```ts
+   * export type * from 'mod';
+   * export type * as ns from 'mod';
+   * export type { foo };
+   * export { type foo }:
+   * export type { foo } from 'mod';
+   * ```
+   */
+  isType: boolean;
+}
+interface StaticImport {
+  /** Start of import statement. */
+  start: number;
+  /** End of import statement. */
+  end: number;
+  /**
+   * Import source.
+   *
+   * ```js
+   * import { foo } from "mod";
+   * //                   ^^^
+   * ```
+   */
+  moduleRequest: ValueSpan;
+  /**
+   * Import specifiers.
+   *
+   * Empty for `import "mod"`.
+   */
+  entries: Array<StaticImportEntry>;
+}
+interface StaticImportEntry {
+  /**
+   * The name under which the desired binding is exported by the module.
+   *
+   * ```js
+   * import { foo } from "mod";
+   * //       ^^^
+   * import { foo as bar } from "mod";
+   * //       ^^^
+   * ```
+   */
+  importName: ImportName;
+  /**
+   * The name that is used to locally access the imported value from within the importing module.
+   * ```js
+   * import { foo } from "mod";
+   * //       ^^^
+   * import { foo as bar } from "mod";
+   * //              ^^^
+   * ```
+   */
+  localName: ValueSpan;
+  /**
+   * Whether this binding is for a TypeScript type-only import.
+   *
+   * `true` for the following imports:
+   * ```ts
+   * import type { foo } from "mod";
+   * import { type foo } from "mod";
+   * ```
+   */
+  isType: boolean;
+}
+interface ValueSpan {
+  value: string;
+  start: number;
+  end: number;
+}
+declare class ResolverFactory {
+  constructor(options?: NapiResolveOptions | undefined | null);
+  static default(): ResolverFactory;
+  /** Clone the resolver using the same underlying cache. */
+  cloneWithOptions(options: NapiResolveOptions): ResolverFactory;
+  /**
+   * Clear the underlying cache.
+   *
+   * Warning: The caller must ensure that there're no ongoing resolution operations when calling this method. Otherwise, it may cause those operations to return an incorrect result.
+   */
+  clearCache(): void;
+  /** Synchronously resolve `specifier` at an absolute path to a `directory`. */
+  sync(directory: string, request: string): ResolveResult;
+  /** Asynchronously resolve `specifier` at an absolute path to a `directory`. */
+  async(directory: string, request: string): Promise<ResolveResult>;
+  /**
+   * Synchronously resolve `specifier` at an absolute path to a `file`.
+   *
+   * This method automatically discovers tsconfig.json by traversing parent directories.
+   */
+  resolveFileSync(file: string, request: string): ResolveResult;
+  /**
+   * Asynchronously resolve `specifier` at an absolute path to a `file`.
+   *
+   * This method automatically discovers tsconfig.json by traversing parent directories.
+   */
+  resolveFileAsync(file: string, request: string): Promise<ResolveResult>;
+  /**
+   * Synchronously resolve `specifier` for TypeScript declaration files.
+   *
+   * `file` is the absolute path to the containing file.
+   * Uses TypeScript's `moduleResolution: "bundler"` algorithm.
+   */
+  resolveDtsSync(file: string, request: string): ResolveResult;
+  /**
+   * Asynchronously resolve `specifier` for TypeScript declaration files.
+   *
+   * `file` is the absolute path to the containing file.
+   * Uses TypeScript's `moduleResolution: "bundler"` algorithm.
+   */
+  resolveDtsAsync(file: string, request: string): Promise<ResolveResult>;
+}
+/** Node.js builtin module when `Options::builtin_modules` is enabled. */
+interface Builtin {
+  /**
+   * Resolved module.
+   *
+   * Always prefixed with "node:" in compliance with the ESM specification.
+   */
+  resolved: string;
+  /**
+   * Whether the request was prefixed with `node:` or not.
+   * `fs` -> `false`.
+   * `node:fs` returns `true`.
+   */
+  isRuntimeModule: boolean;
+}
+declare enum EnforceExtension {
+  Auto = 0,
+  Enabled = 1,
+  Disabled = 2
+}
+type ModuleType = 'module' | 'commonjs' | 'json' | 'wasm' | 'addon';
+/**
+ * Module Resolution Options
+ *
+ * Options are directly ported from [enhanced-resolve](https://github.com/webpack/enhanced-resolve#resolver-options).
+ *
+ * See [webpack resolve](https://webpack.js.org/configuration/resolve/) for information and examples
+ */
+interface NapiResolveOptions {
+  /**
+   * Discover tsconfig automatically or use the specified tsconfig.json path.
+   *
+   * Default `None`
+   */
+  tsconfig?: 'auto' | TsconfigOptions;
+  /**
+   * Alias for [ResolveOptions::alias] and [ResolveOptions::fallback].
+   *
+   * For the second value of the tuple, `None -> AliasValue::Ignore`, Some(String) ->
+   * AliasValue::Path(String)`
+   * Create aliases to import or require certain modules more easily.
+   * A trailing $ can also be added to the given object's keys to signify an exact match.
+   * Default `{}`
+   */
+  alias?: Record<string, Array<string | undefined | null>>;
+  /**
+   * A list of alias fields in description files.
+   * Specify a field, such as `browser`, to be parsed according to [this specification](https://github.com/defunctzombie/package-browser-field-spec).
+   * Can be a path to json object such as `["path", "to", "exports"]`.
+   *
+   * Default `[]`
+   */
+  aliasFields?: (string | string[])[];
+  /**
+   * Condition names for exports field which defines entry points of a package.
+   * The key order in the exports field is significant. During condition matching, earlier entries have higher priority and take precedence over later entries.
+   *
+   * Default `[]`
+   */
+  conditionNames?: Array<string>;
+  /**
+   * If true, it will not allow extension-less files.
+   * So by default `require('./foo')` works if `./foo` has a `.js` extension,
+   * but with this enabled only `require('./foo.js')` will work.
+   *
+   * Default to `true` when [ResolveOptions::extensions] contains an empty string.
+   * Use `Some(false)` to disable the behavior.
+   * See <https://github.com/webpack/enhanced-resolve/pull/285>
+   *
+   * Default None, which is the same as `Some(false)` when the above empty rule is not applied.
+   */
+  enforceExtension?: EnforceExtension;
+  /**
+   * A list of exports fields in description files.
+   * Can be a path to json object such as `["path", "to", "exports"]`.
+   *
+   * Default `[["exports"]]`.
+   */
+  exportsFields?: (string | string[])[];
+  /**
+   * Fields from `package.json` which are used to provide the internal requests of a package
+   * (requests starting with # are considered internal).
+   *
+   * Can be a path to a JSON object such as `["path", "to", "imports"]`.
+   *
+   * Default `[["imports"]]`.
+   */
+  importsFields?: (string | string[])[];
+  /**
+   * An object which maps extension to extension aliases.
+   *
+   * Default `{}`
+   */
+  extensionAlias?: Record<string, Array<string>>;
+  /**
+   * Attempt to resolve these extensions in order.
+   * If multiple files share the same name but have different extensions,
+   * will resolve the one with the extension listed first in the array and skip the rest.
+   *
+   * Default `[".js", ".json", ".node"]`
+   */
+  extensions?: Array<string>;
+  /**
+   * Redirect module requests when normal resolving fails.
+   *
+   * Default `{}`
+   */
+  fallback?: Record<string, Array<string | undefined | null>>;
+  /**
+   * Request passed to resolve is already fully specified and extensions or main files are not resolved for it (they are still resolved for internal requests).
+   *
+   * See also webpack configuration [resolve.fullySpecified](https://webpack.js.org/configuration/module/#resolvefullyspecified)
+   *
+   * Default `false`
+   */
+  fullySpecified?: boolean;
+  /**
+   * A list of main fields in description files
+   *
+   * Default `["main"]`.
+   */
+  mainFields?: string | string[];
+  /**
+   * The filename to be used while resolving directories.
+   *
+   * Default `["index"]`
+   */
+  mainFiles?: Array<string>;
+  /**
+   * A list of directories to resolve modules from, can be absolute path or folder name.
+   *
+   * Default `["node_modules"]`
+   */
+  modules?: string | string[];
+  /**
+   * Resolve to a context instead of a file.
+   *
+   * Default `false`
+   */
+  resolveToContext?: boolean;
+  /**
+   * Prefer to resolve module requests as relative requests instead of using modules from node_modules directories.
+   *
+   * Default `false`
+   */
+  preferRelative?: boolean;
+  /**
+   * Prefer to resolve server-relative urls as absolute paths before falling back to resolve in ResolveOptions::roots.
+   *
+   * Default `false`
+   */
+  preferAbsolute?: boolean;
+  /**
+   * A list of resolve restrictions to restrict the paths that a request can be resolved on.
+   *
+   * Default `[]`
+   */
+  restrictions?: Array<Restriction>;
+  /**
+   * A list of directories where requests of server-relative URLs (starting with '/') are resolved.
+   * On non-Windows systems these requests are resolved as an absolute path first.
+   *
+   * Default `[]`
+   */
+  roots?: Array<string>;
+  /**
+   * Whether to resolve symlinks to their symlinked location.
+   * When enabled, symlinked resources are resolved to their real path, not their symlinked location.
+   * Note that this may cause module resolution to fail when using tools that symlink packages (like npm link).
+   *
+   * Default `true`
+   */
+  symlinks?: boolean;
+  /**
+   * Whether to read the `NODE_PATH` environment variable and append its entries to `modules`.
+   *
+   * `NODE_PATH` is a deprecated Node.js feature that is not part of ESM resolution.
+   * Set this to `false` to disable the behavior.
+   *
+   * Default `true`
+   */
+  nodePath?: boolean;
+  /**
+   * Whether to parse [module.builtinModules](https://nodejs.org/api/module.html#modulebuiltinmodules) or not.
+   * For example, "zlib" will throw [crate::ResolveError::Builtin] when set to true.
+   *
+   * Default `false`
+   */
+  builtinModules?: boolean;
+  /**
+   * Resolve [ResolveResult::moduleType].
+   *
+   * Default `false`
+   */
+  moduleType?: boolean;
+  /**
+   * Allow `exports` field in `require('../directory')`.
+   *
+   * This is not part of the spec but some vite projects rely on this behavior.
+   * See
+   * * <https://github.com/vitejs/vite/pull/20252>
+   * * <https://github.com/nodejs/node/issues/58827>
+   *
+   * Default: `false`
+   */
+  allowPackageExportsInDirectoryResolve?: boolean;
+}
+interface ResolveResult {
+  path?: string;
+  error?: string;
+  builtin?: Builtin;
+  /**
+   * Module type for this path.
+   *
+   * Enable with `ResolveOptions#moduleType`.
+   *
+   * The module type is computed `ESM_FILE_FORMAT` from the [ESM resolution algorithm specification](https://nodejs.org/docs/latest/api/esm.html#resolution-algorithm-specification).
+   *
+   *  The algorithm uses the file extension or finds the closest `package.json` with the `type` field.
+   */
+  moduleType?: ModuleType;
+  /** `package.json` path for the given module. */
+  packageJsonPath?: string;
+}
+/**
+ * Alias Value for [ResolveOptions::alias] and [ResolveOptions::fallback].
+ * Use struct because napi don't support structured union now
+ */
+interface Restriction {
+  path?: string;
+  regex?: string;
+}
+/**
+ * Tsconfig Options
+ *
+ * Derived from [tsconfig-paths-webpack-plugin](https://github.com/dividab/tsconfig-paths-webpack-plugin#options)
+ */
+interface TsconfigOptions {
+  /**
+   * Allows you to specify where to find the TypeScript configuration file.
+   * You may provide
+   * * a relative path to the configuration file. It will be resolved relative to cwd.
+   * * an absolute path to the configuration file.
+   */
+  configFile: string;
+  /**
+   * Support for Typescript Project References.
+   *
+   * * `'auto'`: use the `references` field from tsconfig of `config_file`.
+   */
+  references?: 'auto';
+}
+interface SourceMap {
+  file?: string;
+  mappings: string;
+  names: Array<string>;
+  sourceRoot?: string;
+  sources: Array<string>;
+  sourcesContent?: Array<string>;
+  version: number;
+  x_google_ignoreList?: Array<number>;
+}
+interface CompilerAssumptions {
+  ignoreFunctionLength?: boolean;
+  noDocumentAll?: boolean;
+  objectRestNoSymbols?: boolean;
+  pureGetters?: boolean;
+  /**
+   * When using public class fields, assume that they don't shadow any getter in the current class,
+   * in its subclasses or in its superclass. Thus, it's safe to assign them rather than using
+   * `Object.defineProperty`.
+   *
+   * For example:
+   *
+   * Input:
+   * ```js
+   * class Test {
+   *  field = 2;
+   *
+   *  static staticField = 3;
+   * }
+   * ```
+   *
+   * When `set_public_class_fields` is `true`, the output will be:
+   * ```js
+   * class Test {
+   *  constructor() {
+   *    this.field = 2;
+   *  }
+   * }
+   * Test.staticField = 3;
+   * ```
+   *
+   * Otherwise, the output will be:
+   * ```js
+   * import _defineProperty from "@oxc-project/runtime/helpers/defineProperty";
+   * class Test {
+   *   constructor() {
+   *     _defineProperty(this, "field", 2);
+   *   }
+   * }
+   * _defineProperty(Test, "staticField", 3);
+   * ```
+   *
+   * NOTE: For TypeScript, if you wanted behavior is equivalent to `useDefineForClassFields: false`, you should
+   * set both `set_public_class_fields` and [`crate::TypeScriptOptions::remove_class_fields_without_initializer`]
+   * to `true`.
+   */
+  setPublicClassFields?: boolean;
+}
+interface DecoratorOptions {
+  /**
+   * Enables experimental support for decorators, which is a version of decorators that predates the TC39 standardization process.
+   *
+   * Decorators are a language feature which hasn’t yet been fully ratified into the JavaScript specification.
+   * This means that the implementation version in TypeScript may differ from the implementation in JavaScript when it it decided by TC39.
+   *
+   * @see https://www.typescriptlang.org/tsconfig/#experimentalDecorators
+   * @default false
+   */
+  legacy?: boolean;
+  /**
+   * Enables emitting decorator metadata.
+   *
+   * This option the same as [emitDecoratorMetadata](https://www.typescriptlang.org/tsconfig/#emitDecoratorMetadata)
+   * in TypeScript, and it only works when `legacy` is true.
+   *
+   * @see https://www.typescriptlang.org/tsconfig/#emitDecoratorMetadata
+   * @default false
+   */
+  emitDecoratorMetadata?: boolean;
+}
+type HelperMode =
+/**
+* Runtime mode (default): Helper functions are imported from a runtime package.
+*
+* Example:
+*
+* ```js
+* import helperName from "@oxc-project/runtime/helpers/helperName";
+* helperName(...arguments);
+* ```
+*/
+'Runtime' |
+/**
+ * External mode: Helper functions are accessed from a global `babelHelpers` object.
+ *
+ * Example:
+ *
+ * ```js
+ * babelHelpers.helperName(...arguments);
+ * ```
+ */
+'External';
+interface Helpers {
+  mode?: HelperMode;
+}
+/**
+ * TypeScript Isolated Declarations for Standalone DTS Emit (async)
+ *
+ * Note: This function can be slower than `isolatedDeclarationSync` due to the overhead of spawning a thread.
+ */
+declare function isolatedDeclaration(filename: string, sourceText: string, options?: IsolatedDeclarationsOptions | undefined | null): Promise<IsolatedDeclarationsResult>;
+interface IsolatedDeclarationsOptions {
+  /**
+   * Do not emit declarations for code that has an @internal annotation in its JSDoc comment.
+   * This is an internal compiler option; use at your own risk, because the compiler does not check that the result is valid.
+   *
+   * Default: `false`
+   *
+   * See <https://www.typescriptlang.org/tsconfig/#stripInternal>
+   */
+  stripInternal?: boolean;
+  sourcemap?: boolean;
+}
+interface IsolatedDeclarationsResult {
+  code: string;
+  map?: SourceMap;
+  errors: Array<OxcError>;
+}
+/** TypeScript Isolated Declarations for Standalone DTS Emit */
+declare function isolatedDeclarationSync(filename: string, sourceText: string, options?: IsolatedDeclarationsOptions | undefined | null): IsolatedDeclarationsResult;
+/**
+ * Configure how TSX and JSX are transformed.
+ *
+ * @see {@link https://oxc.rs/docs/guide/usage/transformer/jsx}
+ */
+interface JsxOptions {
+  /**
+   * Decides which runtime to use.
+   *
+   * - 'automatic' - auto-import the correct JSX factories
+   * - 'classic' - no auto-import
+   *
+   * @default 'automatic'
+   */
+  runtime?: 'classic' | 'automatic';
+  /**
+   * Emit development-specific information, such as `__source` and `__self`.
+   *
+   * @default false
+   */
+  development?: boolean;
+  /**
+   * Toggles whether or not to throw an error if an XML namespaced tag name
+   * is used.
+   *
+   * Though the JSX spec allows this, it is disabled by default since React's
+   * JSX does not currently have support for it.
+   *
+   * @default true
+   */
+  throwIfNamespace?: boolean;
+  /**
+   * Mark JSX elements and top-level React method calls as pure for tree shaking.
+   *
+   * @default true
+   */
+  pure?: boolean;
+  /**
+   * Replaces the import source when importing functions.
+   *
+   * @default 'react'
+   */
+  importSource?: string;
+  /**
+   * Replace the function used when compiling JSX expressions. It should be a
+   * qualified name (e.g. `React.createElement`) or an identifier (e.g.
+   * `createElement`).
+   *
+   * Only used for `classic` {@link runtime}.
+   *
+   * @default 'React.createElement'
+   */
+  pragma?: string;
+  /**
+   * Replace the component used when compiling JSX fragments. It should be a
+   * valid JSX tag name.
+   *
+   * Only used for `classic` {@link runtime}.
+   *
+   * @default 'React.Fragment'
+   */
+  pragmaFrag?: string;
+  /**
+   * Enable React Fast Refresh .
+   *
+   * Conforms to the implementation in {@link https://github.com/facebook/react/tree/v18.3.1/packages/react-refresh}
+   *
+   * @default false
+   */
+  refresh?: boolean | ReactRefreshOptions;
+}
+/**
+ * Transform JavaScript code to a Vite Node runnable module.
+ *
+ * @param filename The name of the file being transformed.
+ * @param sourceText the source code itself
+ * @param options The options for the transformation. See {@link
+ * ModuleRunnerTransformOptions} for more information.
+ *
+ * @returns an object containing the transformed code, source maps, and any
+ * errors that occurred during parsing or transformation.
+ *
+ * Note: This function can be slower than `moduleRunnerTransformSync` due to the overhead of spawning a thread.
+ *
+ * @deprecated Only works for Vite.
+ */
+declare function moduleRunnerTransform(filename: string, sourceText: string, options?: ModuleRunnerTransformOptions | undefined | null): Promise<ModuleRunnerTransformResult>;
+interface ModuleRunnerTransformOptions {
+  /**
+   * Enable source map generation.
+   *
+   * When `true`, the `sourceMap` field of transform result objects will be populated.
+   *
+   * @default false
+   *
+   * @see {@link SourceMap}
+   */
+  sourcemap?: boolean;
+}
+interface ModuleRunnerTransformResult {
+  /**
+   * The transformed code.
+   *
+   * If parsing failed, this will be an empty string.
+   */
+  code: string;
+  /**
+   * The source map for the transformed code.
+   *
+   * This will be set if {@link TransformOptions#sourcemap} is `true`.
+   */
+  map?: SourceMap;
+  deps: Array<string>;
+  dynamicDeps: Array<string>;
+  /**
+   * Parse and transformation errors.
+   *
+   * Oxc's parser recovers from common syntax errors, meaning that
+   * transformed code may still be available even if there are errors in this
+   * list.
+   */
+  errors: Array<OxcError>;
+}
+interface PluginsOptions {
+  styledComponents?: StyledComponentsOptions;
+  taggedTemplateEscape?: boolean;
+}
+interface ReactRefreshOptions {
+  /**
+   * Specify the identifier of the refresh registration variable.
+   *
+   * @default `$RefreshReg$`.
+   */
+  refreshReg?: string;
+  /**
+   * Specify the identifier of the refresh signature variable.
+   *
+   * @default `$RefreshSig$`.
+   */
+  refreshSig?: string;
+  emitFullSignatures?: boolean;
+}
+/**
+ * Configure how styled-components are transformed.
+ *
+ * @see {@link https://oxc.rs/docs/guide/usage/transformer/plugins#styled-components}
+ */
+interface StyledComponentsOptions {
+  /**
+   * Enhances the attached CSS class name on each component with richer output to help
+   * identify your components in the DOM without React DevTools.
+   *
+   * @default true
+   */
+  displayName?: boolean;
+  /**
+   * Controls whether the `displayName` of a component will be prefixed with the filename
+   * to make the component name as unique as possible.
+   *
+   * @default true
+   */
+  fileName?: boolean;
+  /**
+   * Adds a unique identifier to every styled component to avoid checksum mismatches
+   * due to different class generation on the client and server during server-side rendering.
+   *
+   * @default true
+   */
+  ssr?: boolean;
+  /**
+   * Transpiles styled-components tagged template literals to a smaller representation
+   * than what Babel normally creates, helping to reduce bundle size.
+   *
+   * @default true
+   */
+  transpileTemplateLiterals?: boolean;
+  /**
+   * Minifies CSS content by removing all whitespace and comments from your CSS,
+   * keeping valuable bytes out of your bundles.
+   *
+   * @default true
+   */
+  minify?: boolean;
+  /**
+   * Enables transformation of JSX `css` prop when using styled-components.
+   *
+   * **Note: This feature is not yet implemented in oxc.**
+   *
+   * @default true
+   */
+  cssProp?: boolean;
+  /**
+   * Enables "pure annotation" to aid dead code elimination by bundlers.
+   *
+   * @default false
+   */
+  pure?: boolean;
+  /**
+   * Adds a namespace prefix to component identifiers to ensure class names are unique.
+   *
+   * Example: With `namespace: "my-app"`, generates `componentId: "my-app__sc-3rfj0a-1"`
+   */
+  namespace?: string;
+  /**
+   * List of file names that are considered meaningless for component naming purposes.
+   *
+   * When the `fileName` option is enabled and a component is in a file with a name
+   * from this list, the directory name will be used instead of the file name for
+   * the component's display name.
+   *
+   * @default `["index"]`
+   */
+  meaninglessFileNames?: Array<string>;
+  /**
+   * Import paths to be considered as styled-components imports at the top level.
+   *
+   * **Note: This feature is not yet implemented in oxc.**
+   */
+  topLevelImportPaths?: Array<string>;
+}
+/**
+ * Options for transforming a JavaScript or TypeScript file.
+ *
+ * @see {@link transform}
+ */
+interface TransformOptions {
+  /** Treat the source text as `js`, `jsx`, `ts`, `tsx`, or `dts`. */
+  lang?: 'js' | 'jsx' | 'ts' | 'tsx' | 'dts';
+  /** Treat the source text as `script` or `module` code. */
+  sourceType?: 'script' | 'module' | 'commonjs' | 'unambiguous' | undefined;
+  /**
+   * The current working directory. Used to resolve relative paths in other
+   * options.
+   */
+  cwd?: string;
+  /**
+   * Enable source map generation.
+   *
+   * When `true`, the `sourceMap` field of transform result objects will be populated.
+   *
+   * @default false
+   *
+   * @see {@link SourceMap}
+   */
+  sourcemap?: boolean;
+  /** Set assumptions in order to produce smaller output. */
+  assumptions?: CompilerAssumptions;
+  /**
+   * Configure how TypeScript is transformed.
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/typescript}
+   */
+  typescript?: TypeScriptOptions;
+  /**
+   * Configure how TSX and JSX are transformed.
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/jsx}
+   */
+  jsx?: 'preserve' | JsxOptions;
+  /**
+   * Sets the target environment for the generated JavaScript.
+   *
+   * The lowest target is `es2015`.
+   *
+   * Example:
+   *
+   * * `'es2015'`
+   * * `['es2020', 'chrome58', 'edge16', 'firefox57', 'node12', 'safari11']`
+   *
+   * @default `esnext` (No transformation)
+   *
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/lowering#target}
+   */
+  target?: string | Array<string>;
+  /** Behaviour for runtime helpers. */
+  helpers?: Helpers;
+  /**
+   * Define Plugin
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#define}
+   */
+  define?: Record<string, string>;
+  /**
+   * Inject Plugin
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#inject}
+   */
+  inject?: Record<string, string | [string, string]>;
+  /** Decorator plugin */
+  decorator?: DecoratorOptions;
+  /**
+   * Third-party plugins to use.
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/plugins}
+   */
+  plugins?: PluginsOptions;
+}
+interface TypeScriptOptions {
+  jsxPragma?: string;
+  jsxPragmaFrag?: string;
+  onlyRemoveTypeImports?: boolean;
+  allowNamespaces?: boolean;
+  /**
+   * When enabled, type-only class fields are only removed if they are prefixed with the declare modifier:
+   *
+   * @deprecated
+   *
+   * Allowing `declare` fields is built-in support in Oxc without any option. If you want to remove class fields
+   * without initializer, you can use `remove_class_fields_without_initializer: true` instead.
+   */
+  allowDeclareFields?: boolean;
+  /**
+   * When enabled, class fields without initializers are removed.
+   *
+   * For example:
+   * ```ts
+   * class Foo {
+   *    x: number;
+   *    y: number = 0;
+   * }
+   * ```
+   * // transform into
+   * ```js
+   * class Foo {
+   *    x: number;
+   * }
+   * ```
+   *
+   * The option is used to align with the behavior of TypeScript's `useDefineForClassFields: false` option.
+   * When you want to enable this, you also need to set [`crate::CompilerAssumptions::set_public_class_fields`]
+   * to `true`. The `set_public_class_fields: true` + `remove_class_fields_without_initializer: true` is
+   * equivalent to `useDefineForClassFields: false` in TypeScript.
+   *
+   * When `set_public_class_fields` is true and class-properties plugin is enabled, the above example transforms into:
+   *
+   * ```js
+   * class Foo {
+   *   constructor() {
+   *     this.y = 0;
+   *   }
+   * }
+   * ```
+   *
+   * Defaults to `false`.
+   */
+  removeClassFieldsWithoutInitializer?: boolean;
+  /**
+   * When true, optimize const enums by inlining their values at usage sites
+   * and removing the enum declaration.
+   *
+   * @default false
+   */
+  optimizeConstEnums?: boolean;
+  /**
+   * When true, optimize regular (non-const) enums by inlining their member
+   * accesses at usage sites when the member value is statically known.
+   *
+   * Non-exported enum declarations are also removed when all members are
+   * evaluable and no references to the enum as a runtime value exist
+   * (e.g., `console.log(Foo)`, `typeof Foo`, or passing the enum as an argument).
+   *
+   * @default false
+   */
+  optimizeEnums?: boolean;
+  /**
+   * Also generate a `.d.ts` declaration file for TypeScript files.
+   *
+   * The source file must be compliant with all
+   * [`isolatedDeclarations`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-5.html#isolated-declarations)
+   * requirements.
+   *
+   * @default false
+   */
+  declaration?: IsolatedDeclarationsOptions;
+  /**
+   * Rewrite or remove TypeScript import/export declaration extensions.
+   *
+   * - When set to `rewrite`, it will change `.ts`, `.mts`, `.cts` extensions to `.js`, `.mjs`, `.cjs` respectively.
+   * - When set to `remove`, it will remove `.ts`/`.mts`/`.cts`/`.tsx` extension entirely.
+   * - When set to `true`, it's equivalent to `rewrite`.
+   * - When set to `false` or omitted, no changes will be made to the extensions.
+   *
+   * @default false
+   */
+  rewriteImportExtensions?: 'rewrite' | 'remove' | boolean;
+}
+/** A decoded source map with mappings as an array of arrays instead of VLQ-encoded string. */
+declare class BindingDecodedMap {
+  /** The source map version (always 3). */
+  get version(): number;
+  /** The generated file name. */
+  get file(): string | null;
+  /** The list of original source files. */
+  get sources(): Array<string>;
+  /** The original source contents (if `includeContent` was true). */
+  get sourcesContent(): Array<string | undefined | null>;
+  /** The list of symbol names used in mappings. */
+  get names(): Array<string>;
+  /**
+   * The decoded mappings as an array of line arrays.
+   * Each line is an array of segments, where each segment is [generatedColumn, sourceIndex, originalLine, originalColumn, nameIndex?].
+   */
+  get mappings(): Array<Array<Array<number>>>;
+  /** The list of source indices that should be excluded from debugging. */
+  get x_google_ignoreList(): Array<number> | null;
+}
+declare class BindingMagicString {
+  constructor(source: string, options?: BindingMagicStringOptions | undefined | null);
+  get original(): string;
+  get filename(): string | null;
+  get indentExclusionRanges(): Array<Array<number>> | Array<number> | null;
+  get ignoreList(): boolean;
+  get offset(): number;
+  set offset(offset: number);
+  replace(from: string, to: string): this;
+  replaceAll(from: string, to: string): this;
+  /**
+   * Returns the UTF-16 offset past the last match, or -1 if no match was found.
+   * The JS wrapper uses this to update `lastIndex` on the caller's RegExp.
+   * Global/sticky behavior is derived from the regex's own flags.
+   */
+  replaceRegex(from: RegExp, to: string): number;
+  prepend(content: string): this;
+  append(content: string): this;
+  prependLeft(index: number, content: string): this;
+  prependRight(index: number, content: string): this;
+  appendLeft(index: number, content: string): this;
+  appendRight(index: number, content: string): this;
+  overwrite(start: number, end: number, content: string, options?: BindingOverwriteOptions | undefined | null): this;
+  toString(): string;
+  hasChanged(): boolean;
+  length(): number;
+  isEmpty(): boolean;
+  remove(start: number, end: number): this;
+  update(start: number, end: number, content: string, options?: BindingUpdateOptions | undefined | null): this;
+  relocate(start: number, end: number, to: number): this;
+  /**
+   * Alias for `relocate` to match the original magic-string API.
+   * Moves the characters from `start` to `end` to `index`.
+   * Returns `this` for method chaining.
+   */
+  move(start: number, end: number, index: number): this;
+  indent(indentor?: string | undefined | null, options?: BindingIndentOptions | undefined | null): this;
+  /** Trims whitespace or specified characters from the start and end. */
+  trim(charType?: string | undefined | null): this;
+  /** Trims whitespace or specified characters from the start. */
+  trimStart(charType?: string | undefined | null): this;
+  /** Trims whitespace or specified characters from the end. */
+  trimEnd(charType?: string | undefined | null): this;
+  /** Trims newlines from the start and end. */
+  trimLines(): this;
+  /**
+   * Deprecated method that throws an error directing users to use prependRight or appendLeft.
+   * This matches the original magic-string API which deprecated this method.
+   */
+  insert(index: number, content: string): void;
+  /** Returns a clone of the MagicString instance. */
+  clone(): BindingMagicString;
+  /** Returns the last character of the generated string, or an empty string if empty. */
+  lastChar(): string;
+  /** Returns the content after the last newline in the generated string. */
+  lastLine(): string;
+  /** Returns the guessed indentation string, or `\t` if none is found. */
+  getIndentString(): string;
+  /** Returns a clone with content outside the specified range removed. */
+  snip(start: number, end: number): BindingMagicString;
+  /**
+   * Resets the portion of the string from `start` to `end` to its original content.
+   * This undoes any modifications made to that range.
+   * Supports negative indices (counting from the end).
+   */
+  reset(start: number, end: number): this;
+  /**
+   * Returns the content between the specified UTF-16 code unit positions (JS string indices).
+   * Supports negative indices (counting from the end).
+   *
+   * When an index falls in the middle of a surrogate pair, the lone surrogate is
+   * included in the result (matching the original magic-string / JS behavior).
+   * This is done by returning a UTF-16 encoded JS string via `napi_create_string_utf16`.
+   */
+  slice(start?: number | undefined | null, end?: number | undefined | null): string;
+  /**
+   * Generates a source map for the transformations applied to this MagicString.
+   * Returns a BindingSourceMap object with version, file, sources, sourcesContent, names, mappings.
+   */
+  generateMap(options?: BindingSourceMapOptions | undefined | null): BindingSourceMap;
+  /**
+   * Generates a decoded source map for the transformations applied to this MagicString.
+   * Returns a BindingDecodedMap object with mappings as an array of arrays.
+   */
+  generateDecodedMap(options?: BindingSourceMapOptions | undefined | null): BindingDecodedMap;
+}
+declare class BindingNormalizedOptions {
+  get input(): Array<string> | Record<string, string>;
+  get cwd(): string;
+  get platform(): 'node' | 'browser' | 'neutral';
+  get shimMissingExports(): boolean;
+  get name(): string | null;
+  get entryFilenames(): string | undefined;
+  get chunkFilenames(): string | undefined;
+  get assetFilenames(): string | undefined;
+  get dir(): string | null;
+  get file(): string | null;
+  get format(): 'es' | 'cjs' | 'iife' | 'umd';
+  get exports(): 'default' | 'named' | 'none' | 'auto';
+  get esModule(): boolean | 'if-default-prop';
+  get codeSplitting(): boolean;
+  get dynamicImportInCjs(): boolean;
+  get sourcemap(): boolean | 'inline' | 'hidden';
+  get sourcemapBaseUrl(): string | null;
+  get banner(): string | undefined | null | undefined;
+  get footer(): string | undefined | null | undefined;
+  get intro(): string | undefined | null | undefined;
+  get outro(): string | undefined | null | undefined;
+  get postBanner(): string | undefined | null | undefined;
+  get postFooter(): string | undefined | null | undefined;
+  get externalLiveBindings(): boolean;
+  get extend(): boolean;
+  get globals(): Record<string, string> | undefined;
+  get hashCharacters(): 'base64' | 'base36' | 'hex';
+  get sourcemapDebugIds(): boolean;
+  get sourcemapExcludeSources(): boolean;
+  get polyfillRequire(): boolean;
+  get minify(): false | 'dce-only' | MinifyOptions;
+  get legalComments(): 'none' | 'inline';
+  get comments(): BindingCommentsOptions;
+  get preserveModules(): boolean;
+  get preserveModulesRoot(): string | undefined;
+  get virtualDirname(): string;
+  get topLevelVar(): boolean;
+  get minifyInternalExports(): boolean;
+  get context(): string;
+}
+declare class BindingRenderedChunk {
+  get name(): string;
+  get isEntry(): boolean;
+  get isDynamicEntry(): boolean;
+  get facadeModuleId(): string | null;
+  get moduleIds(): Array<string>;
+  get exports(): Array<string>;
+  get fileName(): string;
+  get modules(): BindingModules;
+  get imports(): Array<string>;
+  get dynamicImports(): Array<string>;
+}
+declare class BindingRenderedModule {
+  get code(): string | null;
+  get renderedExports(): Array<string>;
+}
+/** A source map object with properties matching the SourceMap V3 specification. */
+declare class BindingSourceMap {
+  /** The source map version (always 3). */
+  get version(): number;
+  /** The generated file name. */
+  get file(): string | null;
+  /** The list of original source files. */
+  get sources(): Array<string>;
+  /** The original source contents (if `includeContent` was true). */
+  get sourcesContent(): Array<string | undefined | null>;
+  /** The list of symbol names used in mappings. */
+  get names(): Array<string>;
+  /** The VLQ-encoded mappings string. */
+  get mappings(): string;
+  /** The list of source indices that should be excluded from debugging. */
+  get x_google_ignoreList(): Array<number> | null;
+  /** Returns the source map as a JSON string. */
+  toString(): string;
+  /** Returns the source map as a base64-encoded data URL. */
+  toUrl(): string;
+}
+/**
+ * Minimal wrapper around a `BundleHandle` for watcher events.
+ * This is returned from watcher event data to allow calling `result.close()`.
+ */
+declare class BindingWatcherBundler {
+  close(): Promise<void>;
+}
+declare class TsconfigCache {
+  /** Create a new transform cache with auto tsconfig discovery enabled. */
+  constructor(yarnPnp: boolean);
+  /**
+   * Clear the cache.
+   *
+   * Call this when tsconfig files have changed to ensure fresh resolution.
+   */
+  clear(): void;
+  /** Get the number of cached entries. */
+  size(): number;
+}
+type BindingBuiltinPluginName = 'builtin:bundle-analyzer' | 'builtin:esm-external-require' | 'builtin:isolated-declaration' | 'builtin:replace' | 'builtin:vite-alias' | 'builtin:vite-build-import-analysis' | 'builtin:vite-dynamic-import-vars' | 'builtin:vite-import-glob' | 'builtin:vite-json' | 'builtin:vite-load-fallback' | 'builtin:vite-manifest' | 'builtin:vite-module-preload-polyfill' | 'builtin:vite-react-refresh-wrapper' | 'builtin:vite-reporter' | 'builtin:vite-resolve' | 'builtin:vite-transform' | 'builtin:vite-wasm-fallback' | 'builtin:vite-web-worker-post' | 'builtin:oxc-runtime';
+interface BindingBundleAnalyzerPluginConfig {
+  /** Output filename for the bundle analysis data (default: "analyze-data.json") */
+  fileName?: string;
+  /** Output format: "json" (default) or "md" for LLM-friendly markdown */
+  format?: 'json' | 'md';
+}
+interface BindingBundleState {
+  lastFullBuildFailed: boolean;
+  hasStaleOutput: boolean;
+}
+interface BindingClientHmrUpdate {
+  clientId: string;
+  update: BindingHmrUpdate;
+}
+interface BindingCommentsOptions {
+  legal?: boolean;
+  annotation?: boolean;
+  jsdoc?: boolean;
+}
+interface BindingCompilerOptions {
+  baseUrl?: string;
+  paths?: Record<string, Array<string>>;
+  experimentalDecorators?: boolean;
+  emitDecoratorMetadata?: boolean;
+  useDefineForClassFields?: boolean;
+  rewriteRelativeImportExtensions?: boolean;
+  jsx?: string;
+  jsxFactory?: string;
+  jsxFragmentFactory?: string;
+  jsxImportSource?: string;
+  verbatimModuleSyntax?: boolean;
+  preserveValueImports?: boolean;
+  importsNotUsedAsValues?: string;
+  target?: string;
+  module?: string;
+  allowJs?: boolean;
+  rootDirs?: Array<string>;
+}
+/** Enhanced transform options with tsconfig and inputMap support. */
+interface BindingEnhancedTransformOptions {
+  /** Treat the source text as 'js', 'jsx', 'ts', 'tsx', or 'dts'. */
+  lang?: 'js' | 'jsx' | 'ts' | 'tsx' | 'dts';
+  /** Treat the source text as 'script', 'module', 'commonjs', or 'unambiguous'. */
+  sourceType?: 'script' | 'module' | 'commonjs' | 'unambiguous' | undefined;
+  /**
+   * The current working directory. Used to resolve relative paths in other
+   * options.
+   */
+  cwd?: string;
+  /**
+   * Enable source map generation.
+   *
+   * When `true`, the `sourceMap` field of transform result objects will be populated.
+   *
+   * @default false
+   */
+  sourcemap?: boolean;
+  /** Set assumptions in order to produce smaller output. */
+  assumptions?: CompilerAssumptions;
+  /**
+   * Configure how TypeScript is transformed.
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/typescript}
+   */
+  typescript?: TypeScriptOptions;
+  /**
+   * Configure how TSX and JSX are transformed.
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/jsx}
+   */
+  jsx?: 'preserve' | JsxOptions;
+  /**
+   * Sets the target environment for the generated JavaScript.
+   *
+   * The lowest target is `es2015`.
+   *
+   * Example:
+   *
+   * * `'es2015'`
+   * * `['es2020', 'chrome58', 'edge16', 'firefox57', 'node12', 'safari11']`
+   *
+   * @default `esnext` (No transformation)
+   *
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/lowering#target}
+   */
+  target?: string | Array<string>;
+  /** Behaviour for runtime helpers. */
+  helpers?: Helpers;
+  /**
+   * Define Plugin
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#define}
+   */
+  define?: Record<string, string>;
+  /**
+   * Inject Plugin
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#inject}
+   */
+  inject?: Record<string, string | [string, string]>;
+  /** Decorator plugin */
+  decorator?: DecoratorOptions;
+  /**
+   * Third-party plugins to use.
+   * @see {@link https://oxc.rs/docs/guide/usage/transformer/plugins}
+   */
+  plugins?: PluginsOptions;
+  /**
+   * Configure tsconfig handling.
+   * - true: Auto-discover and load the nearest tsconfig.json
+   * - TsconfigRawOptions: Use the provided inline tsconfig options
+   */
+  tsconfig?: boolean | BindingTsconfigRawOptions;
+  /** An input source map to collapse with the output source map. */
+  inputMap?: SourceMap;
+}
+/** Result of the enhanced transform API. */
+interface BindingEnhancedTransformResult {
+  /**
+   * The transformed code.
+   *
+   * If parsing failed, this will be an empty string.
+   */
+  code: string;
+  /**
+   * The source map for the transformed code.
+   *
+   * This will be set if {@link BindingEnhancedTransformOptions#sourcemap} is `true`.
+   */
+  map?: SourceMap;
+  /**
+   * The `.d.ts` declaration file for the transformed code. Declarations are
+   * only generated if `declaration` is set to `true` and a TypeScript file
+   * is provided.
+   *
+   * If parsing failed and `declaration` is set, this will be an empty string.
+   *
+   * @see {@link TypeScriptOptions#declaration}
+   * @see [declaration tsconfig option](https://www.typescriptlang.org/tsconfig/#declaration)
+   */
+  declaration?: string;
+  /**
+   * Declaration source map. Only generated if both
+   * {@link TypeScriptOptions#declaration declaration} and
+   * {@link BindingEnhancedTransformOptions#sourcemap sourcemap} are set to `true`.
+   */
+  declarationMap?: SourceMap;
+  /**
+   * Helpers used.
+   *
+   * @internal
+   *
+   * Example:
+   *
+   * ```text
+   * { "_objectSpread": "@oxc-project/runtime/helpers/objectSpread2" }
+   * ```
+   */
+  helpersUsed: Record<string, string>;
+  /** Parse and transformation errors. */
+  errors: Array<BindingError>;
+  /** Parse and transformation warnings. */
+  warnings: Array<BindingError>;
+  /** Paths to tsconfig files that were loaded during transformation. */
+  tsconfigFilePaths: Array<string>;
+}
+type BindingError = {
+  type: 'JsError';
+  field0: Error;
+} | {
+  type: 'NativeError';
+  field0: NativeError;
+};
+interface BindingEsmExternalRequirePluginConfig {
+  external: Array<BindingStringOrRegex>;
+  skipDuplicateCheck?: boolean;
+}
+interface BindingHmrBoundaryOutput {
+  boundary: string;
+  acceptedVia: string;
+}
+type BindingHmrUpdate = {
+  type: 'Patch';
+  code: string;
+  filename: string;
+  sourcemap?: string;
+  sourcemapFilename?: string;
+  hmrBoundaries: Array<BindingHmrBoundaryOutput>;
+} | {
+  type: 'FullReload';
+  reason?: string;
+} | {
+  type: 'Noop';
+};
+interface BindingHookResolveIdExtraArgs {
+  custom?: number;
+  isEntry: boolean;
+  /**
+   * - `import-statement`: `import { foo } from './lib.js';`
+   * - `dynamic-import`: `import('./lib.js')`
+   * - `require-call`: `require('./lib.js')`
+   * - `import-rule`: `@import 'bg-color.css'`
+   * - `url-token`: `url('./icon.png')`
+   * - `new-url`: `new URL('./worker.js', import.meta.url)`
+   * - `hot-accept`: `import.meta.hot.accept('./lib.js', () => {})`
+   */
+  kind: 'import-statement' | 'dynamic-import' | 'require-call' | 'import-rule' | 'url-token' | 'new-url' | 'hot-accept';
+}
+interface BindingIndentOptions {
+  exclude?: Array<Array<number>> | Array<number>;
+}
+interface BindingIsolatedDeclarationPluginConfig {
+  stripInternal?: boolean;
+}
+interface BindingLogLocation {
+  /** 1-based */
+  line: number;
+  /** 0-based position in the line in UTF-16 code units */
+  column: number;
+  file?: string;
+}
+interface BindingMagicStringOptions {
+  filename?: string;
+  offset?: number;
+  indentExclusionRanges?: Array<Array<number>> | Array<number>;
+  ignoreList?: boolean;
+}
+interface BindingModulePreloadOptions {
+  polyfill: boolean;
+  resolveDependencies?: (filename: string, deps: string[], context: {
+    hostId: string;
+    hostType: 'html' | 'js';
+  }) => string[];
+}
+interface BindingModules {
+  values: Array<BindingRenderedModule>;
+  keys: Array<string>;
+}
+interface BindingOverwriteOptions {
+  contentOnly?: boolean;
+}
+interface BindingPluginContextResolveOptions {
+  /**
+   * - `import-statement`: `import { foo } from './lib.js';`
+   * - `dynamic-import`: `import('./lib.js')`
+   * - `require-call`: `require('./lib.js')`
+   * - `import-rule`: `@import 'bg-color.css'`
+   * - `url-token`: `url('./icon.png')`
+   * - `new-url`: `new URL('./worker.js', import.meta.url)`
+   * - `hot-accept`: `import.meta.hot.accept('./lib.js', () => {})`
+   */
+  importKind?: 'import-statement' | 'dynamic-import' | 'require-call' | 'import-rule' | 'url-token' | 'new-url' | 'hot-accept';
+  isEntry?: boolean;
+  skipSelf?: boolean;
+  custom?: number;
+  vitePluginCustom?: BindingVitePluginCustom;
+}
+declare enum BindingRebuildStrategy {
+  Always = 0,
+  Auto = 1,
+  Never = 2
+}
+interface BindingRenderBuiltUrlConfig {
+  ssr: boolean;
+  type: 'asset' | 'public';
+  hostId: string;
+  hostType: 'js' | 'css' | 'html';
+}
+interface BindingRenderBuiltUrlRet {
+  relative?: boolean;
+  runtime?: string;
+}
+interface BindingReplacePluginConfig {
+  values: Record<string, string>;
+  delimiters?: [string, string];
+  preventAssignment?: boolean;
+  objectGuards?: boolean;
+  sourcemap?: boolean;
+}
+interface BindingSourceMapOptions {
+  /** The filename for the generated file (goes into `map.file`) */
+  file?: string;
+  /** The filename of the original source (goes into `map.sources`) */
+  source?: string;
+  includeContent?: boolean;
+  /**
+   * Accepts boolean or string: true, false, "boundary"
+   * - true: high-resolution sourcemaps (character-level)
+   * - false: low-resolution sourcemaps (line-level) - default
+   * - "boundary": high-resolution only at word boundaries
+   */
+  hires?: boolean | string;
+}
+interface BindingTransformHookExtraArgs {
+  moduleType: string;
+}
+interface BindingTsconfig {
+  files?: Array<string>;
+  include?: Array<string>;
+  exclude?: Array<string>;
+  compilerOptions: BindingCompilerOptions;
+}
+/**
+ * TypeScript compiler options for inline tsconfig configuration.
+ *
+ * @category Utilities
+ */
+interface BindingTsconfigCompilerOptions {
+  /** Specifies the JSX factory function to use. */
+  jsx?: 'react' | 'react-jsx' | 'react-jsxdev' | 'preserve' | 'react-native';
+  /** Specifies the JSX factory function. */
+  jsxFactory?: string;
+  /** Specifies the JSX fragment factory function. */
+  jsxFragmentFactory?: string;
+  /** Specifies the module specifier for JSX imports. */
+  jsxImportSource?: string;
+  /** Enables experimental decorators. */
+  experimentalDecorators?: boolean;
+  /** Enables decorator metadata emission. */
+  emitDecoratorMetadata?: boolean;
+  /** Preserves module structure of imports/exports. */
+  verbatimModuleSyntax?: boolean;
+  /** Configures how class fields are emitted. */
+  useDefineForClassFields?: boolean;
+  /** The ECMAScript target version. */
+  target?: string;
+  /** @deprecated Use verbatimModuleSyntax instead. */
+  preserveValueImports?: boolean;
+  /** @deprecated Use verbatimModuleSyntax instead. */
+  importsNotUsedAsValues?: 'remove' | 'preserve' | 'error';
+}
+/**
+ * Raw tsconfig options for inline configuration.
+ *
+ * @category Utilities
+ */
+interface BindingTsconfigRawOptions {
+  /** TypeScript compiler options. */
+  compilerOptions?: BindingTsconfigCompilerOptions;
+}
+interface BindingTsconfigResult {
+  tsconfig: BindingTsconfig;
+  tsconfigFilePaths: Array<string>;
+}
+interface BindingUpdateOptions {
+  overwrite?: boolean;
+}
+interface BindingViteBuildImportAnalysisPluginConfig {
+  preloadCode: string;
+  insertPreload: boolean;
+  optimizeModulePreloadRelativePaths: boolean;
+  renderBuiltUrl: boolean;
+  isRelativeBase: boolean;
+  v2?: BindingViteBuildImportAnalysisPluginV2Config;
+}
+interface BindingViteBuildImportAnalysisPluginV2Config {
+  isSsr: boolean;
+  urlBase: string;
+  decodedBase: string;
+  modulePreload: false | BindingModulePreloadOptions;
+  renderBuiltUrl?: (filename: string, type: BindingRenderBuiltUrlConfig) => undefined | string | BindingRenderBuiltUrlRet;
+}
+interface BindingViteDynamicImportVarsPluginConfig {
+  sourcemap?: boolean;
+  include?: Array<BindingStringOrRegex>;
+  exclude?: Array<BindingStringOrRegex>;
+  resolver?: (id: string, importer: string) => MaybePromise<string | undefined>;
+}
+interface BindingViteImportGlobPluginConfig {
+  root?: string;
+  sourcemap?: boolean;
+  restoreQueryExtension?: boolean;
+}
+interface BindingViteJsonPluginConfig {
+  minify?: boolean;
+  namedExports?: boolean;
+  stringify?: BindingViteJsonPluginStringify;
+}
+type BindingViteJsonPluginStringify = boolean | string;
+interface BindingViteManifestPluginConfig {
+  root: string;
+  outPath: string;
+  isEnableV2?: boolean;
+  isLegacy?: (args: BindingNormalizedOptions) => boolean;
+  cssEntries: () => Record<string, string>;
+}
+interface BindingViteModulePreloadPolyfillPluginConfig {
+  isServer?: boolean;
+}
+interface BindingVitePluginCustom {
+  'vite:import-glob'?: ViteImportGlobMeta;
+}
+interface BindingViteReactRefreshWrapperPluginConfig {
+  cwd: string;
+  include?: Array<BindingStringOrRegex>;
+  exclude?: Array<BindingStringOrRegex>;
+  jsxImportSource: string;
+  reactRefreshHost: string;
+}
+interface BindingViteReporterPluginConfig {
+  root: string;
+  isTty: boolean;
+  isLib: boolean;
+  assetsDir: string;
+  chunkLimit: number;
+  warnLargeChunks: boolean;
+  reportCompressedSize: boolean;
+  logInfo?: (msg: string) => void;
+}
+interface BindingViteResolvePluginConfig {
+  resolveOptions: BindingViteResolvePluginResolveOptions;
+  environmentConsumer: string;
+  environmentName: string;
+  builtins: Array<BindingStringOrRegex>;
+  external: true | string[];
+  noExternal: true | Array<string | RegExp>;
+  dedupe: Array<string>;
+  disableCache?: boolean;
+  legacyInconsistentCjsInterop?: boolean;
+  finalizeBareSpecifier?: (resolvedId: string, rawId: string, importer: string | null | undefined) => VoidNullable<string>;
+  finalizeOtherSpecifiers?: (resolvedId: string, rawId: string) => VoidNullable<string>;
+  resolveSubpathImports: (id: string, importer: string, isRequire: boolean, scan: boolean) => VoidNullable<string>;
+  onWarn?: (message: string) => void;
+  onDebug?: (message: string) => void;
+  yarnPnp: boolean;
+}
+interface BindingViteResolvePluginResolveOptions {
+  isBuild: boolean;
+  isProduction: boolean;
+  asSrc: boolean;
+  preferRelative: boolean;
+  isRequire?: boolean;
+  root: string;
+  scan: boolean;
+  mainFields: Array<string>;
+  conditions: Array<string>;
+  externalConditions: Array<string>;
+  extensions: Array<string>;
+  tryIndex: boolean;
+  tryPrefix?: string;
+  preserveSymlinks: boolean;
+  tsconfigPaths: boolean;
+}
+interface BindingViteTransformPluginConfig {
+  root: string;
+  include?: Array<BindingStringOrRegex>;
+  exclude?: Array<BindingStringOrRegex>;
+  jsxRefreshInclude?: Array<BindingStringOrRegex>;
+  jsxRefreshExclude?: Array<BindingStringOrRegex>;
+  isServerConsumer?: boolean;
+  jsxInject?: string;
+  transformOptions?: TransformOptions;
+  yarnPnp?: boolean;
+}
+interface ExternalMemoryStatus {
+  freed: boolean;
+  reason?: string;
+}
+/** Error emitted from native side, it only contains kind and message, no stack trace. */
+interface NativeError {
+  kind: string;
+  message: string;
+  /** The id of the file associated with the error */
+  id?: string;
+  /** The exporter associated with the error (for import/export errors) */
+  exporter?: string;
+  /** Location information (line, column, file) */
+  loc?: BindingLogLocation;
+  /** Position in the source file in UTF-16 code units */
+  pos?: number;
+}
+interface PreRenderedChunk {
+  /** The name of this chunk, which is used in naming patterns. */
+  name: string;
+  /** Whether this chunk is a static entry point. */
+  isEntry: boolean;
+  /** Whether this chunk is a dynamic entry point. */
+  isDynamicEntry: boolean;
+  /** The id of a module that this chunk corresponds to. */
+  facadeModuleId?: string;
+  /** The list of ids of modules included in this chunk. */
+  moduleIds: Array<string>;
+  /** Exported variable names from this chunk. */
+  exports: Array<string>;
+}
+interface ViteImportGlobMeta {
+  isSubImportsPattern?: boolean;
+}
+//#endregion
+export { ExternalMemoryStatus as A, ResolveResult as B, BindingViteManifestPluginConfig as C, BindingViteResolvePluginConfig as D, BindingViteReporterPluginConfig as E, MinifyResult as F, isolatedDeclaration as G, SourceMap as H, NapiResolveOptions as I, isolatedDeclarationSync as K, ParseResult as L, IsolatedDeclarationsResult as M, JsxOptions as N, BindingViteTransformPluginConfig as O, MinifyOptions as P, ParserOptions as R, BindingViteJsonPluginConfig as S, BindingViteReactRefreshWrapperPluginConfig as T, TransformOptions as U, ResolverFactory as V, TsconfigCache as W, BindingTsconfigRawOptions as _, BindingEnhancedTransformOptions as a, BindingViteDynamicImportVarsPluginConfig as b, BindingHookResolveIdExtraArgs as c, BindingPluginContextResolveOptions as d, BindingRebuildStrategy as f, BindingTsconfigCompilerOptions as g, BindingTransformHookExtraArgs as h, BindingClientHmrUpdate as i, IsolatedDeclarationsOptions as j, BindingWatcherBundler as k, BindingIsolatedDeclarationPluginConfig as l, BindingReplacePluginConfig as m, BindingBundleAnalyzerPluginConfig as n, BindingEnhancedTransformResult as o, BindingRenderedChunk as p, moduleRunnerTransform as q, BindingBundleState as r, BindingEsmExternalRequirePluginConfig as s, BindingBuiltinPluginName as t, BindingMagicString as u, BindingTsconfigResult as v, BindingViteModulePreloadPolyfillPluginConfig as w, BindingViteImportGlobPluginConfig as x, BindingViteBuildImportAnalysisPluginConfig as y, PreRenderedChunk as z };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/bindingify-input-options-BnfFBV6b.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/bindingify-input-options-BnfFBV6b.mjs
new file mode 100644
index 0000000..d8155a6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/bindingify-input-options-BnfFBV6b.mjs
@@ -0,0 +1,2233 @@
+import { n as __toESM, t as require_binding } from "./binding-C9S351wt.mjs";
+import { a as logInvalidLogPosition, c as logPluginError, n as error, r as logCycleLoading, t as augmentCodeLocation } from "./logs-D80CXhvg.mjs";
+import { i as bindingifyManifestPlugin, n as BuiltinPlugin, r as bindingifyBuiltInPlugin, t as normalizedStringOrRegex } from "./normalize-string-or-regex-C-WttzRA.mjs";
+import { a as unreachable, o as unsupported, r as noop, t as arraify } from "./misc-DJYbNKZX.mjs";
+import { a as bindingifySourcemap, i as unwrapBindingResult, t as aggregateBindingErrorsIntoJsError } from "./error-CkdMJ9ps.mjs";
+import { parseAst } from "../parse-ast-index.mjs";
+import path from "node:path";
+import * as filter from "@rolldown/pluginutils";
+import fsp from "node:fs/promises";
+//#region package.json
+var version = "1.0.1";
+var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
+//#endregion
+//#region src/constants/version.ts
+/**
+* The version of Rolldown.
+* @example `'1.0.0'`
+*
+* @category Plugin APIs
+*/
+const VERSION = version;
+//#endregion
+//#region src/constants/index.ts
+/**
+* Runtime helper module ID
+*/
+const RUNTIME_MODULE_ID = "\0rolldown/runtime.js";
+//#endregion
+//#region src/log/logging.ts
+const LOG_LEVEL_SILENT = "silent";
+const LOG_LEVEL_ERROR = "error";
+const LOG_LEVEL_WARN = "warn";
+const LOG_LEVEL_INFO = "info";
+const LOG_LEVEL_DEBUG = "debug";
+const logLevelPriority = {
+	[LOG_LEVEL_DEBUG]: 0,
+	[LOG_LEVEL_INFO]: 1,
+	[LOG_LEVEL_WARN]: 2,
+	[LOG_LEVEL_SILENT]: 3
+};
+//#endregion
+//#region src/log/log-handler.ts
+const normalizeLog = (log) => typeof log === "string" ? { message: log } : typeof log === "function" ? normalizeLog(log()) : log;
+function getLogHandler(level, code, logger, pluginName, logLevel) {
+	if (logLevelPriority[level] < logLevelPriority[logLevel]) return noop;
+	return (log, pos) => {
+		if (pos != null) logger(LOG_LEVEL_WARN, logInvalidLogPosition(pluginName));
+		log = normalizeLog(log);
+		if (log.code && !log.pluginCode) log.pluginCode = log.code;
+		log.code = code;
+		log.plugin = pluginName;
+		logger(level, log);
+	};
+}
+//#endregion
+//#region src/utils/normalize-hook.ts
+function normalizeHook(hook) {
+	if (typeof hook === "function" || typeof hook === "string") return {
+		handler: hook,
+		options: {},
+		meta: {}
+	};
+	if (typeof hook === "object" && hook !== null) {
+		const { handler, order, ...options } = hook;
+		return {
+			handler,
+			options,
+			meta: { order }
+		};
+	}
+	unreachable("Invalid hook type");
+}
+//#endregion
+//#region src/plugin/minimal-plugin-context.ts
+var MinimalPluginContextImpl = class {
+	pluginName;
+	hookName;
+	info;
+	warn;
+	debug;
+	meta;
+	constructor(onLog, logLevel, pluginName, watchMode, hookName) {
+		this.pluginName = pluginName;
+		this.hookName = hookName;
+		this.debug = getLogHandler(LOG_LEVEL_DEBUG, "PLUGIN_LOG", onLog, pluginName, logLevel);
+		this.info = getLogHandler(LOG_LEVEL_INFO, "PLUGIN_LOG", onLog, pluginName, logLevel);
+		this.warn = getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", onLog, pluginName, logLevel);
+		this.meta = {
+			rollupVersion: "4.23.0",
+			rolldownVersion: VERSION,
+			watchMode
+		};
+	}
+	error(e) {
+		return error(logPluginError(normalizeLog(e), this.pluginName, { hook: this.hookName }));
+	}
+};
+//#endregion
+//#region src/types/plain-object-like.ts
+const LAZY_FIELDS_KEY = Symbol("__lazy_fields__");
+/**
+* Base class for classes that use `@lazyProp` decorated properties.
+*
+* **Design Pattern in Rolldown:**
+* This is a common pattern in Rolldown due to its three-layer architecture:
+* TypeScript API → NAPI Bindings → Rust Core
+*
+* **Why we use getters:**
+* For performance - to lazily fetch data from Rust bindings only when needed,
+* rather than eagerly fetching all data during object construction.
+*
+* **The problem:**
+* Getters defined on class prototypes are non-enumerable by default, which breaks:
+* - Object spread operators ({...obj})
+* - Object.keys() and similar methods
+* - Standard JavaScript object semantics
+*
+* **The solution:**
+* This base class automatically converts `@lazyProp` decorated getters into
+* own enumerable getters on each instance during construction.
+*
+* **Result:**
+* Objects get both lazy-loading performance benefits AND plain JavaScript object behavior.
+*
+* @example
+* ```typescript
+* class MyClass extends PlainObjectLike {
+*   @lazyProp
+*   get myProp() {
+*     return fetchFromRustBinding();
+*   }
+* }
+* ```
+*/
+var PlainObjectLike = class {
+	constructor() {
+		setupLazyProperties(this);
+	}
+};
+/**
+* Set up lazy properties as own getters on an instance.
+* This is called automatically by the `PlainObjectLike` base class constructor.
+*
+* @param instance - The instance to set up lazy properties on
+* @internal
+*/
+function setupLazyProperties(instance) {
+	const lazyFields = instance.constructor[LAZY_FIELDS_KEY];
+	if (!lazyFields) return;
+	for (const [propertyKey, originalGetter] of lazyFields.entries()) {
+		let cachedValue;
+		let hasValue = false;
+		Object.defineProperty(instance, propertyKey, {
+			get() {
+				if (!hasValue) {
+					cachedValue = originalGetter.call(this);
+					hasValue = true;
+				}
+				return cachedValue;
+			},
+			enumerable: true,
+			configurable: true
+		});
+	}
+}
+/**
+* Get all lazy field names from a class instance.
+*
+* @param instance - Instance to inspect
+* @returns Set of lazy property names
+*/
+function getLazyFields(instance) {
+	const lazyFields = instance.constructor[LAZY_FIELDS_KEY];
+	return lazyFields ? new Set(lazyFields.keys()) : /* @__PURE__ */ new Set();
+}
+//#endregion
+//#region src/decorators/lazy.ts
+/**
+* Decorator that marks a getter as lazy-evaluated and cached.
+*
+* **What "lazy" means here:**
+* 1. Data is lazily fetched from Rust bindings only when the property is accessed (not eagerly on construction)
+* 2. Once fetched, the data is cached for subsequent accesses (performance optimization)
+* 3. Despite being a getter, it behaves like a plain object property (enumerable, appears in Object.keys())
+*
+* **Important**: Properties decorated with `@lazyProp` are defined as own enumerable
+* properties on each instance (not on the prototype). This ensures they:
+* - Appear in Object.keys() and Object.getOwnPropertyNames()
+* - Are included in object spreads ({...obj})
+* - Are enumerable in for...in loops
+*
+* Classes using this decorator must extend `PlainObjectLike` base class.
+*
+* @example
+* ```typescript
+* class MyClass extends PlainObjectLike {
+*   @lazyProp
+*   get expensiveValue() {
+*     return someExpensiveComputation();
+*   }
+* }
+* ```
+*/
+function lazyProp(target, propertyKey, descriptor) {
+	if (!target.constructor[LAZY_FIELDS_KEY]) target.constructor[LAZY_FIELDS_KEY] = /* @__PURE__ */ new Map();
+	const originalGetter = descriptor.get;
+	target.constructor[LAZY_FIELDS_KEY].set(propertyKey, originalGetter);
+	return {
+		enumerable: false,
+		configurable: true
+	};
+}
+//#endregion
+//#region src/utils/asset-source.ts
+function transformAssetSource(bindingAssetSource) {
+	return bindingAssetSource.inner;
+}
+function bindingAssetSource(source) {
+	return { inner: source };
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.130.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/types/output-asset-impl.ts
+var OutputAssetImpl = class extends PlainObjectLike {
+	bindingAsset;
+	type = "asset";
+	constructor(bindingAsset) {
+		super();
+		this.bindingAsset = bindingAsset;
+	}
+	get fileName() {
+		return this.bindingAsset.getFileName();
+	}
+	get originalFileName() {
+		return this.bindingAsset.getOriginalFileName() || null;
+	}
+	get originalFileNames() {
+		return this.bindingAsset.getOriginalFileNames();
+	}
+	get name() {
+		return this.bindingAsset.getName() ?? void 0;
+	}
+	get names() {
+		return this.bindingAsset.getNames();
+	}
+	get source() {
+		return transformAssetSource(this.bindingAsset.getSource());
+	}
+	__rolldown_external_memory_handle__(keepDataAlive) {
+		if (keepDataAlive) this.#evaluateAllLazyFields();
+		return this.bindingAsset.dropInner();
+	}
+	#evaluateAllLazyFields() {
+		for (const field of getLazyFields(this)) this[field];
+	}
+};
+__decorate([lazyProp], OutputAssetImpl.prototype, "fileName", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "originalFileName", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "originalFileNames", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "name", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "names", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "source", null);
+//#endregion
+//#region src/utils/transform-rendered-module.ts
+function transformToRenderedModule(bindingRenderedModule) {
+	return {
+		get code() {
+			return bindingRenderedModule.code;
+		},
+		get renderedLength() {
+			return bindingRenderedModule.code?.length || 0;
+		},
+		get renderedExports() {
+			return bindingRenderedModule.renderedExports;
+		}
+	};
+}
+//#endregion
+//#region src/utils/transform-rendered-chunk.ts
+function transformRenderedChunk(chunk) {
+	let modules = null;
+	return {
+		type: "chunk",
+		get name() {
+			return chunk.name;
+		},
+		get isEntry() {
+			return chunk.isEntry;
+		},
+		get isDynamicEntry() {
+			return chunk.isDynamicEntry;
+		},
+		get facadeModuleId() {
+			return chunk.facadeModuleId;
+		},
+		get moduleIds() {
+			return chunk.moduleIds;
+		},
+		get exports() {
+			return chunk.exports;
+		},
+		get fileName() {
+			return chunk.fileName;
+		},
+		get imports() {
+			return chunk.imports;
+		},
+		get dynamicImports() {
+			return chunk.dynamicImports;
+		},
+		get modules() {
+			if (!modules) modules = transformChunkModules(chunk.modules);
+			return modules;
+		}
+	};
+}
+function transformChunkModules(modules) {
+	const result = {};
+	for (let i = 0; i < modules.values.length; i++) {
+		let key = modules.keys[i];
+		const mod = modules.values[i];
+		result[key] = transformToRenderedModule(mod);
+	}
+	return result;
+}
+//#endregion
+//#region src/types/output-chunk-impl.ts
+var OutputChunkImpl = class extends PlainObjectLike {
+	bindingChunk;
+	type = "chunk";
+	constructor(bindingChunk) {
+		super();
+		this.bindingChunk = bindingChunk;
+	}
+	get fileName() {
+		return this.bindingChunk.getFileName();
+	}
+	get name() {
+		return this.bindingChunk.getName();
+	}
+	get exports() {
+		return this.bindingChunk.getExports();
+	}
+	get isEntry() {
+		return this.bindingChunk.getIsEntry();
+	}
+	get facadeModuleId() {
+		return this.bindingChunk.getFacadeModuleId() || null;
+	}
+	get isDynamicEntry() {
+		return this.bindingChunk.getIsDynamicEntry();
+	}
+	get sourcemapFileName() {
+		return this.bindingChunk.getSourcemapFileName() || null;
+	}
+	get preliminaryFileName() {
+		return this.bindingChunk.getPreliminaryFileName();
+	}
+	get code() {
+		return this.bindingChunk.getCode();
+	}
+	get modules() {
+		return transformChunkModules(this.bindingChunk.getModules());
+	}
+	get imports() {
+		return this.bindingChunk.getImports();
+	}
+	get dynamicImports() {
+		return this.bindingChunk.getDynamicImports();
+	}
+	get moduleIds() {
+		return this.bindingChunk.getModuleIds();
+	}
+	get map() {
+		const mapString = this.bindingChunk.getMap();
+		return mapString ? transformToRollupSourceMap(mapString) : null;
+	}
+	__rolldown_external_memory_handle__(keepDataAlive) {
+		if (keepDataAlive) this.#evaluateAllLazyFields();
+		return this.bindingChunk.dropInner();
+	}
+	#evaluateAllLazyFields() {
+		for (const field of getLazyFields(this)) this[field];
+	}
+};
+__decorate([lazyProp], OutputChunkImpl.prototype, "fileName", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "name", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "exports", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "isEntry", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "facadeModuleId", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "isDynamicEntry", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "sourcemapFileName", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "preliminaryFileName", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "code", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "modules", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "imports", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "dynamicImports", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "moduleIds", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "map", null);
+//#endregion
+//#region src/utils/transform-to-rollup-output.ts
+function transformToRollupSourceMap(map) {
+	const obj = {
+		...JSON.parse(map),
+		toString() {
+			return JSON.stringify(obj);
+		},
+		toUrl() {
+			return `data:application/json;charset=utf-8;base64,${Buffer.from(obj.toString(), "utf-8").toString("base64")}`;
+		}
+	};
+	return obj;
+}
+function transformToRollupOutputChunk(bindingChunk) {
+	return new OutputChunkImpl(bindingChunk);
+}
+function transformToMutableRollupOutputChunk(bindingChunk, changed) {
+	const chunk = {
+		type: "chunk",
+		get code() {
+			return bindingChunk.getCode();
+		},
+		fileName: bindingChunk.getFileName(),
+		name: bindingChunk.getName(),
+		get modules() {
+			return transformChunkModules(bindingChunk.getModules());
+		},
+		get imports() {
+			return bindingChunk.getImports();
+		},
+		get dynamicImports() {
+			return bindingChunk.getDynamicImports();
+		},
+		exports: bindingChunk.getExports(),
+		isEntry: bindingChunk.getIsEntry(),
+		facadeModuleId: bindingChunk.getFacadeModuleId() || null,
+		isDynamicEntry: bindingChunk.getIsDynamicEntry(),
+		get moduleIds() {
+			return bindingChunk.getModuleIds();
+		},
+		get map() {
+			const map = bindingChunk.getMap();
+			return map ? transformToRollupSourceMap(map) : null;
+		},
+		sourcemapFileName: bindingChunk.getSourcemapFileName() || null,
+		preliminaryFileName: bindingChunk.getPreliminaryFileName()
+	};
+	const cache = {};
+	return new Proxy(chunk, {
+		get(target, p) {
+			if (p in cache) return cache[p];
+			const value = target[p];
+			cache[p] = value;
+			return value;
+		},
+		set(_target, p, newValue) {
+			cache[p] = newValue;
+			changed.updated.add(bindingChunk.getFileName());
+			return true;
+		},
+		has(target, p) {
+			if (p in cache) return true;
+			return p in target;
+		}
+	});
+}
+function transformToRollupOutputAsset(bindingAsset) {
+	return new OutputAssetImpl(bindingAsset);
+}
+function transformToMutableRollupOutputAsset(bindingAsset, changed) {
+	const asset = {
+		type: "asset",
+		fileName: bindingAsset.getFileName(),
+		originalFileName: bindingAsset.getOriginalFileName() || null,
+		originalFileNames: bindingAsset.getOriginalFileNames(),
+		get source() {
+			return transformAssetSource(bindingAsset.getSource());
+		},
+		name: bindingAsset.getName() ?? void 0,
+		names: bindingAsset.getNames()
+	};
+	const cache = {};
+	return new Proxy(asset, {
+		get(target, p) {
+			if (p in cache) return cache[p];
+			const value = target[p];
+			cache[p] = value;
+			return value;
+		},
+		set(_target, p, newValue) {
+			cache[p] = newValue;
+			changed.updated.add(bindingAsset.getFileName());
+			return true;
+		}
+	});
+}
+function transformToRollupOutput(output) {
+	const { chunks, assets } = output;
+	return { output: [...chunks.map((chunk) => transformToRollupOutputChunk(chunk)), ...assets.map((asset) => transformToRollupOutputAsset(asset))] };
+}
+function transformToMutableRollupOutput(output, changed) {
+	const { chunks, assets } = output;
+	return { output: [...chunks.map((chunk) => transformToMutableRollupOutputChunk(chunk, changed)), ...assets.map((asset) => transformToMutableRollupOutputAsset(asset, changed))] };
+}
+function transformToOutputBundle(context, output, changed) {
+	const bundle = Object.fromEntries(transformToMutableRollupOutput(output, changed).output.map((item) => [item.fileName, item]));
+	return new Proxy(bundle, {
+		set(_target, _p, _newValue, _receiver) {
+			const originalStackTraceLimit = Error.stackTraceLimit;
+			Error.stackTraceLimit = 2;
+			const message = "This plugin assigns to bundle variable. This is discouraged by Rollup and is not supported by Rolldown. This will be ignored. https://rollupjs.org/plugin-development/#generatebundle:~:text=DANGER,this.emitFile.";
+			const stack = new Error(message).stack ?? message;
+			Error.stackTraceLimit = originalStackTraceLimit;
+			context.warn({
+				message: stack,
+				code: "UNSUPPORTED_BUNDLE_ASSIGNMENT"
+			});
+			return true;
+		},
+		deleteProperty(target, property) {
+			if (typeof property === "string") changed.deleted.add(property);
+			return true;
+		}
+	});
+}
+function collectChangedBundle(changed, bundle) {
+	const changes = {};
+	for (const key in bundle) {
+		if (changed.deleted.has(key) || !changed.updated.has(key)) continue;
+		const item = bundle[key];
+		if (item.type === "asset") changes[key] = {
+			filename: item.fileName,
+			originalFileNames: item.originalFileNames,
+			source: bindingAssetSource(item.source),
+			names: item.names
+		};
+		else changes[key] = {
+			code: item.code,
+			filename: item.fileName,
+			name: item.name,
+			isEntry: item.isEntry,
+			exports: item.exports,
+			modules: {},
+			imports: item.imports,
+			dynamicImports: item.dynamicImports,
+			facadeModuleId: item.facadeModuleId || void 0,
+			isDynamicEntry: item.isDynamicEntry,
+			moduleIds: item.moduleIds,
+			map: bindingifySourcemap(item.map),
+			sourcemapFilename: item.sourcemapFileName || void 0,
+			preliminaryFilename: item.preliminaryFileName
+		};
+	}
+	return {
+		changes,
+		deleted: changed.deleted
+	};
+}
+//#endregion
+//#region src/binding-magic-string.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+Object.defineProperty(import_binding.BindingMagicString.prototype, "isRolldownMagicString", {
+	value: true,
+	writable: false,
+	configurable: false
+});
+function assertString(content, msg) {
+	if (typeof content !== "string") throw new TypeError(msg);
+}
+const nativeAppend = import_binding.BindingMagicString.prototype.append;
+const nativePrepend = import_binding.BindingMagicString.prototype.prepend;
+const nativeAppendLeft = import_binding.BindingMagicString.prototype.appendLeft;
+const nativeAppendRight = import_binding.BindingMagicString.prototype.appendRight;
+const nativePrependLeft = import_binding.BindingMagicString.prototype.prependLeft;
+const nativePrependRight = import_binding.BindingMagicString.prototype.prependRight;
+const nativeOverwrite = import_binding.BindingMagicString.prototype.overwrite;
+const nativeUpdate = import_binding.BindingMagicString.prototype.update;
+import_binding.BindingMagicString.prototype.append = function(content) {
+	assertString(content, "outro content must be a string");
+	return nativeAppend.call(this, content);
+};
+import_binding.BindingMagicString.prototype.prepend = function(content) {
+	assertString(content, "outro content must be a string");
+	return nativePrepend.call(this, content);
+};
+import_binding.BindingMagicString.prototype.appendLeft = function(index, content) {
+	assertString(content, "inserted content must be a string");
+	return nativeAppendLeft.call(this, index, content);
+};
+import_binding.BindingMagicString.prototype.appendRight = function(index, content) {
+	assertString(content, "inserted content must be a string");
+	return nativeAppendRight.call(this, index, content);
+};
+import_binding.BindingMagicString.prototype.prependLeft = function(index, content) {
+	assertString(content, "inserted content must be a string");
+	return nativePrependLeft.call(this, index, content);
+};
+import_binding.BindingMagicString.prototype.prependRight = function(index, content) {
+	assertString(content, "inserted content must be a string");
+	return nativePrependRight.call(this, index, content);
+};
+import_binding.BindingMagicString.prototype.overwrite = function(start, end, content, options) {
+	assertString(content, "replacement content must be a string");
+	return nativeOverwrite.call(this, start, end, content, options);
+};
+import_binding.BindingMagicString.prototype.update = function(start, end, content, options) {
+	assertString(content, "replacement content must be a string");
+	return nativeUpdate.call(this, start, end, content, options);
+};
+const nativeReplace = import_binding.BindingMagicString.prototype.replace;
+const nativeReplaceAll = import_binding.BindingMagicString.prototype.replaceAll;
+import_binding.BindingMagicString.prototype.replace = function(searchValue, replacement) {
+	if (typeof searchValue === "string") return nativeReplace.call(this, searchValue, replacement);
+	if (searchValue.global) searchValue.lastIndex = 0;
+	const lastMatchEnd = this.replaceRegex(searchValue, replacement);
+	if (searchValue.global) searchValue.lastIndex = 0;
+	else if (searchValue.sticky) searchValue.lastIndex = lastMatchEnd === -1 ? 0 : lastMatchEnd;
+	return this;
+};
+import_binding.BindingMagicString.prototype.replaceAll = function(searchValue, replacement) {
+	if (typeof searchValue === "string") return nativeReplaceAll.call(this, searchValue, replacement);
+	if (!searchValue.global) throw new TypeError("MagicString.prototype.replaceAll called with a non-global RegExp argument");
+	searchValue.lastIndex = 0;
+	this.replaceRegex(searchValue, replacement);
+	searchValue.lastIndex = 0;
+	return this;
+};
+/**
+* A native MagicString implementation powered by Rust.
+*
+* @experimental
+*/
+const RolldownMagicString = import_binding.BindingMagicString;
+//#endregion
+//#region src/utils/transform-module-info.ts
+function transformModuleInfo(info, option) {
+	return {
+		get ast() {
+			return unsupported("ModuleInfo#ast");
+		},
+		get code() {
+			return info.code;
+		},
+		id: info.id,
+		importers: info.importers,
+		dynamicImporters: info.dynamicImporters,
+		importedIds: info.importedIds,
+		dynamicallyImportedIds: info.dynamicallyImportedIds,
+		exports: info.exports,
+		isEntry: info.isEntry,
+		inputFormat: info.inputFormat,
+		...option
+	};
+}
+//#endregion
+//#region src/utils/transform-sourcemap.ts
+function isEmptySourcemapFiled(array) {
+	if (!array) return true;
+	if (array.length === 0 || !array[0]) return true;
+	return false;
+}
+function normalizeTransformHookSourcemap(id, originalCode, rawMap) {
+	if (!rawMap) return;
+	let map = typeof rawMap === "object" ? rawMap : JSON.parse(rawMap);
+	if (isEmptySourcemapFiled(map.sourcesContent)) map.sourcesContent = [originalCode];
+	if (isEmptySourcemapFiled(map.sources) || map.sources && map.sources.length === 1 && map.sources[0] !== id) map.sources = [id];
+	return map;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.34.0/node_modules/remeda/dist/lazyDataLastImpl-DtF3cihj.js
+function e(e, t, n) {
+	let r = (n) => e(n, ...t);
+	return n === void 0 ? r : Object.assign(r, {
+		lazy: n,
+		lazyArgs: t
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.34.0/node_modules/remeda/dist/purry.js
+function t$1(t, n, r) {
+	let i = t.length - n.length;
+	if (i === 0) return t(...n);
+	if (i === 1) return e(t, n, r);
+	throw Error(`Wrong number of arguments`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.34.0/node_modules/remeda/dist/partition.js
+function t(...t) {
+	return t$1(n, t);
+}
+const n = (e, t) => {
+	let n = [[], []];
+	for (let [r, i] of e.entries()) t(i, r, e) ? n[0].push(i) : n[1].push(i);
+	return n;
+};
+//#endregion
+//#region src/plugin/bindingify-hook-filter.ts
+function generalHookFilterMatcherToFilterExprs(matcher, stringKind) {
+	if (typeof matcher === "string" || matcher instanceof RegExp) return [filter.include(generateAtomMatcher(stringKind, matcher))];
+	if (Array.isArray(matcher)) return matcher.map((m) => filter.include(generateAtomMatcher(stringKind, m)));
+	let ret = [];
+	if (matcher.exclude) ret.push(...arraify(matcher.exclude).map((m) => filter.exclude(generateAtomMatcher(stringKind, m))));
+	if (matcher.include) ret.push(...arraify(matcher.include).map((m) => filter.include(generateAtomMatcher(stringKind, m))));
+	return ret;
+}
+function generateAtomMatcher(kind, matcher) {
+	return kind === "code" ? filter.code(matcher) : filter.id(matcher);
+}
+function transformFilterMatcherToFilterExprs(filterOption) {
+	if (!filterOption) return;
+	if (Array.isArray(filterOption)) return filterOption;
+	const { id, code, moduleType } = filterOption;
+	let ret = [];
+	let idIncludes = [];
+	let idExcludes = [];
+	let codeIncludes = [];
+	let codeExcludes = [];
+	if (id) [idIncludes, idExcludes] = t(generalHookFilterMatcherToFilterExprs(id, "id") ?? [], (m) => m.kind === "include");
+	if (code) [codeIncludes, codeExcludes] = t(generalHookFilterMatcherToFilterExprs(code, "code") ?? [], (m) => m.kind === "include");
+	ret.push(...idExcludes);
+	ret.push(...codeExcludes);
+	let andExprList = [];
+	if (moduleType) {
+		let moduleTypes = Array.isArray(moduleType) ? moduleType : moduleType.include ?? [];
+		andExprList.push(filter.or(...moduleTypes.map((m) => filter.moduleType(m))));
+	}
+	if (idIncludes.length) andExprList.push(filter.or(...idIncludes.map((item) => item.expr)));
+	if (codeIncludes.length) andExprList.push(filter.or(...codeIncludes.map((item) => item.expr)));
+	if (andExprList.length) ret.push(filter.include(filter.and(...andExprList)));
+	return ret;
+}
+function bindingifyGeneralHookFilter(stringKind, pattern) {
+	let filterExprs = generalHookFilterMatcherToFilterExprs(pattern, stringKind);
+	let ret = [];
+	if (filterExprs) ret = filterExprs.map(bindingifyFilterExpr);
+	return ret.length > 0 ? { value: ret } : void 0;
+}
+function bindingifyFilterExpr(expr) {
+	let list = [];
+	bindingifyFilterExprImpl(expr, list);
+	return list;
+}
+function containsImporterId(expr) {
+	switch (expr.kind) {
+		case "and":
+		case "or": return expr.args.some(containsImporterId);
+		case "not":
+		case "include":
+		case "exclude": return containsImporterId(expr.expr);
+		case "importerId": return true;
+		default: return false;
+	}
+}
+function assertNoImporterId(filterExprs, hookName) {
+	if (filterExprs?.some(containsImporterId)) throw new Error(`The \`importerId\` filter can only be used with the \`resolveId\` hook, but it was used with the \`${hookName}\` hook.`);
+}
+function bindingifyFilterExprImpl(expr, list) {
+	switch (expr.kind) {
+		case "and": {
+			let args = expr.args;
+			for (let i = args.length - 1; i >= 0; i--) bindingifyFilterExprImpl(args[i], list);
+			list.push({
+				kind: "And",
+				payload: args.length
+			});
+			break;
+		}
+		case "or": {
+			let args = expr.args;
+			for (let i = args.length - 1; i >= 0; i--) bindingifyFilterExprImpl(args[i], list);
+			list.push({
+				kind: "Or",
+				payload: args.length
+			});
+			break;
+		}
+		case "not":
+			bindingifyFilterExprImpl(expr.expr, list);
+			list.push({ kind: "Not" });
+			break;
+		case "id":
+			list.push({
+				kind: "Id",
+				payload: expr.pattern
+			});
+			if (expr.params.cleanUrl) list.push({ kind: "CleanUrl" });
+			break;
+		case "importerId":
+			list.push({
+				kind: "ImporterId",
+				payload: expr.pattern
+			});
+			if (expr.params.cleanUrl) list.push({ kind: "CleanUrl" });
+			break;
+		case "moduleType":
+			list.push({
+				kind: "ModuleType",
+				payload: expr.pattern
+			});
+			break;
+		case "code":
+			list.push({
+				kind: "Code",
+				payload: expr.pattern
+			});
+			break;
+		case "include":
+			bindingifyFilterExprImpl(expr.expr, list);
+			list.push({ kind: "Include" });
+			break;
+		case "exclude":
+			bindingifyFilterExprImpl(expr.expr, list);
+			list.push({ kind: "Exclude" });
+			break;
+		case "query":
+			list.push({
+				kind: "QueryKey",
+				payload: expr.key
+			});
+			list.push({
+				kind: "QueryValue",
+				payload: expr.pattern
+			});
+			break;
+		default: throw new Error(`Unknown filter expression: ${expr}`);
+	}
+}
+function bindingifyResolveIdFilter(filterOption) {
+	if (!filterOption) return;
+	if (Array.isArray(filterOption)) return { value: filterOption.map(bindingifyFilterExpr) };
+	return filterOption.id ? bindingifyGeneralHookFilter("id", filterOption.id) : void 0;
+}
+function bindingifyLoadFilter(filterOption) {
+	if (!filterOption) return;
+	if (Array.isArray(filterOption)) {
+		assertNoImporterId(filterOption, "load");
+		return { value: filterOption.map(bindingifyFilterExpr) };
+	}
+	return filterOption.id ? bindingifyGeneralHookFilter("id", filterOption.id) : void 0;
+}
+function bindingifyTransformFilter(filterOption) {
+	if (!filterOption) return;
+	let filterExprs = transformFilterMatcherToFilterExprs(filterOption);
+	assertNoImporterId(filterExprs, "transform");
+	let ret = [];
+	if (filterExprs) ret = filterExprs.map(bindingifyFilterExpr);
+	return { value: ret.length > 0 ? ret : void 0 };
+}
+function bindingifyRenderChunkFilter(filterOption) {
+	if (!filterOption) return;
+	if (Array.isArray(filterOption)) {
+		assertNoImporterId(filterOption, "renderChunk");
+		return { value: filterOption.map(bindingifyFilterExpr) };
+	}
+	return filterOption.code ? bindingifyGeneralHookFilter("code", filterOption.code) : void 0;
+}
+//#endregion
+//#region src/plugin/bindingify-plugin-hook-meta.ts
+function bindingifyPluginHookMeta(options) {
+	return { order: bindingPluginOrder(options.order) };
+}
+function bindingPluginOrder(order) {
+	switch (order) {
+		case "post": return import_binding.BindingPluginOrder.Post;
+		case "pre": return import_binding.BindingPluginOrder.Pre;
+		case null:
+		case void 0: return;
+		default: throw new Error(`Unknown plugin order: ${order}`);
+	}
+}
+//#endregion
+//#region src/plugin/fs.ts
+const fsModule = {
+	appendFile: fsp.appendFile,
+	copyFile: fsp.copyFile,
+	mkdir: fsp.mkdir,
+	mkdtemp: fsp.mkdtemp,
+	readdir: fsp.readdir,
+	readFile: fsp.readFile,
+	realpath: fsp.realpath,
+	rename: fsp.rename,
+	rmdir: fsp.rmdir,
+	stat: fsp.stat,
+	lstat: fsp.lstat,
+	unlink: fsp.unlink,
+	writeFile: fsp.writeFile
+};
+//#endregion
+//#region src/plugin/plugin-context.ts
+var PluginContextImpl = class extends MinimalPluginContextImpl {
+	outputOptions;
+	context;
+	data;
+	onLog;
+	currentLoadingModule;
+	fs = fsModule;
+	getModuleInfo;
+	constructor(outputOptions, context, plugin, data, onLog, logLevel, watchMode, currentLoadingModule) {
+		super(onLog, logLevel, plugin.name, watchMode);
+		this.outputOptions = outputOptions;
+		this.context = context;
+		this.data = data;
+		this.onLog = onLog;
+		this.currentLoadingModule = currentLoadingModule;
+		this.getModuleInfo = (id) => this.data.getModuleInfo(id, context);
+	}
+	async load(options) {
+		const id = options.id;
+		if (id === this.currentLoadingModule) this.onLog(LOG_LEVEL_WARN, logCycleLoading(this.pluginName, this.currentLoadingModule));
+		const moduleInfo = this.data.getModuleInfo(id, this.context);
+		if (moduleInfo && moduleInfo.code !== null) return moduleInfo;
+		const rawOptions = {
+			meta: options.meta || {},
+			moduleSideEffects: options.moduleSideEffects || null,
+			invalidate: false
+		};
+		this.data.updateModuleOption(id, rawOptions);
+		let loadPromise = this.data.loadModulePromiseMap.get(id);
+		if (!loadPromise) {
+			loadPromise = this.context.load(id, options.moduleSideEffects ?? void 0, options.packageJsonPath ?? void 0).catch(() => {
+				this.data.loadModulePromiseMap.delete(id);
+			});
+			this.data.loadModulePromiseMap.set(id, loadPromise);
+		}
+		await loadPromise;
+		return this.data.getModuleInfo(id, this.context);
+	}
+	async resolve(source, importer, options) {
+		let receipt = void 0;
+		if (options != null) receipt = this.data.saveResolveOptions(options);
+		const vitePluginCustom = Object.entries(options?.custom ?? {}).reduce((acc, [key, value]) => {
+			if (key.startsWith("vite:")) (acc ??= {})[key] = value;
+			return acc;
+		}, void 0);
+		const res = await this.context.resolve(source, importer, {
+			importKind: options?.kind,
+			custom: receipt,
+			isEntry: options?.isEntry,
+			skipSelf: options?.skipSelf,
+			vitePluginCustom
+		});
+		if (receipt != null) this.data.removeSavedResolveOptions(receipt);
+		if (res == null) return null;
+		const info = this.data.getModuleOption(res.id) || {};
+		return {
+			...res,
+			external: res.external === "relative" ? unreachable(`The PluginContext resolve result external couldn't be 'relative'`) : res.external,
+			...info,
+			moduleSideEffects: info.moduleSideEffects ?? res.moduleSideEffects ?? null,
+			packageJsonPath: res.packageJsonPath
+		};
+	}
+	emitFile = (file) => {
+		if (file.type === "prebuilt-chunk") return this.context.emitPrebuiltChunk({
+			fileName: file.fileName,
+			name: file.name,
+			code: file.code,
+			exports: file.exports,
+			map: bindingifySourcemap(file.map),
+			sourcemapFileName: file.sourcemapFileName,
+			facadeModuleId: file.facadeModuleId,
+			isEntry: file.isEntry,
+			isDynamicEntry: file.isDynamicEntry
+		});
+		if (file.type === "chunk") return this.context.emitChunk({
+			preserveEntrySignatures: bindingifyPreserveEntrySignatures(file.preserveSignature),
+			...file
+		});
+		const fnSanitizedFileName = file.fileName || typeof this.outputOptions.sanitizeFileName !== "function" ? void 0 : this.outputOptions.sanitizeFileName(file.name || "asset");
+		const filename = file.fileName ? void 0 : this.getAssetFileNames(file);
+		return this.context.emitFile({
+			...file,
+			originalFileName: file.originalFileName || void 0,
+			source: bindingAssetSource(file.source)
+		}, filename, fnSanitizedFileName);
+	};
+	getAssetFileNames(file) {
+		if (typeof this.outputOptions.assetFileNames === "function") return this.outputOptions.assetFileNames({
+			type: "asset",
+			name: file.name,
+			names: file.name ? [file.name] : [],
+			originalFileName: file.originalFileName,
+			originalFileNames: file.originalFileName ? [file.originalFileName] : [],
+			source: file.source
+		});
+	}
+	getFileName(referenceId) {
+		return this.context.getFileName(referenceId);
+	}
+	getModuleIds() {
+		return this.data.getModuleIds(this.context);
+	}
+	addWatchFile(id) {
+		this.context.addWatchFile(id);
+	}
+	parse(input, options) {
+		return parseAst(input, options);
+	}
+};
+//#endregion
+//#region src/plugin/load-plugin-context.ts
+var LoadPluginContextImpl = class extends PluginContextImpl {
+	inner;
+	constructor(outputOptions, context, plugin, data, inner, moduleId, onLog, logLevelOption, watchMode) {
+		super(outputOptions, context, plugin, data, onLog, logLevelOption, watchMode, moduleId);
+		this.inner = inner;
+	}
+	addWatchFile(id) {
+		this.inner.addWatchFile(id);
+	}
+};
+//#endregion
+//#region src/plugin/transform-plugin-context.ts
+var TransformPluginContextImpl = class extends PluginContextImpl {
+	inner;
+	moduleId;
+	moduleSource;
+	constructor(outputOptions, context, plugin, data, inner, moduleId, moduleSource, onLog, LogLevelOption, watchMode) {
+		super(outputOptions, context, plugin, data, onLog, LogLevelOption, watchMode, moduleId);
+		this.inner = inner;
+		this.moduleId = moduleId;
+		this.moduleSource = moduleSource;
+		const getLogHandler = (handler) => (log, pos) => {
+			log = normalizeLog(log);
+			if (pos) augmentCodeLocation(log, pos, moduleSource, moduleId);
+			log.id = moduleId;
+			log.hook = "transform";
+			handler(log);
+		};
+		this.debug = getLogHandler(this.debug);
+		this.warn = getLogHandler(this.warn);
+		this.info = getLogHandler(this.info);
+	}
+	error(e, pos) {
+		if (typeof e === "string") e = { message: e };
+		if (pos) augmentCodeLocation(e, pos, this.moduleSource, this.moduleId);
+		e.id = this.moduleId;
+		e.hook = "transform";
+		return error(logPluginError(normalizeLog(e), this.pluginName));
+	}
+	getCombinedSourcemap() {
+		return JSON.parse(this.inner.getCombinedSourcemap());
+	}
+	addWatchFile(id) {
+		this.inner.addWatchFile(id);
+	}
+	sendMagicString(s) {
+		this.inner.sendMagicString(s);
+	}
+};
+//#endregion
+//#region src/plugin/bindingify-build-hooks.ts
+function createPluginContext(args, ctx) {
+	return new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode);
+}
+function bindingifyBuildStart(args) {
+	const hook = args.plugin.buildStart;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, opts) => {
+			await handler.call(createPluginContext(args, ctx), args.pluginContextData.getInputOptions(opts));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyBuildEnd(args) {
+	const hook = args.plugin.buildEnd;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, err) => {
+			await handler.call(createPluginContext(args, ctx), err ? aggregateBindingErrorsIntoJsError(err) : void 0);
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyResolveId(args) {
+	const hook = args.plugin.resolveId;
+	if (!hook) return {};
+	const { handler, meta, options } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, specifier, importer, extraOptions) => {
+			const contextResolveOptions = extraOptions.custom != null ? args.pluginContextData.getSavedResolveOptions(extraOptions.custom) : void 0;
+			const ret = await handler.call(createPluginContext(args, ctx), specifier, importer ?? void 0, {
+				...extraOptions,
+				custom: contextResolveOptions?.custom
+			});
+			if (ret == null) return;
+			if (ret === false) return {
+				id: specifier,
+				external: true,
+				normalizeExternalId: true
+			};
+			if (typeof ret === "string") return {
+				id: ret,
+				normalizeExternalId: false
+			};
+			let exist = args.pluginContextData.updateModuleOption(ret.id, {
+				meta: ret.meta || {},
+				moduleSideEffects: ret.moduleSideEffects ?? null,
+				invalidate: false
+			});
+			return {
+				id: ret.id,
+				external: ret.external,
+				normalizeExternalId: false,
+				moduleSideEffects: exist.moduleSideEffects ?? void 0,
+				packageJsonPath: ret.packageJsonPath
+			};
+		},
+		meta: bindingifyPluginHookMeta(meta),
+		filter: bindingifyResolveIdFilter(options.filter)
+	};
+}
+function bindingifyResolveDynamicImport(args) {
+	const hook = args.plugin.resolveDynamicImport;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, specifier, importer) => {
+			const ret = await handler.call(createPluginContext(args, ctx), specifier, importer ?? void 0);
+			if (ret == null) return;
+			if (ret === false) return {
+				id: specifier,
+				external: true
+			};
+			if (typeof ret === "string") return { id: ret };
+			const result = {
+				id: ret.id,
+				external: ret.external,
+				packageJsonPath: ret.packageJsonPath
+			};
+			if (ret.moduleSideEffects !== null) result.moduleSideEffects = ret.moduleSideEffects;
+			args.pluginContextData.updateModuleOption(ret.id, {
+				meta: ret.meta || {},
+				moduleSideEffects: ret.moduleSideEffects || null,
+				invalidate: false
+			});
+			return result;
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyTransform(args) {
+	const hook = args.plugin.transform;
+	if (!hook) return {};
+	const { handler, meta, options } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, code, id, meta) => {
+			let magicStringInstance, astInstance;
+			Object.defineProperties(meta, {
+				magicString: { get() {
+					if (magicStringInstance) return magicStringInstance;
+					magicStringInstance = new RolldownMagicString(code);
+					return magicStringInstance;
+				} },
+				ast: { get() {
+					if (astInstance) return astInstance;
+					let lang = "js";
+					switch (meta.moduleType) {
+						case "js":
+						case "jsx":
+						case "ts":
+						case "tsx":
+							lang = meta.moduleType;
+							break;
+						default: break;
+					}
+					astInstance = parseAst(code, {
+						astType: meta.moduleType.includes("ts") ? "ts" : "js",
+						lang
+					});
+					return astInstance;
+				} }
+			});
+			const transformCtx = new TransformPluginContextImpl(args.outputOptions, ctx.inner(), args.plugin, args.pluginContextData, ctx, id, code, args.onLog, args.logLevel, args.watchMode);
+			const ret = await handler.call(transformCtx, code, id, meta);
+			if (ret == null) return;
+			if (typeof ret === "string") return { code: ret };
+			let moduleOption = args.pluginContextData.updateModuleOption(id, {
+				meta: ret.meta ?? {},
+				moduleSideEffects: ret.moduleSideEffects ?? null,
+				invalidate: false
+			});
+			let normalizedCode = void 0;
+			let map = ret.map;
+			if (typeof ret.code === "string") normalizedCode = ret.code;
+			else if (ret.code instanceof RolldownMagicString) {
+				let magicString = ret.code;
+				normalizedCode = magicString.toString();
+				let fallbackSourcemap = ctx.sendMagicString(magicString);
+				if (fallbackSourcemap != void 0) map = fallbackSourcemap;
+			}
+			return {
+				code: normalizedCode,
+				map: bindingifySourcemap(normalizeTransformHookSourcemap(id, code, map)),
+				moduleSideEffects: moduleOption.moduleSideEffects ?? void 0,
+				moduleType: ret.moduleType
+			};
+		},
+		meta: bindingifyPluginHookMeta(meta),
+		filter: bindingifyTransformFilter(options.filter)
+	};
+}
+function bindingifyLoad(args) {
+	const hook = args.plugin.load;
+	if (!hook) return {};
+	const { handler, meta, options } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, id) => {
+			const ret = await handler.call(new LoadPluginContextImpl(args.outputOptions, ctx.inner(), args.plugin, args.pluginContextData, ctx, id, args.onLog, args.logLevel, args.watchMode), id);
+			if (ret == null) return;
+			if (typeof ret === "string") return { code: ret };
+			let moduleOption = args.pluginContextData.updateModuleOption(id, {
+				meta: ret.meta || {},
+				moduleSideEffects: ret.moduleSideEffects ?? null,
+				invalidate: false
+			});
+			let map = preProcessSourceMap(ret, id);
+			return {
+				code: ret.code,
+				map: bindingifySourcemap(map),
+				moduleType: ret.moduleType,
+				moduleSideEffects: moduleOption.moduleSideEffects ?? void 0
+			};
+		},
+		meta: bindingifyPluginHookMeta(meta),
+		filter: bindingifyLoadFilter(options.filter)
+	};
+}
+function preProcessSourceMap(ret, id) {
+	if (!ret.map) return;
+	let map = typeof ret.map === "object" ? ret.map : JSON.parse(ret.map);
+	if (!isEmptySourcemapFiled(map.sources)) {
+		const directory = path.dirname(id) || ".";
+		const sourceRoot = map.sourceRoot || ".";
+		map.sources = map.sources.map((source) => path.resolve(directory, sourceRoot, source));
+	}
+	return map;
+}
+function bindingifyModuleParsed(args) {
+	const hook = args.plugin.moduleParsed;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, moduleInfo) => {
+			await handler.call(createPluginContext(args, ctx), transformModuleInfo(moduleInfo, args.pluginContextData.getModuleOption(moduleInfo.id)));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+//#endregion
+//#region src/plugin/bindingify-output-hooks.ts
+function bindingifyRenderStart(args) {
+	const hook = args.plugin.renderStart;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, opts) => {
+			handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), args.pluginContextData.getOutputOptions(opts), args.pluginContextData.getInputOptions(opts));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyRenderChunk(args) {
+	const hook = args.plugin.renderChunk;
+	if (!hook) return {};
+	const { handler, meta, options } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, code, chunk, opts, meta) => {
+			if (args.pluginContextData.getRenderChunkMeta() == null) args.pluginContextData.setRenderChunkMeta({ chunks: Object.fromEntries(Object.entries(meta.chunks).map(([key, value]) => [key, transformRenderedChunk(value)])) });
+			const renderChunkMeta = args.pluginContextData.getRenderChunkMeta();
+			let magicStringInstance;
+			if (args.options.experimental?.nativeMagicString) Object.defineProperty(renderChunkMeta, "magicString", {
+				get() {
+					if (magicStringInstance) return magicStringInstance;
+					magicStringInstance = new RolldownMagicString(code);
+					return magicStringInstance;
+				},
+				configurable: true
+			});
+			const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), code, transformRenderedChunk(chunk), args.pluginContextData.getOutputOptions(opts), renderChunkMeta);
+			if (ret == null) return;
+			if (ret instanceof RolldownMagicString) {
+				const normalizedCode = ret.toString();
+				const generatedMap = ret.generateMap();
+				return {
+					code: normalizedCode,
+					map: bindingifySourcemap({
+						file: generatedMap.file,
+						mappings: generatedMap.mappings,
+						names: generatedMap.names,
+						sources: generatedMap.sources,
+						sourcesContent: generatedMap.sourcesContent.map((s) => s ?? null)
+					})
+				};
+			}
+			if (typeof ret === "string") return { code: ret };
+			if (ret.code instanceof RolldownMagicString) {
+				const magicString = ret.code;
+				const normalizedCode = magicString.toString();
+				if (ret.map === null) return { code: normalizedCode };
+				if (ret.map === void 0) {
+					const generatedMap = magicString.generateMap();
+					return {
+						code: normalizedCode,
+						map: bindingifySourcemap({
+							file: generatedMap.file,
+							mappings: generatedMap.mappings,
+							names: generatedMap.names,
+							sources: generatedMap.sources,
+							sourcesContent: generatedMap.sourcesContent.map((s) => s ?? null)
+						})
+					};
+				}
+				return {
+					code: normalizedCode,
+					map: bindingifySourcemap(ret.map)
+				};
+			}
+			if (!ret.map) return { code: ret.code };
+			return {
+				code: ret.code,
+				map: bindingifySourcemap(ret.map)
+			};
+		},
+		meta: bindingifyPluginHookMeta(meta),
+		filter: bindingifyRenderChunkFilter(options.filter)
+	};
+}
+function bindingifyAugmentChunkHash(args) {
+	const hook = args.plugin.augmentChunkHash;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, chunk) => {
+			return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyRenderError(args) {
+	const hook = args.plugin.renderError;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, err) => {
+			handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), aggregateBindingErrorsIntoJsError(err));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyGenerateBundle(args) {
+	const hook = args.plugin.generateBundle;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, bundle, isWrite, opts) => {
+			const changed = {
+				updated: /* @__PURE__ */ new Set(),
+				deleted: /* @__PURE__ */ new Set()
+			};
+			const context = new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode);
+			const output = transformToOutputBundle(context, unwrapBindingResult(bundle), changed);
+			await handler.call(context, args.pluginContextData.getOutputOptions(opts), output, isWrite);
+			return collectChangedBundle(changed, output);
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyWriteBundle(args) {
+	const hook = args.plugin.writeBundle;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, bundle, opts) => {
+			const changed = {
+				updated: /* @__PURE__ */ new Set(),
+				deleted: /* @__PURE__ */ new Set()
+			};
+			const context = new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode);
+			const output = transformToOutputBundle(context, unwrapBindingResult(bundle), changed);
+			await handler.call(context, args.pluginContextData.getOutputOptions(opts), output);
+			return collectChangedBundle(changed, output);
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyCloseBundle(args) {
+	const hook = args.plugin.closeBundle;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, err) => {
+			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), err ? aggregateBindingErrorsIntoJsError(err) : void 0);
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyBanner(args) {
+	const hook = args.plugin.banner;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, chunk) => {
+			if (typeof handler === "string") return handler;
+			return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyFooter(args) {
+	const hook = args.plugin.footer;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, chunk) => {
+			if (typeof handler === "string") return handler;
+			return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyIntro(args) {
+	const hook = args.plugin.intro;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, chunk) => {
+			if (typeof handler === "string") return handler;
+			return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyOutro(args) {
+	const hook = args.plugin.outro;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, chunk) => {
+			if (typeof handler === "string") return handler;
+			return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+//#endregion
+//#region src/plugin/bindingify-watch-hooks.ts
+function bindingifyWatchChange(args) {
+	const hook = args.plugin.watchChange;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx, id, event) => {
+			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), id, { event });
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+function bindingifyCloseWatcher(args) {
+	const hook = args.plugin.closeWatcher;
+	if (!hook) return {};
+	const { handler, meta } = normalizeHook(hook);
+	return {
+		plugin: async (ctx) => {
+			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode));
+		},
+		meta: bindingifyPluginHookMeta(meta)
+	};
+}
+//#endregion
+//#region src/plugin/generated/hook-usage.ts
+var HookUsage = class {
+	bitflag = BigInt(0);
+	constructor() {}
+	union(kind) {
+		this.bitflag |= BigInt(kind);
+	}
+	inner() {
+		return Number(this.bitflag);
+	}
+};
+function extractHookUsage(plugin) {
+	let hookUsage = new HookUsage();
+	if (plugin.buildStart) hookUsage.union(1);
+	if (plugin.resolveId) hookUsage.union(2);
+	if (plugin.resolveDynamicImport) hookUsage.union(4);
+	if (plugin.load) hookUsage.union(8);
+	if (plugin.transform) hookUsage.union(16);
+	if (plugin.moduleParsed) hookUsage.union(32);
+	if (plugin.buildEnd) hookUsage.union(64);
+	if (plugin.renderStart) hookUsage.union(128);
+	if (plugin.renderError) hookUsage.union(256);
+	if (plugin.renderChunk) hookUsage.union(512);
+	if (plugin.augmentChunkHash) hookUsage.union(1024);
+	if (plugin.generateBundle) hookUsage.union(2048);
+	if (plugin.writeBundle) hookUsage.union(4096);
+	if (plugin.closeBundle) hookUsage.union(8192);
+	if (plugin.watchChange) hookUsage.union(16384);
+	if (plugin.closeWatcher) hookUsage.union(32768);
+	if (plugin.banner) hookUsage.union(131072);
+	if (plugin.footer) hookUsage.union(262144);
+	if (plugin.intro) hookUsage.union(524288);
+	if (plugin.outro) hookUsage.union(1048576);
+	return hookUsage;
+}
+//#endregion
+//#region src/plugin/bindingify-plugin.ts
+function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode) {
+	const args = {
+		plugin,
+		options,
+		outputOptions,
+		pluginContextData,
+		onLog,
+		logLevel,
+		watchMode,
+		normalizedOutputPlugins
+	};
+	const { plugin: buildStart, meta: buildStartMeta } = bindingifyBuildStart(args);
+	const { plugin: resolveId, meta: resolveIdMeta, filter: resolveIdFilter } = bindingifyResolveId(args);
+	const { plugin: resolveDynamicImport, meta: resolveDynamicImportMeta } = bindingifyResolveDynamicImport(args);
+	const { plugin: buildEnd, meta: buildEndMeta } = bindingifyBuildEnd(args);
+	const { plugin: transform, meta: transformMeta, filter: transformFilter } = bindingifyTransform(args);
+	const { plugin: moduleParsed, meta: moduleParsedMeta } = bindingifyModuleParsed(args);
+	const { plugin: load, meta: loadMeta, filter: loadFilter } = bindingifyLoad(args);
+	const { plugin: renderChunk, meta: renderChunkMeta, filter: renderChunkFilter } = bindingifyRenderChunk(args);
+	const { plugin: augmentChunkHash, meta: augmentChunkHashMeta } = bindingifyAugmentChunkHash(args);
+	const { plugin: renderStart, meta: renderStartMeta } = bindingifyRenderStart(args);
+	const { plugin: renderError, meta: renderErrorMeta } = bindingifyRenderError(args);
+	const { plugin: generateBundle, meta: generateBundleMeta } = bindingifyGenerateBundle(args);
+	const { plugin: writeBundle, meta: writeBundleMeta } = bindingifyWriteBundle(args);
+	const { plugin: closeBundle, meta: closeBundleMeta } = bindingifyCloseBundle(args);
+	const { plugin: banner, meta: bannerMeta } = bindingifyBanner(args);
+	const { plugin: footer, meta: footerMeta } = bindingifyFooter(args);
+	const { plugin: intro, meta: introMeta } = bindingifyIntro(args);
+	const { plugin: outro, meta: outroMeta } = bindingifyOutro(args);
+	const { plugin: watchChange, meta: watchChangeMeta } = bindingifyWatchChange(args);
+	const { plugin: closeWatcher, meta: closeWatcherMeta } = bindingifyCloseWatcher(args);
+	let hookUsage = extractHookUsage(plugin).inner();
+	return wrapHandlers({
+		name: plugin.name,
+		buildStart,
+		buildStartMeta,
+		resolveId,
+		resolveIdMeta,
+		resolveIdFilter,
+		resolveDynamicImport,
+		resolveDynamicImportMeta,
+		buildEnd,
+		buildEndMeta,
+		transform,
+		transformMeta,
+		transformFilter,
+		moduleParsed,
+		moduleParsedMeta,
+		load,
+		loadMeta,
+		loadFilter,
+		renderChunk,
+		renderChunkMeta,
+		renderChunkFilter,
+		augmentChunkHash,
+		augmentChunkHashMeta,
+		renderStart,
+		renderStartMeta,
+		renderError,
+		renderErrorMeta,
+		generateBundle,
+		generateBundleMeta,
+		writeBundle,
+		writeBundleMeta,
+		closeBundle,
+		closeBundleMeta,
+		banner,
+		bannerMeta,
+		footer,
+		footerMeta,
+		intro,
+		introMeta,
+		outro,
+		outroMeta,
+		watchChange,
+		watchChangeMeta,
+		closeWatcher,
+		closeWatcherMeta,
+		hookUsage
+	});
+}
+function wrapHandlers(plugin) {
+	for (const hookName of [
+		"buildStart",
+		"resolveId",
+		"resolveDynamicImport",
+		"buildEnd",
+		"transform",
+		"moduleParsed",
+		"load",
+		"renderChunk",
+		"augmentChunkHash",
+		"renderStart",
+		"renderError",
+		"generateBundle",
+		"writeBundle",
+		"closeBundle",
+		"banner",
+		"footer",
+		"intro",
+		"outro",
+		"watchChange",
+		"closeWatcher"
+	]) {
+		const handler = plugin[hookName];
+		if (handler) plugin[hookName] = async (...args) => {
+			try {
+				return await handler(...args);
+			} catch (e) {
+				return error(logPluginError(e, plugin.name, {
+					hook: hookName,
+					id: hookName === "transform" ? args[2] : void 0
+				}));
+			}
+		};
+	}
+	return plugin;
+}
+//#endregion
+//#region src/options/normalized-input-options.ts
+var NormalizedInputOptionsImpl = class extends PlainObjectLike {
+	onLog;
+	inputPlugins;
+	inner;
+	constructor(inner, onLog, inputPlugins) {
+		super();
+		this.onLog = onLog;
+		this.inputPlugins = inputPlugins;
+		this.inner = inner;
+	}
+	get shimMissingExports() {
+		return this.inner.shimMissingExports;
+	}
+	get input() {
+		return this.inner.input;
+	}
+	get cwd() {
+		return this.inner.cwd;
+	}
+	get platform() {
+		return this.inner.platform;
+	}
+	get context() {
+		return this.inner.context;
+	}
+	get plugins() {
+		return this.inputPlugins;
+	}
+};
+__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "shimMissingExports", null);
+__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "input", null);
+__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "cwd", null);
+__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "platform", null);
+__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "context", null);
+//#endregion
+//#region src/options/normalized-output-options.ts
+var NormalizedOutputOptionsImpl = class extends PlainObjectLike {
+	inner;
+	outputOptions;
+	normalizedOutputPlugins;
+	constructor(inner, outputOptions, normalizedOutputPlugins) {
+		super();
+		this.inner = inner;
+		this.outputOptions = outputOptions;
+		this.normalizedOutputPlugins = normalizedOutputPlugins;
+	}
+	get dir() {
+		return this.inner.dir ?? void 0;
+	}
+	get entryFileNames() {
+		return this.inner.entryFilenames || this.outputOptions.entryFileNames;
+	}
+	get chunkFileNames() {
+		return this.inner.chunkFilenames || this.outputOptions.chunkFileNames;
+	}
+	get assetFileNames() {
+		return this.inner.assetFilenames || this.outputOptions.assetFileNames;
+	}
+	get format() {
+		return this.inner.format;
+	}
+	get exports() {
+		return this.inner.exports;
+	}
+	get sourcemap() {
+		return this.inner.sourcemap;
+	}
+	get sourcemapBaseUrl() {
+		return this.inner.sourcemapBaseUrl ?? void 0;
+	}
+	get shimMissingExports() {
+		return this.inner.shimMissingExports;
+	}
+	get name() {
+		return this.inner.name ?? void 0;
+	}
+	get file() {
+		return this.inner.file ?? void 0;
+	}
+	get codeSplitting() {
+		return this.inner.codeSplitting;
+	}
+	/**
+	* @deprecated Use `codeSplitting` instead.
+	*/
+	get inlineDynamicImports() {
+		return !this.inner.codeSplitting;
+	}
+	get dynamicImportInCjs() {
+		return this.inner.dynamicImportInCjs;
+	}
+	get externalLiveBindings() {
+		return this.inner.externalLiveBindings;
+	}
+	get banner() {
+		return normalizeAddon(this.outputOptions.banner);
+	}
+	get footer() {
+		return normalizeAddon(this.outputOptions.footer);
+	}
+	get postBanner() {
+		return normalizeAddon(this.outputOptions.postBanner);
+	}
+	get postFooter() {
+		return normalizeAddon(this.outputOptions.postFooter);
+	}
+	get intro() {
+		return normalizeAddon(this.outputOptions.intro);
+	}
+	get outro() {
+		return normalizeAddon(this.outputOptions.outro);
+	}
+	get esModule() {
+		return this.inner.esModule;
+	}
+	get extend() {
+		return this.inner.extend;
+	}
+	get globals() {
+		return this.inner.globals || this.outputOptions.globals;
+	}
+	get paths() {
+		return this.outputOptions.paths;
+	}
+	get hashCharacters() {
+		return this.inner.hashCharacters;
+	}
+	get sourcemapDebugIds() {
+		return this.inner.sourcemapDebugIds;
+	}
+	get sourcemapExcludeSources() {
+		return this.inner.sourcemapExcludeSources;
+	}
+	get sourcemapIgnoreList() {
+		return this.outputOptions.sourcemapIgnoreList;
+	}
+	get sourcemapPathTransform() {
+		return this.outputOptions.sourcemapPathTransform;
+	}
+	get minify() {
+		let ret = this.inner.minify;
+		if (typeof ret === "object" && ret !== null) {
+			delete ret["codegen"];
+			delete ret["module"];
+			delete ret["sourcemap"];
+		}
+		return ret;
+	}
+	get legalComments() {
+		return this.inner.legalComments;
+	}
+	get comments() {
+		const c = this.inner.comments;
+		return {
+			legal: c.legal ?? true,
+			annotation: c.annotation ?? true,
+			jsdoc: c.jsdoc ?? true
+		};
+	}
+	get polyfillRequire() {
+		return this.inner.polyfillRequire;
+	}
+	get plugins() {
+		return this.normalizedOutputPlugins;
+	}
+	get preserveModules() {
+		return this.inner.preserveModules;
+	}
+	get preserveModulesRoot() {
+		return this.inner.preserveModulesRoot;
+	}
+	get virtualDirname() {
+		return this.inner.virtualDirname;
+	}
+	get topLevelVar() {
+		return this.inner.topLevelVar ?? false;
+	}
+	get minifyInternalExports() {
+		return this.inner.minifyInternalExports ?? false;
+	}
+};
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "dir", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "entryFileNames", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "chunkFileNames", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "assetFileNames", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "format", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "exports", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemap", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemapBaseUrl", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "shimMissingExports", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "name", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "file", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "codeSplitting", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "inlineDynamicImports", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "dynamicImportInCjs", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "externalLiveBindings", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "banner", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "footer", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "postBanner", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "postFooter", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "intro", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "outro", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "esModule", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "extend", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "globals", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "paths", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "hashCharacters", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemapDebugIds", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemapExcludeSources", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemapIgnoreList", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemapPathTransform", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "minify", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "legalComments", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "comments", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "polyfillRequire", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "plugins", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "preserveModules", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "preserveModulesRoot", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "virtualDirname", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "topLevelVar", null);
+__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "minifyInternalExports", null);
+function normalizeAddon(value) {
+	if (typeof value === "function") return value;
+	return () => value || "";
+}
+//#endregion
+//#region src/plugin/plugin-context-data.ts
+var PluginContextData = class {
+	onLog;
+	outputOptions;
+	normalizedInputPlugins;
+	normalizedOutputPlugins;
+	moduleOptionMap = /* @__PURE__ */ new Map();
+	resolveOptionsMap = /* @__PURE__ */ new Map();
+	loadModulePromiseMap = /* @__PURE__ */ new Map();
+	renderedChunkMeta = null;
+	normalizedInputOptions = null;
+	normalizedOutputOptions = null;
+	constructor(onLog, outputOptions, normalizedInputPlugins, normalizedOutputPlugins) {
+		this.onLog = onLog;
+		this.outputOptions = outputOptions;
+		this.normalizedInputPlugins = normalizedInputPlugins;
+		this.normalizedOutputPlugins = normalizedOutputPlugins;
+	}
+	updateModuleOption(id, option) {
+		const existing = this.moduleOptionMap.get(id);
+		if (existing) {
+			if (option.moduleSideEffects != null) existing.moduleSideEffects = option.moduleSideEffects;
+			if (option.meta != null) Object.assign(existing.meta, option.meta);
+			if (option.invalidate != null) existing.invalidate = option.invalidate;
+		} else {
+			this.moduleOptionMap.set(id, option);
+			return option;
+		}
+		return existing;
+	}
+	getModuleOption(id) {
+		const option = this.moduleOptionMap.get(id);
+		if (!option) {
+			const raw = {
+				moduleSideEffects: null,
+				meta: {}
+			};
+			this.moduleOptionMap.set(id, raw);
+			return raw;
+		}
+		return option;
+	}
+	getModuleInfo(id, context) {
+		const bindingInfo = context.getModuleInfo(id);
+		if (bindingInfo) {
+			const info = transformModuleInfo(bindingInfo, this.getModuleOption(id));
+			return this.proxyModuleInfo(id, info);
+		}
+		return null;
+	}
+	proxyModuleInfo(id, info) {
+		let moduleSideEffects = info.moduleSideEffects;
+		Object.defineProperty(info, "moduleSideEffects", {
+			get() {
+				return moduleSideEffects;
+			},
+			set: (v) => {
+				this.updateModuleOption(id, {
+					moduleSideEffects: v,
+					meta: info.meta,
+					invalidate: true
+				});
+				moduleSideEffects = v;
+			}
+		});
+		return info;
+	}
+	getModuleIds(context) {
+		return context.getModuleIds().values();
+	}
+	saveResolveOptions(options) {
+		const index = this.resolveOptionsMap.size;
+		this.resolveOptionsMap.set(index, options);
+		return index;
+	}
+	getSavedResolveOptions(receipt) {
+		return this.resolveOptionsMap.get(receipt);
+	}
+	removeSavedResolveOptions(receipt) {
+		this.resolveOptionsMap.delete(receipt);
+	}
+	setRenderChunkMeta(meta) {
+		this.renderedChunkMeta = meta;
+	}
+	getRenderChunkMeta() {
+		return this.renderedChunkMeta;
+	}
+	getInputOptions(opts) {
+		this.normalizedInputOptions ??= new NormalizedInputOptionsImpl(opts, this.onLog, this.normalizedInputPlugins);
+		return this.normalizedInputOptions;
+	}
+	getOutputOptions(opts) {
+		this.normalizedOutputOptions ??= new NormalizedOutputOptionsImpl(opts, this.outputOptions, this.normalizedOutputPlugins);
+		return this.normalizedOutputOptions;
+	}
+	clear() {
+		this.renderedChunkMeta = null;
+		this.loadModulePromiseMap.clear();
+	}
+};
+//#endregion
+//#region src/utils/normalize-transform-options.ts
+/**
+* Normalizes transform options by extracting `define`, `inject`, and `dropLabels` separately from OXC transform options.
+*
+* Prioritizes values from `transform.define`, `transform.inject`, and `transform.dropLabels` over deprecated top-level options.
+*/
+function normalizeTransformOptions(inputOptions) {
+	const transform = inputOptions.transform;
+	const define = transform?.define ? Object.entries(transform.define) : void 0;
+	const inject = transform?.inject;
+	const dropLabels = transform?.dropLabels;
+	let oxcTransformOptions;
+	if (transform) {
+		const { define: _define, inject: _inject, dropLabels: _dropLabels, ...rest } = transform;
+		if (Object.keys(rest).length > 0) {
+			if (rest.jsx === false) rest.jsx = "disable";
+			oxcTransformOptions = rest;
+		}
+	}
+	return {
+		define,
+		inject,
+		dropLabels,
+		oxcTransformOptions
+	};
+}
+//#endregion
+//#region src/utils/bindingify-input-options.ts
+function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, normalizedInputPlugins, normalizedOutputPlugins, onLog, logLevel, watchMode) {
+	const pluginContextData = new PluginContextData(onLog, outputOptions, normalizedInputPlugins, normalizedOutputPlugins);
+	const plugins = rawPlugins.map((plugin) => {
+		if ("_parallel" in plugin) return;
+		if (plugin instanceof BuiltinPlugin) switch (plugin.name) {
+			case "builtin:vite-manifest": return bindingifyManifestPlugin(plugin, pluginContextData);
+			default: return bindingifyBuiltInPlugin(plugin);
+		}
+		return bindingifyPlugin(plugin, inputOptions, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode);
+	});
+	const normalizedTransform = normalizeTransformOptions(inputOptions);
+	return {
+		input: bindingifyInput(inputOptions.input),
+		plugins,
+		cwd: inputOptions.cwd ?? process.cwd(),
+		external: bindingifyExternal(inputOptions.external),
+		resolve: bindingifyResolve(inputOptions.resolve),
+		platform: inputOptions.platform,
+		shimMissingExports: inputOptions.shimMissingExports,
+		logLevel: bindingifyLogLevel(logLevel),
+		onLog: async (level, log) => onLog(level, log),
+		treeshake: bindingifyTreeshakeOptions(inputOptions.treeshake),
+		moduleTypes: inputOptions.moduleTypes,
+		define: normalizedTransform.define,
+		inject: bindingifyInject(normalizedTransform.inject),
+		experimental: bindingifyExperimental(inputOptions.experimental),
+		profilerNames: outputOptions.generatedCode?.profilerNames,
+		transform: normalizedTransform.oxcTransformOptions,
+		watch: bindingifyWatch(inputOptions.watch),
+		dropLabels: normalizedTransform.dropLabels,
+		keepNames: outputOptions.keepNames,
+		checks: inputOptions.checks,
+		deferSyncScanData: () => {
+			let ret = [];
+			pluginContextData.moduleOptionMap.forEach((value, key) => {
+				if (value.invalidate) ret.push({
+					id: key,
+					sideEffects: value.moduleSideEffects ?? void 0
+				});
+			});
+			return ret;
+		},
+		makeAbsoluteExternalsRelative: bindingifyMakeAbsoluteExternalsRelative(inputOptions.makeAbsoluteExternalsRelative),
+		devtools: inputOptions.devtools,
+		invalidateJsSideCache: pluginContextData.clear.bind(pluginContextData),
+		preserveEntrySignatures: bindingifyPreserveEntrySignatures(inputOptions.preserveEntrySignatures),
+		optimization: inputOptions.optimization,
+		context: inputOptions.context,
+		tsconfig: inputOptions.resolve?.tsconfigFilename ?? inputOptions.tsconfig
+	};
+}
+function bindingifyDevMode(devMode) {
+	if (devMode) {
+		if (typeof devMode === "boolean") return devMode ? {} : void 0;
+		return devMode;
+	}
+}
+function bindingifyAttachDebugInfo(attachDebugInfo) {
+	switch (attachDebugInfo) {
+		case void 0: return;
+		case "full": return import_binding.BindingAttachDebugInfo.Full;
+		case "simple": return import_binding.BindingAttachDebugInfo.Simple;
+		case "none": return import_binding.BindingAttachDebugInfo.None;
+	}
+}
+function bindingifyExternal(external) {
+	if (external) {
+		if (typeof external === "function") return (id, importer, isResolved) => {
+			if (id.startsWith("\0")) return false;
+			return external(id, importer, isResolved) ?? false;
+		};
+		return arraify(external);
+	}
+}
+function bindingifyExperimental(experimental) {
+	let chunkModulesOrder = import_binding.BindingChunkModuleOrderBy.ExecOrder;
+	if (experimental?.chunkModulesOrder) switch (experimental.chunkModulesOrder) {
+		case "exec-order":
+			chunkModulesOrder = import_binding.BindingChunkModuleOrderBy.ExecOrder;
+			break;
+		case "module-id":
+			chunkModulesOrder = import_binding.BindingChunkModuleOrderBy.ModuleId;
+			break;
+		default: throw new Error(`Unexpected chunkModulesOrder: ${experimental.chunkModulesOrder}`);
+	}
+	return {
+		viteMode: experimental?.viteMode,
+		resolveNewUrlToAsset: experimental?.resolveNewUrlToAsset,
+		devMode: bindingifyDevMode(experimental?.devMode),
+		attachDebugInfo: bindingifyAttachDebugInfo(experimental?.attachDebugInfo),
+		chunkModulesOrder,
+		chunkImportMap: experimental?.chunkImportMap,
+		onDemandWrapping: experimental?.onDemandWrapping,
+		incrementalBuild: experimental?.incrementalBuild,
+		nativeMagicString: experimental?.nativeMagicString,
+		chunkOptimization: experimental?.chunkOptimization,
+		lazyBarrel: experimental?.lazyBarrel
+	};
+}
+function bindingifyResolve(resolve) {
+	const yarnPnp = typeof process === "object" && !!process.versions?.pnp;
+	if (resolve) {
+		const { alias, extensionAlias, ...rest } = resolve;
+		return {
+			alias: alias ? Object.entries(alias).map(([name, replacement]) => ({
+				find: name,
+				replacements: replacement === false ? [void 0] : arraify(replacement)
+			})) : void 0,
+			extensionAlias: extensionAlias ? Object.entries(extensionAlias).map(([name, value]) => ({
+				target: name,
+				replacements: value
+			})) : void 0,
+			yarnPnp,
+			...rest
+		};
+	} else return { yarnPnp };
+}
+function bindingifyInject(inject) {
+	if (inject) return Object.entries(inject).map(([alias, item]) => {
+		if (Array.isArray(item)) {
+			if (item[1] === "*") return {
+				tagNamespace: true,
+				alias,
+				from: item[0]
+			};
+			return {
+				tagNamed: true,
+				alias,
+				from: item[0],
+				imported: item[1]
+			};
+		} else return {
+			tagNamed: true,
+			imported: "default",
+			alias,
+			from: item
+		};
+	});
+}
+function bindingifyLogLevel(logLevel) {
+	switch (logLevel) {
+		case "silent": return import_binding.BindingLogLevel.Silent;
+		case "debug": return import_binding.BindingLogLevel.Debug;
+		case "warn": return import_binding.BindingLogLevel.Warn;
+		case "info": return import_binding.BindingLogLevel.Info;
+		default: throw new Error(`Unexpected log level: ${logLevel}`);
+	}
+}
+function bindingifyInput(input) {
+	if (input === void 0) return [];
+	if (typeof input === "string") return [{ import: input }];
+	if (Array.isArray(input)) return input.map((src) => ({ import: src }));
+	return Object.entries(input).map(([name, import_path]) => {
+		return {
+			name,
+			import: import_path
+		};
+	});
+}
+function bindingifyWatch(watch) {
+	if (watch) {
+		if (watch.notify) console.warn("The \"watch.notify\" option is deprecated. Please use \"watch.watcher\" instead.");
+		const watcher = {
+			...watch.notify,
+			...watch.watcher
+		};
+		return {
+			buildDelay: watch.buildDelay,
+			skipWrite: watch.skipWrite,
+			usePolling: watcher.usePolling,
+			pollInterval: watcher.pollInterval,
+			compareContentsForPolling: watcher.compareContentsForPolling,
+			useDebounce: watcher.useDebounce,
+			debounceDelay: watcher.debounceDelay,
+			debounceTickRate: watcher.debounceTickRate,
+			include: normalizedStringOrRegex(watch.include),
+			exclude: normalizedStringOrRegex(watch.exclude),
+			onInvalidate: (...args) => watch.onInvalidate?.(...args)
+		};
+	}
+}
+function bindingifyTreeshakeOptions(config) {
+	if (config === false) return;
+	if (config === true || config === void 0) return { moduleSideEffects: true };
+	let normalizedConfig = {
+		moduleSideEffects: true,
+		annotations: config.annotations,
+		manualPureFunctions: config.manualPureFunctions,
+		unknownGlobalSideEffects: config.unknownGlobalSideEffects,
+		invalidImportSideEffects: config.invalidImportSideEffects,
+		commonjs: config.commonjs
+	};
+	switch (config.propertyReadSideEffects) {
+		case "always":
+			normalizedConfig.propertyReadSideEffects = import_binding.BindingPropertyReadSideEffects.Always;
+			break;
+		case false:
+			normalizedConfig.propertyReadSideEffects = import_binding.BindingPropertyReadSideEffects.False;
+			break;
+		default:
+	}
+	switch (config.propertyWriteSideEffects) {
+		case "always":
+			normalizedConfig.propertyWriteSideEffects = import_binding.BindingPropertyWriteSideEffects.Always;
+			break;
+		case false:
+			normalizedConfig.propertyWriteSideEffects = import_binding.BindingPropertyWriteSideEffects.False;
+			break;
+		default:
+	}
+	if (config.moduleSideEffects === void 0) normalizedConfig.moduleSideEffects = true;
+	else if (config.moduleSideEffects === "no-external") normalizedConfig.moduleSideEffects = [{
+		external: true,
+		sideEffects: false
+	}, {
+		external: false,
+		sideEffects: true
+	}];
+	else normalizedConfig.moduleSideEffects = config.moduleSideEffects;
+	return normalizedConfig;
+}
+function bindingifyMakeAbsoluteExternalsRelative(makeAbsoluteExternalsRelative) {
+	if (makeAbsoluteExternalsRelative === "ifRelativeSource") return { type: "IfRelativeSource" };
+	if (typeof makeAbsoluteExternalsRelative === "boolean") return {
+		type: "Bool",
+		field0: makeAbsoluteExternalsRelative
+	};
+}
+function bindingifyPreserveEntrySignatures(preserveEntrySignatures) {
+	if (preserveEntrySignatures == void 0) return;
+	else if (typeof preserveEntrySignatures === "string") return {
+		type: "String",
+		field0: preserveEntrySignatures
+	};
+	else return {
+		type: "Bool",
+		field0: preserveEntrySignatures
+	};
+}
+//#endregion
+export { version as C, description as S, LOG_LEVEL_INFO as _, RolldownMagicString as a, RUNTIME_MODULE_ID as b, __decorate as c, PlainObjectLike as d, MinimalPluginContextImpl as f, LOG_LEVEL_ERROR as g, LOG_LEVEL_DEBUG as h, transformModuleInfo as i, transformAssetSource as l, normalizeLog as m, PluginContextData as n, transformToRollupOutput as o, normalizeHook as p, bindingifyPlugin as r, transformRenderedChunk as s, bindingifyInputOptions as t, lazyProp as u, LOG_LEVEL_WARN as v, VERSION as x, logLevelPriority as y };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/constructors-Ciqn_yS7.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/constructors-Ciqn_yS7.mjs
new file mode 100644
index 0000000..1a1e63f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/constructors-Ciqn_yS7.mjs
@@ -0,0 +1,71 @@
+import { a as makeBuiltinPluginCallable, n as BuiltinPlugin, t as normalizedStringOrRegex } from "./normalize-string-or-regex-C-WttzRA.mjs";
+//#region src/builtin-plugin/constructors.ts
+function viteModulePreloadPolyfillPlugin(config) {
+	return new BuiltinPlugin("builtin:vite-module-preload-polyfill", config);
+}
+function viteDynamicImportVarsPlugin(config) {
+	if (config) {
+		config.include = normalizedStringOrRegex(config.include);
+		config.exclude = normalizedStringOrRegex(config.exclude);
+	}
+	return new BuiltinPlugin("builtin:vite-dynamic-import-vars", config);
+}
+function viteImportGlobPlugin(config) {
+	return new BuiltinPlugin("builtin:vite-import-glob", config);
+}
+function viteReporterPlugin(config) {
+	return new BuiltinPlugin("builtin:vite-reporter", config);
+}
+function viteWasmFallbackPlugin() {
+	return makeBuiltinPluginCallable(new BuiltinPlugin("builtin:vite-wasm-fallback"));
+}
+function viteLoadFallbackPlugin() {
+	return new BuiltinPlugin("builtin:vite-load-fallback");
+}
+function viteJsonPlugin(config) {
+	return makeBuiltinPluginCallable(new BuiltinPlugin("builtin:vite-json", config));
+}
+function viteBuildImportAnalysisPlugin(config) {
+	return new BuiltinPlugin("builtin:vite-build-import-analysis", config);
+}
+function viteResolvePlugin(config) {
+	return makeBuiltinPluginCallable(new BuiltinPlugin("builtin:vite-resolve", {
+		...config,
+		async resolveSubpathImports(id, importer, isRequire, scan) {
+			return config.resolveSubpathImports(id, importer, isRequire, scan);
+		},
+		yarnPnp: typeof process === "object" && !!process.versions?.pnp
+	}));
+}
+function isolatedDeclarationPlugin(config) {
+	return new BuiltinPlugin("builtin:isolated-declaration", config);
+}
+function viteWebWorkerPostPlugin() {
+	return new BuiltinPlugin("builtin:vite-web-worker-post");
+}
+/**
+* A plugin that converts CommonJS require() calls for external dependencies into ESM import statements.
+*
+* @see https://rolldown.rs/builtin-plugins/esm-external-require
+* @category Builtin Plugins
+*/
+function esmExternalRequirePlugin(config) {
+	const plugin = new BuiltinPlugin("builtin:esm-external-require", config);
+	plugin.enforce = "pre";
+	return plugin;
+}
+/**
+* This plugin should not be used for Rolldown.
+*/
+function oxcRuntimePlugin() {
+	return makeBuiltinPluginCallable(new BuiltinPlugin("builtin:oxc-runtime"));
+}
+function viteReactRefreshWrapperPlugin(config) {
+	if (config) {
+		config.include = normalizedStringOrRegex(config.include);
+		config.exclude = normalizedStringOrRegex(config.exclude);
+	}
+	return makeBuiltinPluginCallable(new BuiltinPlugin("builtin:vite-react-refresh-wrapper", config));
+}
+//#endregion
+export { viteDynamicImportVarsPlugin as a, viteLoadFallbackPlugin as c, viteReporterPlugin as d, viteResolvePlugin as f, viteBuildImportAnalysisPlugin as i, viteModulePreloadPolyfillPlugin as l, viteWebWorkerPostPlugin as m, isolatedDeclarationPlugin as n, viteImportGlobPlugin as o, viteWasmFallbackPlugin as p, oxcRuntimePlugin as r, viteJsonPlugin as s, esmExternalRequirePlugin as t, viteReactRefreshWrapperPlugin as u };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/constructors-DAnSz-_I.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/constructors-DAnSz-_I.d.mts
new file mode 100644
index 0000000..2521581
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/constructors-DAnSz-_I.d.mts
@@ -0,0 +1,37 @@
+import { D as BindingViteResolvePluginConfig, E as BindingViteReporterPluginConfig, S as BindingViteJsonPluginConfig, T as BindingViteReactRefreshWrapperPluginConfig, b as BindingViteDynamicImportVarsPluginConfig, l as BindingIsolatedDeclarationPluginConfig, s as BindingEsmExternalRequirePluginConfig, w as BindingViteModulePreloadPolyfillPluginConfig, x as BindingViteImportGlobPluginConfig, y as BindingViteBuildImportAnalysisPluginConfig } from "./binding-zH1vcmbM.mjs";
+import { P as BuiltinPlugin, Ut as StringOrRegExp } from "./define-config-CeKzMIcs.mjs";
+
+//#region src/builtin-plugin/constructors.d.ts
+declare function viteModulePreloadPolyfillPlugin(config?: BindingViteModulePreloadPolyfillPluginConfig): BuiltinPlugin;
+type DynamicImportVarsPluginConfig = Omit<BindingViteDynamicImportVarsPluginConfig, "include" | "exclude"> & {
+  include?: StringOrRegExp | StringOrRegExp[];
+  exclude?: StringOrRegExp | StringOrRegExp[];
+};
+declare function viteDynamicImportVarsPlugin(config?: DynamicImportVarsPluginConfig): BuiltinPlugin;
+declare function viteImportGlobPlugin(config?: BindingViteImportGlobPluginConfig): BuiltinPlugin;
+declare function viteReporterPlugin(config: BindingViteReporterPluginConfig): BuiltinPlugin;
+declare function viteWasmFallbackPlugin(): BuiltinPlugin;
+declare function viteLoadFallbackPlugin(): BuiltinPlugin;
+declare function viteJsonPlugin(config: BindingViteJsonPluginConfig): BuiltinPlugin;
+declare function viteBuildImportAnalysisPlugin(config: BindingViteBuildImportAnalysisPluginConfig): BuiltinPlugin;
+declare function viteResolvePlugin(config: Omit<BindingViteResolvePluginConfig, "yarnPnp">): BuiltinPlugin;
+declare function isolatedDeclarationPlugin(config?: BindingIsolatedDeclarationPluginConfig): BuiltinPlugin;
+declare function viteWebWorkerPostPlugin(): BuiltinPlugin;
+/**
+* A plugin that converts CommonJS require() calls for external dependencies into ESM import statements.
+*
+* @see https://rolldown.rs/builtin-plugins/esm-external-require
+* @category Builtin Plugins
+*/
+declare function esmExternalRequirePlugin(config?: BindingEsmExternalRequirePluginConfig): BuiltinPlugin;
+type ViteReactRefreshWrapperPluginConfig = Omit<BindingViteReactRefreshWrapperPluginConfig, "include" | "exclude"> & {
+  include?: StringOrRegExp | StringOrRegExp[];
+  exclude?: StringOrRegExp | StringOrRegExp[];
+};
+/**
+* This plugin should not be used for Rolldown.
+*/
+declare function oxcRuntimePlugin(): BuiltinPlugin;
+declare function viteReactRefreshWrapperPlugin(config: ViteReactRefreshWrapperPluginConfig): BuiltinPlugin;
+//#endregion
+export { viteDynamicImportVarsPlugin as a, viteLoadFallbackPlugin as c, viteReporterPlugin as d, viteResolvePlugin as f, viteBuildImportAnalysisPlugin as i, viteModulePreloadPolyfillPlugin as l, viteWebWorkerPostPlugin as m, isolatedDeclarationPlugin as n, viteImportGlobPlugin as o, viteWasmFallbackPlugin as p, oxcRuntimePlugin as r, viteJsonPlugin as s, esmExternalRequirePlugin as t, viteReactRefreshWrapperPlugin as u };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/define-config-CeKzMIcs.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/define-config-CeKzMIcs.d.mts
new file mode 100644
index 0000000..6dc915b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/define-config-CeKzMIcs.d.mts
@@ -0,0 +1,3869 @@
+import { a as RolldownLog, i as RolldownError, n as LogLevelOption, o as RolldownLogWithString, r as LogOrStringHandler, t as LogLevel } from "./logging-C6h4g8dA.mjs";
+import { A as ExternalMemoryStatus, N as JsxOptions, P as MinifyOptions$1, R as ParserOptions, U as TransformOptions$1, c as BindingHookResolveIdExtraArgs, d as BindingPluginContextResolveOptions, h as BindingTransformHookExtraArgs, k as BindingWatcherBundler, p as BindingRenderedChunk, t as BindingBuiltinPluginName, u as BindingMagicString, z as PreRenderedChunk } from "./binding-zH1vcmbM.mjs";
+import { TopLevelFilterExpression } from "@rolldown/pluginutils";
+import { Program } from "@oxc-project/types";
+
+//#region src/types/misc.d.ts
+/** @inline */
+type SourcemapPathTransformOption = (relativeSourcePath: string, sourcemapPath: string) => string;
+/** @inline */
+type SourcemapIgnoreListOption = (relativeSourcePath: string, sourcemapPath: string) => boolean;
+//#endregion
+//#region src/types/module-info.d.ts
+/** @category Plugin APIs */
+interface ModuleInfo extends ModuleOptions {
+  /**
+  * @hidden Not supported by Rolldown
+  */
+  ast: any;
+  /**
+  * The source code of the module.
+  *
+  * `null` if external or not yet available.
+  */
+  code: string | null;
+  /**
+  * The id of the module for convenience
+  */
+  id: string;
+  /**
+  * The ids of all modules that statically import this module.
+  */
+  importers: string[];
+  /**
+  * The ids of all modules that dynamically import this module.
+  */
+  dynamicImporters: string[];
+  /**
+  * The module ids statically imported by this module.
+  */
+  importedIds: string[];
+  /**
+  * The module ids dynamically imported by this module.
+  */
+  dynamicallyImportedIds: string[];
+  /**
+  * All exported variables
+  */
+  exports: string[];
+  /**
+  * Whether this module is a user- or plugin-defined entry point.
+  */
+  isEntry: boolean;
+  /**
+  * The detected format of the module, based on both its syntax and module definition
+  * metadata (such as `package.json` `type` and file extensions like `.mjs`/`.cjs`/`.mts`/`.cts`).
+  * - "esm" for ES modules (has `import`/`export` statements or is defined as ESM by module metadata)
+  * - "cjs" for CommonJS modules (uses `module.exports`, `exports`, top-level `return`, or is defined as CommonJS by module metadata)
+  * - "unknown" when the format could not be determined from either syntax or module definition metadata
+  *
+  * @experimental
+  */
+  inputFormat: "es" | "cjs" | "unknown";
+}
+//#endregion
+//#region src/utils/asset-source.d.ts
+/** @inline */
+type AssetSource = string | Uint8Array;
+//#endregion
+//#region src/types/external-memory-handle.d.ts
+declare const symbolForExternalMemoryHandle: "__rolldown_external_memory_handle__";
+/**
+* Interface for objects that hold external memory that can be explicitly freed.
+*/
+interface ExternalMemoryHandle {
+  /**
+  * Frees the external memory held by this object.
+  * @param keepDataAlive - If true, evaluates all lazy fields before freeing memory.
+  *   This will take time but prevents errors when accessing properties after freeing.
+  * @returns Status object with `freed` boolean and optional `reason` string.
+  * @internal
+  */
+  [symbolForExternalMemoryHandle]: (keepDataAlive?: boolean) => ExternalMemoryStatus;
+}
+/**
+* Frees the external memory held by the given handle.
+*
+* This is useful when you want to manually release memory held by Rust objects
+* (like `OutputChunk` or `OutputAsset`) before they are garbage collected.
+*
+* @param handle - The object with external memory to free
+* @param keepDataAlive - If true, evaluates all lazy fields before freeing memory (default: false).
+*   This will take time to copy data from Rust to JavaScript, but prevents errors
+*   when accessing properties after the memory is freed.
+* @returns Status object with `freed` boolean and optional `reason` string.
+*   - `{ freed: true }` if memory was successfully freed
+*   - `{ freed: false, reason: "..." }` if memory couldn't be freed (e.g., already freed or other references exist)
+*
+* @example
+* ```typescript
+* import { freeExternalMemory } from 'rolldown/experimental';
+*
+* const output = await bundle.generate();
+* const chunk = output.output[0];
+*
+* // Use the chunk...
+*
+* // Manually free the memory (fast, but accessing properties after will throw)
+* const status = freeExternalMemory(chunk); // { freed: true }
+* const statusAgain = freeExternalMemory(chunk); // { freed: false, reason: "Memory has already been freed" }
+*
+* // Keep data alive before freeing (slower, but data remains accessible)
+* freeExternalMemory(chunk, true); // Evaluates all lazy fields first
+* console.log(chunk.code); // OK - data was copied to JavaScript before freeing
+*
+* // Without keepDataAlive, accessing chunk properties after freeing will throw an error
+* ```
+*/
+declare function freeExternalMemory(handle: ExternalMemoryHandle, keepDataAlive?: boolean): ExternalMemoryStatus;
+//#endregion
+//#region src/types/rolldown-output.d.ts
+/**
+* The information about an asset in the generated bundle.
+*
+* @category Plugin APIs
+*/
+interface OutputAsset extends ExternalMemoryHandle {
+  type: "asset";
+  /** The file name of this asset. */
+  fileName: string;
+  /** @deprecated Use {@linkcode originalFileNames} instead. */
+  originalFileName: string | null;
+  /** The list of the absolute paths to the original file of this asset. */
+  originalFileNames: string[];
+  /** The content of this asset. */
+  source: AssetSource;
+  /** @deprecated Use {@linkcode names} instead. */
+  name: string | undefined;
+  names: string[];
+}
+/** @category Plugin APIs */
+interface SourceMap {
+  file: string;
+  mappings: string;
+  names: string[];
+  sources: string[];
+  sourcesContent: string[];
+  version: number;
+  debugId?: string;
+  x_google_ignoreList?: number[];
+  toString(): string;
+  toUrl(): string;
+}
+/** @category Plugin APIs */
+interface RenderedModule {
+  /**
+  * The rendered code of this module.
+  *
+  * The unused variables and functions are removed.
+  */
+  readonly code: string | null;
+  /**
+  * The length of the rendered code of this module.
+  */
+  renderedLength: number;
+  /**
+  * The list of exported names from this module.
+  *
+  * The names that are not used are not included.
+  */
+  renderedExports: string[];
+}
+/**
+* The information about the chunk being rendered.
+*
+* Unlike {@link OutputChunk}, `code` and `map` are not set as the chunk has not been rendered yet.
+* All referenced chunk file names in each property that would contain hashes will contain hash placeholders instead.
+*
+* @category Plugin APIs
+*/
+interface RenderedChunk extends Omit<BindingRenderedChunk, "modules"> {
+  type: "chunk";
+  /** Information about the modules included in this chunk. */
+  modules: {
+    [id: string]: RenderedModule;
+  };
+  /** The name of this chunk, which is used in naming patterns. */
+  name: string;
+  /** Whether this chunk is a static entry point. */
+  isEntry: boolean;
+  /** Whether this chunk is a dynamic entry point. */
+  isDynamicEntry: boolean;
+  /** The id of a module that this chunk corresponds to. */
+  facadeModuleId: string | null;
+  /** The list of ids of modules included in this chunk. */
+  moduleIds: Array<string>;
+  /** Exported variable names from this chunk. */
+  exports: Array<string>;
+  /** The preliminary file name of this chunk with hash placeholders. */
+  fileName: string;
+  /** External modules imported statically by this chunk. */
+  imports: Array<string>;
+  /** External modules imported dynamically by this chunk. */
+  dynamicImports: Array<string>;
+}
+/**
+* The information about a chunk in the generated bundle.
+*
+* @category Plugin APIs
+*/
+interface OutputChunk extends ExternalMemoryHandle {
+  type: "chunk";
+  /** The generated code of this chunk. */
+  code: string;
+  /** The name of this chunk, which is used in naming patterns. */
+  name: string;
+  /** Whether this chunk is a static entry point. */
+  isEntry: boolean;
+  /** Exported variable names from this chunk. */
+  exports: string[];
+  /** The file name of this chunk. */
+  fileName: string;
+  /** Information about the modules included in this chunk. */
+  modules: {
+    [id: string]: RenderedModule;
+  };
+  /** External modules imported statically by this chunk. */
+  imports: string[];
+  /** External modules imported dynamically by this chunk. */
+  dynamicImports: string[];
+  /** The id of a module that this chunk corresponds to. */
+  facadeModuleId: string | null;
+  /** Whether this chunk is a dynamic entry point. */
+  isDynamicEntry: boolean;
+  moduleIds: string[];
+  /** The source map of this chunk if present. */
+  map: SourceMap | null;
+  sourcemapFileName: string | null;
+  /** The preliminary file name of this chunk with hash placeholders. */
+  preliminaryFileName: string;
+}
+/**
+* The generated bundle output.
+*
+* @category Programmatic APIs
+*/
+interface RolldownOutput extends ExternalMemoryHandle {
+  /**
+  * The list of chunks and assets in the generated bundle.
+  *
+  * This includes at least one {@linkcode OutputChunk}. It may also include more
+  * {@linkcode OutputChunk} and/or {@linkcode OutputAsset}s.
+  */
+  output: [OutputChunk, ...(OutputChunk | OutputAsset)[]];
+}
+//#endregion
+//#region src/types/utils.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/** @inline */
+type NullValue<T = void> = T | undefined | null | void;
+type PartialNull<T> = { [P in keyof T]: T[P] | null };
+type MakeAsync<Function_> = Function_ extends ((this: infer This, ...parameters: infer Arguments) => infer Return) ? (this: This, ...parameters: Arguments) => Return | Promise<Return> : never;
+type MaybeArray<T> = T | T[];
+/** @inline */
+type StringOrRegExp = string | RegExp;
+//#endregion
+//#region src/options/output-options.d.ts
+type GeneratedCodePreset = "es5" | "es2015";
+interface GeneratedCodeOptions {
+  /**
+  * Whether to use Symbol.toStringTag for namespace objects.
+  * @default false
+  */
+  symbols?: boolean;
+  /**
+  * Allows choosing one of the presets listed above while overriding some options.
+  *
+  * ```js
+  * export default {
+  *   output: {
+  *     generatedCode: {
+  *       preset: 'es2015',
+  *       symbols: false
+  *     }
+  *   }
+  * };
+  * ```
+  *
+  * @default 'es2015'
+  */
+  preset?: GeneratedCodePreset;
+  /**
+  * Whether to add readable names to internal variables for profiling purposes.
+  *
+  * When enabled, generated code will use descriptive variable names that correspond
+  * to the original module names, making it easier to profile and debug the bundled code.
+  *
+  * @default false
+  *
+  *
+  */
+  profilerNames?: boolean;
+}
+/** @inline */
+type ModuleFormat = "es" | "cjs" | "esm" | "module" | "commonjs" | "iife" | "umd";
+/** @inline */
+type AddonFunction = (chunk: RenderedChunk) => string | Promise<string>;
+/** @inline */
+type ChunkFileNamesFunction = (chunkInfo: PreRenderedChunk) => string;
+/** @inline */
+type SanitizeFileNameFunction = (name: string) => string;
+/** @category Plugin APIs */
+interface PreRenderedAsset {
+  type: "asset";
+  /** @deprecated Use {@linkcode names} instead. */
+  name?: string;
+  names: string[];
+  /** @deprecated Use {@linkcode originalFileNames} instead. */
+  originalFileName?: string;
+  /** The list of the absolute paths to the original file of this asset. */
+  originalFileNames: string[];
+  /** The content of this asset. */
+  source: AssetSource;
+}
+/** @inline */
+type AssetFileNamesFunction = (chunkInfo: PreRenderedAsset) => string;
+/** @inline */
+type PathsFunction$1 = (id: string) => string;
+/** @inline */
+type ManualChunksFunction = (moduleId: string, meta: {
+  getModuleInfo: (moduleId: string) => ModuleInfo | null;
+}) => string | NullValue;
+/** @inline */
+type GlobalsFunction = (name: string) => string;
+/** @category Plugin APIs */
+type CodeSplittingNameFunction = (moduleId: string, ctx: ChunkingContext) => string | NullValue;
+/** @inline */
+type CodeSplittingTestFunction = (id: string) => boolean | undefined | void;
+type MinifyOptions = Omit<MinifyOptions$1, "module" | "sourcemap">;
+interface CommentsOptions {
+  /**
+  * Comments that contain `@license`, `@preserve` or start with `//!` or `/*!`
+  */
+  legal?: boolean;
+  /**
+  * Comments that contain `@__PURE__`, `@__NO_SIDE_EFFECTS__` or `@vite-ignore`
+  */
+  annotation?: boolean;
+  /**
+  * JSDoc comments
+  */
+  jsdoc?: boolean;
+}
+/** @inline */
+interface ChunkingContext {
+  getModuleInfo(moduleId: string): ModuleInfo | null;
+}
+interface OutputOptions {
+  /**
+  * The directory in which all generated chunks are placed.
+  *
+  * The {@linkcode file | output.file} option can be used instead if only a single chunk is generated.
+  *
+  *
+  *
+  * @default 'dist'
+  */
+  dir?: string;
+  /**
+  * The file path for the single generated chunk.
+  *
+  * The {@linkcode dir | output.dir} option should be used instead if multiple chunks are generated.
+  */
+  file?: string;
+  /**
+  * Which exports mode to use.
+  *
+  *
+  *
+  * @default 'auto'
+  */
+  exports?: "auto" | "named" | "default" | "none";
+  /**
+  * Specify the character set that Rolldown is allowed to use in file hashes.
+  *
+  * - `'base64'`: Uses url-safe base64 characters (0-9, a-z, A-Z, -, _). This will produce the shortest hashes.
+  * - `'base36'`: Uses alphanumeric characters (0-9, a-z)
+  * - `'hex'`: Uses hexadecimal characters (0-9, a-f)
+  *
+  * @default 'base64'
+  */
+  hashCharacters?: "base64" | "base36" | "hex";
+  /**
+  * Expected format of generated code.
+  *
+  * - `'es'`, `'esm'` and `'module'` are the same format, all stand for ES module.
+  * - `'cjs'` and `'commonjs'` are the same format, all stand for CommonJS module.
+  * - `'iife'` stands for [Immediately Invoked Function Expression](https://developer.mozilla.org/en-US/docs/Glossary/IIFE).
+  * - `'umd'` stands for [Universal Module Definition](https://github.com/umdjs/umd).
+  *
+  * @default 'es'
+  *
+  *
+  */
+  format?: ModuleFormat;
+  /**
+  * Whether to generate sourcemaps.
+  *
+  * - `false`: No sourcemap will be generated.
+  * - `true`: A separate sourcemap file will be generated.
+  * - `'inline'`: The sourcemap will be appended to the output file as a data URL.
+  * - `'hidden'`: A separate sourcemap file will be generated, but the link to the sourcemap (`//# sourceMappingURL` comment) will not be included in the output file.
+  *
+  * @default false
+  */
+  sourcemap?: boolean | "inline" | "hidden";
+  /**
+  * The base URL for the links to the sourcemap file in the output file.
+  *
+  * By default, relative URLs are generated. If this option is set, an absolute URL with that base URL will be generated. This is useful when deploying source maps to a different location than your code, such as a CDN or separate debugging server.
+  */
+  sourcemapBaseUrl?: string;
+  /**
+  * Whether to include [debug IDs](https://github.com/tc39/ecma426/blob/main/proposals/debug-id.md) in the sourcemap.
+  *
+  * When `true`, a unique debug ID will be emitted in source and sourcemaps which streamlines identifying sourcemaps across different builds.
+  *
+  * @default false
+  */
+  sourcemapDebugIds?: boolean;
+  /**
+  * Control which source files are included in the sourcemap ignore list.
+  *
+  * Files in the ignore list are excluded from debugger stepping and error stack traces.
+  *
+  * - `false`: Include no source files in the ignore list
+  * - `true`: Include all source files in the ignore list
+  * - `string`: Files containing this string in their path will be included in the ignore list
+  * - `RegExp`: Files matching this regular expression will be included in the ignore list
+  * - `function`: Custom function to determine if a source should be ignored
+  *
+  * :::tip Performance
+  * Using static values (`boolean`, `string`, or `RegExp`) is significantly more performant than functions.
+  * Calling JavaScript functions from Rust has extremely high overhead, so prefer static patterns when possible.
+  * :::
+  *
+  * @example
+  * ```js
+  * // ✅ Preferred: Use RegExp for better performance
+  * sourcemapIgnoreList: /node_modules/
+  *
+  * // ✅ Preferred: Use string pattern for better performance
+  * sourcemapIgnoreList: "vendor"
+  *
+  * // ! Use sparingly: Function calls have high overhead
+  * sourcemapIgnoreList: (source, sourcemapPath) => {
+  *   return source.includes('node_modules') || source.includes('.min.');
+  * }
+  * ```
+  *
+  * @default /node_modules/
+  */
+  sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption | StringOrRegExp;
+  /**
+  * A transformation to apply to each path in a sourcemap.
+  *
+  * @example
+  * ```js
+  * export default defineConfig({
+  *   output: {
+  *     sourcemap: true,
+  *     sourcemapPathTransform: (source, sourcemapPath) => {
+  *       // Remove 'src/' prefix from all source paths
+  *       return source.replace(/^src\//, '');
+  *     },
+  *   },
+  * });
+  * ```
+  */
+  sourcemapPathTransform?: SourcemapPathTransformOption;
+  /**
+  * Whether to exclude the original source code from sourcemaps.
+  *
+  * When `true`, the `sourcesContent` field is omitted from the generated sourcemap,
+  * reducing the sourcemap file size. The sourcemap will still contain source file paths
+  * and mappings, so debugging works if the original files are available.
+  *
+  * @default false
+  */
+  sourcemapExcludeSources?: boolean;
+  /**
+  * A string to prepend to the bundle before {@linkcode Plugin.renderChunk | renderChunk} hook.
+  *
+  * See {@linkcode intro | output.intro}, {@linkcode postBanner | output.postBanner} as well.
+  *
+  *
+  */
+  banner?: string | AddonFunction;
+  /**
+  * A string to append to the bundle before {@linkcode Plugin.renderChunk | renderChunk} hook.
+  *
+  * See {@linkcode outro | output.outro}, {@linkcode postFooter | output.postFooter} as well.
+  *
+  *
+  */
+  footer?: string | AddonFunction;
+  /**
+  * A string to prepend to the bundle after {@linkcode Plugin.renderChunk | renderChunk} hook and minification.
+  *
+  * See {@linkcode banner | output.banner}, {@linkcode intro | output.intro} as well.
+  *
+  *
+  */
+  postBanner?: string | AddonFunction;
+  /**
+  * A string to append to the bundle after {@linkcode Plugin.renderChunk | renderChunk} hook and minification.
+  *
+  * See {@linkcode footer | output.footer}, {@linkcode outro | output.outro} as well.
+  *
+  *
+  */
+  postFooter?: string | AddonFunction;
+  /**
+  * A string to prepend inside any {@link OutputOptions.format | format}-specific wrapper.
+  *
+  * See {@linkcode banner | output.banner}, {@linkcode postBanner | output.postBanner} as well.
+  *
+  *
+  */
+  intro?: string | AddonFunction;
+  /**
+  * A string to append inside any {@link OutputOptions.format | format}-specific wrapper.
+  *
+  * See {@linkcode footer | output.footer}, {@linkcode postFooter | output.postFooter} as well.
+  *
+  *
+  */
+  outro?: string | AddonFunction;
+  /**
+  * Whether to extend the global variable defined by the {@linkcode OutputOptions.name | name} option in `umd` or `iife` {@link OutputOptions.format | formats}.
+  *
+  * When `true`, the global variable will be defined as `global.name = global.name || {}`.
+  * When `false`, the global defined by name will be overwritten like `global.name = {}`.
+  *
+  * @default false
+  */
+  extend?: boolean;
+  /**
+  * Whether to add a `__esModule: true` property when generating exports for non-ES {@link OutputOptions.format | formats}.
+  *
+  * This property signifies that the exported value is the namespace of an ES module and that the default export of this module corresponds to the `.default` property of the exported object.
+  *
+  * - `true`: Always add the property when using {@link OutputOptions.exports | named exports mode}, which is similar to what other tools do.
+  * - `"if-default-prop"`: Only add the property when using {@link OutputOptions.exports | named exports mode} and there also is a default export. The subtle difference is that if there is no default export, consumers of the CommonJS version of your library will get all named exports as default export instead of an error or `undefined`.
+  * - `false`: Never add the property even if the default export would become a property `.default`.
+  *
+  * @default 'if-default-prop'
+  *
+  *
+  */
+  esModule?: boolean | "if-default-prop";
+  /**
+  * The pattern to use for naming custom emitted assets to include in the build output, or a function that is called per asset with {@linkcode PreRenderedAsset} to return such a pattern.
+  *
+  * Patterns support the following placeholders:
+  * - `[extname]`: The file extension of the asset including a leading dot, e.g. `.css`.
+  * - `[ext]`: The file extension without a leading dot, e.g. css.
+  * - `[hash]`: A hash based on the content of the asset. You can also set a specific hash length via e.g. `[hash:10]`. By default, it will create a base-64 hash. If you need a reduced character set, see {@linkcode hashCharacters | output.hashCharacters}.
+  * - `[name]`: The file name of the asset excluding any extension.
+  *
+  * Forward slashes (`/`) can be used to place files in sub-directories.
+  *
+  * See also {@linkcode chunkFileNames | output.chunkFileNames}, {@linkcode entryFileNames | output.entryFileNames}.
+  *
+  * @default 'assets/[name]-[hash][extname]'
+  */
+  assetFileNames?: string | AssetFileNamesFunction;
+  /**
+  * The pattern to use for chunks created from entry points, or a function that is called per entry chunk with {@linkcode PreRenderedChunk} to return such a pattern.
+  *
+  * Patterns support the following placeholders:
+  * - `[format]`: The rendering format defined in the output options. The value is any of {@linkcode InternalModuleFormat}.
+  * - `[hash]`: A hash based only on the content of the final generated chunk, including transformations in `renderChunk` and any referenced file hashes. You can also set a specific hash length via e.g. `[hash:10]`. By default, it will create a base-64 hash. If you need a reduced character set, see {@linkcode hashCharacters | output.hashCharacters}.
+  * - `[name]`: The file name (without extension) of the entry point, unless the object form of input was used to define a different name.
+  *
+  * Forward slashes (`/`) can be used to place files in sub-directories. This pattern will also be used for every file when setting the {@linkcode preserveModules | output.preserveModules} option.
+  *
+  * See also {@linkcode assetFileNames | output.assetFileNames}, {@linkcode chunkFileNames | output.chunkFileNames}.
+  *
+  * @default '[name].js'
+  */
+  entryFileNames?: string | ChunkFileNamesFunction;
+  /**
+  * The pattern to use for naming shared chunks created when code-splitting, or a function that is called per chunk with {@linkcode PreRenderedChunk} to return such a pattern.
+  *
+  * Patterns support the following placeholders:
+  * - `[format]`: The rendering format defined in the output options. The value is any of {@linkcode InternalModuleFormat}.
+  * - `[hash]`: A hash based only on the content of the final generated chunk, including transformations in `renderChunk` and any referenced file hashes. You can also set a specific hash length via e.g. `[hash:10]`. By default, it will create a base-64 hash. If you need a reduced character set, see {@linkcode hashCharacters | output.hashCharacters}.
+  * - `[name]`: The name of the chunk. This can be explicitly set via the {@linkcode codeSplitting | output.codeSplitting} option or when the chunk is created by a plugin via `this.emitFile`. Otherwise, it will be derived from the chunk contents.
+  *
+  * Forward slashes (`/`) can be used to place files in sub-directories.
+  *
+  * See also {@linkcode assetFileNames | output.assetFileNames}, {@linkcode entryFileNames | output.entryFileNames}.
+  *
+  * @default '[name]-[hash].js'
+  */
+  chunkFileNames?: string | ChunkFileNamesFunction;
+  /**
+  * Whether to enable chunk name sanitization (removal of non-URL-safe characters like `\0`, `?` and `*`).
+  *
+  * Set `false` to disable the sanitization. You can also provide a custom sanitization function.
+  *
+  * @default true
+  */
+  sanitizeFileName?: boolean | SanitizeFileNameFunction;
+  /**
+  * Control code minification
+  *
+  * Rolldown uses Oxc Minifier under the hood. See Oxc's [minification documentation](https://oxc.rs/docs/guide/usage/minifier#features) for more details.
+  *
+  * - `true`: Enable full minification including code compression and dead code elimination
+  * - `false`: Disable minification
+  * - `'dce-only'`: Only perform dead code elimination without code compression (default)
+  * - `MinifyOptions`: Fine-grained control over minification settings
+  *
+  * @default 'dce-only'
+  */
+  minify?: boolean | "dce-only" | MinifyOptions;
+  /**
+  * Specifies the global variable name that contains the exports of `umd` / `iife` {@link OutputOptions.format | formats}.
+  *
+  * @example
+  * ```js
+  * export default defineConfig({
+  *   output: {
+  *     format: 'iife',
+  *     name: 'MyBundle',
+  *   }
+  * });
+  * ```
+  * ```js
+  * // output
+  * var MyBundle = (function () {
+  *   // ...
+  * })();
+  * ```
+  *
+  *
+  */
+  name?: string;
+  /**
+  * Specifies `id: variableName` pairs necessary for {@link InputOptions.external | external} imports in `umd` / `iife` {@link OutputOptions.format | formats}.
+  *
+  * @example
+  * ```js
+  * export default defineConfig({
+  *   external: ['jquery'],
+  *   output: {
+  *     format: 'iife',
+  *     name: 'MyBundle',
+  *     globals: {
+  *       jquery: '$',
+  *     }
+  *   }
+  * });
+  * ```
+  * ```js
+  * // input
+  * import $ from 'jquery';
+  * ```
+  * ```js
+  * // output
+  * var MyBundle = (function ($) {
+  *   // ...
+  * })($);
+  * ```
+  */
+  globals?: Record<string, string> | GlobalsFunction;
+  /**
+  * Maps {@link InputOptions.external | external} module IDs to paths.
+  *
+  * Allows customizing the path used when importing external dependencies.
+  * This is particularly useful for loading dependencies from CDNs or custom locations.
+  *
+  * - Object form: Maps module IDs to their replacement paths
+  * - Function form: Takes a module ID and returns its replacement path
+  *
+  * @example
+  * ```js
+  * {
+  *   paths: {
+  *     'd3': 'https://cdn.jsdelivr.net/npm/d3@7'
+  *   }
+  * }
+  * ```
+  *
+  * @example
+  * ```js
+  * {
+  *   paths: (id) => {
+  *     if (id.startsWith('lodash')) {
+  *       return `https://cdn.jsdelivr.net/npm/${id}`
+  *     }
+  *     return id
+  *   }
+  * }
+  * ```
+  */
+  paths?: Record<string, string> | PathsFunction$1;
+  /**
+  * Which language features Rolldown can safely use in generated code.
+  *
+  * This will not transpile any user code but only change the code Rolldown uses in wrappers and helpers.
+  */
+  generatedCode?: Partial<GeneratedCodeOptions>;
+  /**
+  * Whether to generate code to support live bindings for {@link InputOptions.external | external} imports.
+  *
+  * With the default value of `true`, Rolldown will generate code to support live bindings for external imports.
+  *
+  * When set to `false`, Rolldown will assume that exports from external modules do not change. This will allow Rolldown to generate smaller code. Note that this can cause issues when there are circular dependencies involving an external dependency.
+  *
+  * @default true
+  *
+  *
+  */
+  externalLiveBindings?: boolean;
+  /**
+  * @deprecated Please use `codeSplitting: false` instead.
+  *
+  * Whether to inline dynamic imports instead of creating new chunks to create a single bundle.
+  *
+  * This option can be used only when a single input is provided.
+  *
+  * @default false
+  */
+  inlineDynamicImports?: boolean;
+  /**
+  * Whether to keep external dynamic imports as `import(...)` expressions in CommonJS output.
+  *
+  * If set to `false`, external dynamic imports will be rewritten to use `require(...)` calls.
+  * This may be necessary to support environments that do not support dynamic `import()` in CommonJS modules like old Node.js versions.
+  *
+  * @default true
+  */
+  dynamicImportInCjs?: boolean;
+  /**
+  * Allows you to do manual chunking. Provided for Rollup compatibility.
+  *
+  * You could use this option for migration purpose. Under the hood,
+  *
+  * ```js
+  * {
+  *   manualChunks: (moduleId, meta) => {
+  *     if (moduleId.includes('node_modules')) {
+  *       return 'vendor';
+  *     }
+  *     return null;
+  *   }
+  * }
+  * ```
+  *
+  * will be transformed to
+  *
+  * ```js
+  * {
+  *   codeSplitting: {
+  *     groups: [
+  *       {
+  *         name(moduleId) {
+  *           if (moduleId.includes('node_modules')) {
+  *             return 'vendor';
+  *           }
+  *           return null;
+  *         },
+  *       },
+  *     ],
+  *   }
+  * }
+  *
+  * ```
+  *
+  * Note that unlike Rollup, object form is not supported.
+  *
+  * @deprecated
+  * Please use {@linkcode codeSplitting | output.codeSplitting} instead.
+  *
+  * :::warning
+  * If `manualChunks` and `codeSplitting` are both specified, `manualChunks` option will be ignored.
+  * :::
+  */
+  manualChunks?: ManualChunksFunction;
+  /**
+  * Controls how code splitting is performed.
+  *
+  * - `true`: Default behavior, automatic code splitting. **(default)**
+  * - `false`: Inline all dynamic imports into a single bundle (equivalent to deprecated `inlineDynamicImports: true`).
+  * - `object`: Advanced manual code splitting configuration.
+  *
+  * For deeper understanding, please refer to the in-depth [documentation](https://rolldown.rs/in-depth/manual-code-splitting).
+  *
+  *
+  *
+  * @example
+  * **Basic vendor chunk**
+  * ```js
+  * export default defineConfig({
+  *   output: {
+  *     codeSplitting: {
+  *       minSize: 20000,
+  *       groups: [
+  *         {
+  *           name: 'vendor',
+  *           test: /node_modules/,
+  *         },
+  *       ],
+  *     },
+  *   },
+  * });
+  * ```
+  *
+  *
+  * @default true
+  */
+  codeSplitting?: boolean | CodeSplittingOptions;
+  /**
+  * @deprecated Please use {@linkcode codeSplitting | output.codeSplitting} instead.
+  *
+  * Allows you to do manual chunking.
+  *
+  * :::warning
+  * If `advancedChunks` and `codeSplitting` are both specified, `advancedChunks` option will be ignored.
+  * :::
+  */
+  advancedChunks?: {
+    includeDependenciesRecursively?: boolean;
+    minSize?: number;
+    maxSize?: number;
+    maxModuleSize?: number;
+    minModuleSize?: number;
+    minShareCount?: number;
+    groups?: CodeSplittingGroup[];
+  };
+  /**
+  * Controls how legal comments are preserved in the output.
+  *
+  * - `none`: no legal comments
+  * - `inline`: preserve legal comments that contain `@license`, `@preserve` or starts with `//!` `/*!`
+  *
+  * @deprecated Use `comments.legal` instead. When both `legalComments` and `comments.legal` are set, `comments.legal` takes priority.
+  */
+  legalComments?: "none" | "inline";
+  /**
+  * Control which comments are preserved in the output.
+  *
+  * - `true`: Preserve legal, annotation, and JSDoc comments (default)
+  * - `false`: Strip all comments
+  * - Object: Granular control over comment categories
+  *
+  * Note: Regular line and block comments without these markers
+  * are always removed regardless of this option.
+  *
+  * When both `legalComments` and `comments.legal` are set, `comments.legal` takes priority.
+  *
+  *
+  *
+  * @default true
+  */
+  comments?: boolean | CommentsOptions;
+  /**
+  * The list of plugins to use only for this output.
+  *
+  * @see {@linkcode InputOptions.plugins | plugins}
+  */
+  plugins?: RolldownOutputPluginOption;
+  /**
+  * Whether to add a polyfill for `require()` function in non-CommonJS formats.
+  *
+  * This option is useful when you want to inject your own `require` implementation.
+  *
+  * @default true
+  */
+  polyfillRequire?: boolean;
+  /**
+  * This option is not implemented yet.
+  * @hidden
+  */
+  hoistTransitiveImports?: false;
+  /**
+  * Whether to use preserve modules mode.
+  *
+  *
+  *
+  * @default false
+  */
+  preserveModules?: boolean;
+  /**
+  * Specifies the directory name for "virtual" files that might be emitted by plugins when using {@link OutputOptions.preserveModules | preserve modules mode}.
+  *
+  * @default '_virtual'
+  */
+  virtualDirname?: string;
+  /**
+  * A directory path to input modules that should be stripped away from {@linkcode dir | output.dir} when using {@link OutputOptions.preserveModules | preserve modules mode}.
+  *
+  *
+  */
+  preserveModulesRoot?: string;
+  /**
+  * Whether to convert top-level `let` and `const` declarations into `var` declarations.
+  *
+  * Enabling this option can improve runtime performance of the generated code in
+  * certain environments by avoiding Temporal Dead Zone (TDZ) checks. Only declarations
+  * in the module's top-level scope are rewritten — declarations inside nested scopes
+  * (functions, blocks, etc.) are left as-is.
+  *
+  * Note:
+  * - Top-level `class X {}` declarations are always emitted as `var X = class {}` so
+  *   rolldown can hoist them alongside other top-level bindings; this transform is
+  *   independent of `topLevelVar`.
+  * - Top-level `function` declarations are never rewritten.
+  *
+  * @default false
+  *
+  *
+  */
+  topLevelVar?: boolean;
+  /**
+  * Whether to minify internal exports as single letter variables to allow for better minification.
+  *
+  * @default
+  * `true` for format `es` or if `output.minify` is `true` or object, `false` otherwise
+  *
+  *
+  */
+  minifyInternalExports?: boolean;
+  /**
+  * Clean output directory ({@linkcode dir | output.dir}) before emitting output.
+  *
+  * @default false
+  *
+  *
+  */
+  cleanDir?: boolean;
+  /**
+  * Keep `name` property of functions and classes after bundling.
+  *
+  * When enabled, the bundler will preserve the original `name` property value of functions and
+  * classes in the output. This is useful for debugging and some frameworks that rely on it for
+  * registration and binding purposes.
+  *
+  *
+  *
+  * @default false
+  */
+  keepNames?: boolean;
+  /**
+  * Lets modules be executed in the order they are declared.
+  *
+  * This is done by injecting runtime helpers to ensure that modules are executed in the order they are imported. External modules won't be affected.
+  *
+  * > [!WARNING]
+  * > Enabling this option may negatively increase bundle size. It is recommended to use this option only when absolutely necessary.
+  * @default false
+  */
+  strictExecutionOrder?: boolean;
+  /**
+  * Whether to always output `"use strict"` directive in non-ES module outputs.
+  *
+  * - `true` - Always emit `"use strict"` at the top of the output (not applicable for ESM format since ESM is always strict).
+  * - `false` - Never emit `"use strict"` in the output.
+  * - `'auto'` - Respect the `"use strict"` directives from the source code.
+  *
+  * See [In-depth directive guide](https://rolldown.rs/in-depth/directives) for more details.
+  *
+  * @default 'auto'
+  */
+  strict?: boolean | "auto";
+}
+/**
+* Built-in module tag names computed by rolldown.
+*
+* - `'$initial'` — the module is statically imported by at least one user-defined entry point, or is part of its static dependency chain.
+*/
+type BuiltinModuleTag = "$initial";
+type CodeSplittingGroup = {
+  /**
+  * Name of the group. It will be also used as the name of the chunk and replace the `[name]` placeholder in the {@linkcode OutputOptions.chunkFileNames | output.chunkFileNames} option.
+  *
+  * For example,
+  *
+  * ```js
+  * import { defineConfig } from 'rolldown';
+  *
+  * export default defineConfig({
+  *   output: {
+  *     codeSplitting: {
+  *       groups: [
+  *         {
+  *           name: 'libs',
+  *           test: /node_modules/,
+  *         },
+  *       ],
+  *     },
+  *   },
+  * });
+  * ```
+  * will create a chunk named `libs-[hash].js` in the end.
+  *
+  * It's ok to have the same name for different groups. Rolldown will deduplicate the chunk names if necessary.
+  *
+  * #### Dynamic `name()`
+  *
+  * If `name` is a function, it will be called with the module id as the argument. The function should return a string or `null`. If it returns `null`, the module will be ignored by this group.
+  *
+  * Notice, each returned new name will be treated as a separate group.
+  *
+  * For example,
+  *
+  * ```js
+  * import { defineConfig } from 'rolldown';
+  *
+  * export default defineConfig({
+  *   output: {
+  *     codeSplitting: {
+  *       groups: [
+  *         {
+  *           name: (moduleId) => moduleId.includes('node_modules') ? 'libs' : 'app',
+  *           minSize: 100 * 1024,
+  *         },
+  *       ],
+  *     },
+  *   },
+  * });
+  * ```
+  *
+  * :::warning
+  * Constraints like `minSize`, `maxSize`, etc. are applied separately for different names returned by the function.
+  * :::
+  */
+  name: string | CodeSplittingNameFunction;
+  /**
+  * Controls which modules are captured in this group.
+  *
+  * - If `test` is a string, the module whose id contains the string will be captured.
+  * - If `test` is a regular expression, the module whose id matches the regular expression will be captured.
+  * - If `test` is a function, modules for which `test(id)` returns `true` will be captured.
+  * - If `test` is empty, any module will be considered as matched.
+  *
+  * :::warning
+  * When using regular expression, it's recommended to use `[\\/]` to match the path separator instead of `/` to avoid potential issues on Windows.
+  * - ✅ Recommended: `/node_modules[\\/]react/`
+  * - ❌ Not recommended: `/node_modules/react/`
+  * :::
+  */
+  test?: StringOrRegExp | CodeSplittingTestFunction;
+  /**
+  * Priority of the group. Group with higher priority will be chosen first to match modules and create chunks. When converting the group to a chunk, modules of that group will be removed from other groups.
+  *
+  * If two groups have the same priority, the group whose index is smaller will be chosen.
+  *
+  * @example
+  * ```js
+  * import { defineConfig } from 'rolldown';
+  *
+  * export default defineConfig({
+  *   output: {
+  *     codeSplitting: {
+  *       groups: [
+  *         {
+  *           name: 'react',
+  *           test: /node_modules[\\/]react/,
+  *           priority: 2,
+  *         },
+  *         {
+  *           name: 'other-libs',
+  *           test: /node_modules/,
+  *           priority: 1,
+  *         },
+  *       ],
+  *     },
+  *   },
+  * });
+  * ```
+  *
+  * @default 0
+  */
+  priority?: number;
+  /**
+  * Minimum size in bytes of the desired chunk. If the accumulated size of the captured modules by this group is smaller than this value, it will be ignored. Modules in this group will fall back to the `automatic chunking` if they are not captured by any other group.
+  *
+  * @default 0
+  */
+  minSize?: number;
+  /**
+  * Controls if a module should be captured based on how many entry chunks reference it.
+  *
+  * @default 1
+  */
+  minShareCount?: number;
+  /**
+  * If the accumulated size in bytes of the captured modules by this group is larger than this value, this group will be split into multiple groups that each has size close to this value.
+  *
+  * @default Infinity
+  */
+  maxSize?: number;
+  /**
+  * Controls whether a module can only be captured if its size in bytes is smaller than or equal to this value.
+  *
+  * @default Infinity
+  */
+  maxModuleSize?: number;
+  /**
+  * Controls whether a module can only be captured if its size in bytes is larger than or equal to this value.
+  *
+  * @default 0
+  */
+  minModuleSize?: number;
+  /**
+  * When `false` (default), all matching modules are merged into a single chunk.
+  * Every entry that uses any of these modules must load the entire chunk — even
+  * modules it doesn't need.
+  *
+  * When `true`, matching modules are grouped by which entries actually import them.
+  * Modules shared by the same set of entries go into the same chunk, while modules
+  * shared by a different set go into a separate chunk. This way, each entry only
+  * loads the code it actually uses.
+  *
+  * Example: entries A, B, C all match a `"vendor"` group.
+  * - `moduleX` is used by A, B, C
+  * - `moduleY` is used by A, B only
+  *
+  * With `entriesAware: false` → one `vendor.js` chunk with both modules; C loads `moduleY` unnecessarily.
+  * With `entriesAware: true`  → `vendor.js` (moduleX, loaded by all) + `vendor2.js` (moduleY, loaded by A and B only).
+  *
+  * @default false
+  */
+  entriesAware?: boolean;
+  /**
+  * Size threshold in bytes for merging small `entriesAware` subgroups into the
+  * closest neighboring subgroup.
+  *
+  * This option only works when {@linkcode CodeSplittingGroup.entriesAware | entriesAware}
+  * is `true`. Set to `0` to disable subgroup merging.
+  *
+  * @default 0
+  */
+  entriesAwareMergeThreshold?: number;
+  /**
+  * Filter modules by tags. Only modules that have **all** specified tags
+  * are captured by this group. Combines with `test` and other filters —
+  * a module must match all criteria.
+  *
+  * Built-in tags: `'$initial'` (module is statically imported by a user-defined entry or part of its dependency chain).
+  *
+  * @see {@link https://rolldown.rs/in-depth/manual-code-splitting | Manual Code Splitting}
+  *
+  * @example
+  * ```js
+  * { name: 'initial-deps', tags: ['$initial'], maxSize: 1048576 }
+  * ```
+  */
+  tags?: BuiltinModuleTag[];
+};
+/**
+* Alias for {@linkcode CodeSplittingGroup}. Use this type for the `codeSplitting.groups` option.
+*
+* @deprecated Please use {@linkcode CodeSplittingGroup} instead.
+*/
+type AdvancedChunksGroup = CodeSplittingGroup;
+/**
+* Configuration options for advanced code splitting.
+*/
+type CodeSplittingOptions = {
+  /**
+  * By default, each group will also include captured modules' dependencies. This reduces the chance of generating circular chunks.
+  *
+  * If you want to disable this behavior, it's recommended to both set
+  * - {@linkcode InputOptions.preserveEntrySignatures | preserveEntrySignatures}: `false | 'allow-extension'`
+  * - {@linkcode OutputOptions.strictExecutionOrder | strictExecutionOrder}: `true`
+  *
+  * to avoid generating invalid chunks.
+  *
+  * @default true
+  */
+  includeDependenciesRecursively?: boolean;
+  /**
+  * Global fallback of {@linkcode CodeSplittingGroup.minSize | group.minSize}, if it's not specified in the group.
+  */
+  minSize?: number;
+  /**
+  * Global fallback of {@linkcode CodeSplittingGroup.maxSize | group.maxSize}, if it's not specified in the group.
+  */
+  maxSize?: number;
+  /**
+  * Global fallback of {@linkcode CodeSplittingGroup.maxModuleSize | group.maxModuleSize}, if it's not specified in the group.
+  */
+  maxModuleSize?: number;
+  /**
+  * Global fallback of {@linkcode CodeSplittingGroup.minModuleSize | group.minModuleSize}, if it's not specified in the group.
+  */
+  minModuleSize?: number;
+  /**
+  * Global fallback of {@linkcode CodeSplittingGroup.minShareCount | group.minShareCount}, if it's not specified in the group.
+  */
+  minShareCount?: number;
+  /**
+  * Groups to be used for code splitting.
+  */
+  groups?: CodeSplittingGroup[];
+};
+/**
+* Alias for {@linkcode CodeSplittingOptions}. Use this type for the `codeSplitting` option.
+*
+* @deprecated Please use {@linkcode CodeSplittingOptions} instead.
+*/
+type AdvancedChunksOptions = CodeSplittingOptions;
+//#endregion
+//#region src/api/build.d.ts
+/**
+* The options for {@linkcode build} function.
+*
+* @experimental
+* @category Programmatic APIs
+*/
+type BuildOptions = InputOptions & {
+  /**
+  * Write the output to the file system
+  *
+  * @default true
+  */
+  write?: boolean;
+  output?: OutputOptions;
+};
+/**
+* Build a single output.
+*
+* @param options The build options.
+* @returns A Promise that resolves to the build output.
+*/
+declare function build(options: BuildOptions): Promise<RolldownOutput>;
+/**
+* Build multiple outputs __sequentially__.
+*
+* @param options The build options.
+* @returns A Promise that resolves to the build outputs for each option.
+*/
+declare function build(options: BuildOptions[]): Promise<RolldownOutput[]>;
+//#endregion
+//#region src/api/rolldown/rolldown-build.d.ts
+/**
+* The bundle object returned by {@linkcode rolldown} function.
+*
+* @category Programmatic APIs
+*/
+declare class RolldownBuild {
+  #private;
+  /** @internal */
+  static asyncRuntimeShutdown: boolean;
+  /** @hidden should not be used directly */
+  constructor(inputOptions: InputOptions);
+  /**
+  * Whether the bundle has been closed.
+  *
+  * If the bundle is closed, calling other methods will throw an error.
+  */
+  get closed(): boolean;
+  /**
+  * Generate bundles in-memory.
+  *
+  * If you directly want to write bundles to disk, use the {@linkcode write} method instead.
+  *
+  * @param outputOptions The output options.
+  * @returns The generated bundle.
+  * @throws {@linkcode BundleError} When an error occurs during the build.
+  */
+  generate(outputOptions?: OutputOptions): Promise<RolldownOutput>;
+  /**
+  * Generate and write bundles to disk.
+  *
+  * If you want to generate bundles in-memory, use the {@linkcode generate} method instead.
+  *
+  * @param outputOptions The output options.
+  * @returns The generated bundle.
+  * @throws {@linkcode BundleError} When an error occurs during the build.
+  */
+  write(outputOptions?: OutputOptions): Promise<RolldownOutput>;
+  /**
+  * Close the bundle and free resources.
+  *
+  * This method is called automatically when using `using` syntax.
+  *
+  * @example
+  * ```js
+  * import { rolldown } from 'rolldown';
+  *
+  * {
+  *   using bundle = await rolldown({ input: 'src/main.js' });
+  *   const output = await bundle.generate({ format: 'esm' });
+  *   console.log(output);
+  *   // bundle.close() is called automatically here
+  * }
+  * ```
+  */
+  close(): Promise<void>;
+  /** @hidden documented in close method */
+  [Symbol.asyncDispose](): Promise<void>;
+  /**
+  * @experimental
+  * @hidden not ready for public usage yet
+  */
+  get watchFiles(): Promise<string[]>;
+}
+//#endregion
+//#region src/api/rolldown/index.d.ts
+/**
+* The API compatible with Rollup's `rollup` function.
+*
+* Unlike Rollup, the module graph is not built until the methods of the bundle object are called.
+*
+* @param input The input options object.
+* @returns A Promise that resolves to a bundle object.
+*
+* @example
+* ```js
+* import { rolldown } from 'rolldown';
+*
+* let bundle, failed = false;
+* try {
+*   bundle = await rolldown({
+*     input: 'src/main.js',
+*   });
+*   await bundle.write({
+*     format: 'esm',
+*   });
+* } catch (e) {
+*   console.error(e);
+*   failed = true;
+* }
+* if (bundle) {
+*   await bundle.close();
+* }
+* process.exitCode = failed ? 1 : 0;
+* ```
+*
+* @category Programmatic APIs
+*/
+declare const rolldown: (input: InputOptions) => Promise<RolldownBuild>;
+//#endregion
+//#region src/options/watch-options.d.ts
+/** @category Programmatic APIs */
+interface WatchOptions extends InputOptions {
+  output?: OutputOptions | OutputOptions[];
+}
+//#endregion
+//#region src/api/watch/watch-emitter.d.ts
+type ChangeEvent$1 = "create" | "update" | "delete";
+type RolldownWatchBuild = BindingWatcherBundler;
+/**
+* - `START`: the watcher is (re)starting
+* - `BUNDLE_START`: building an individual bundle
+* - `BUNDLE_END`: finished building a bundle
+*   - `duration`: the build duration in milliseconds
+*   - `output`: an array of the {@linkcode OutputOptions.file | file} or {@linkcode OutputOptions.dir | dir} option values of the generated outputs
+*   - `result`: the bundle object that can be used to generate additional outputs. This is especially important when the watch.skipWrite option is used. You should call `event.result.close()` once you are done generating outputs, or if you do not generate outputs. This will allow plugins to clean up resources via the `closeBundle` hook.
+* - `END`: finished building all bundles
+* - `ERROR`: encountered an error while bundling
+*   - `error`: the error that was thrown
+*   - `result`: the bundle object
+*
+* @category Programmatic APIs
+*/
+type RolldownWatcherEvent = {
+  code: "START";
+} | {
+  code: "BUNDLE_START";
+} | {
+  code: "BUNDLE_END";
+  duration: number;
+  output: readonly string[];
+  result: RolldownWatchBuild;
+} | {
+  code: "END";
+} | {
+  code: "ERROR";
+  error: Error;
+  result: RolldownWatchBuild;
+};
+/**
+*
+* @category Programmatic APIs
+*/
+type RolldownWatcherWatcherEventMap = {
+  event: [data: RolldownWatcherEvent]; /** a file was modified */
+  change: [id: string, change: {
+    event: ChangeEvent$1;
+  }]; /** a new run was triggered */
+  restart: []; /** the watcher was closed */
+  close: [];
+};
+/**
+* @category Programmatic APIs
+*/
+interface RolldownWatcher {
+  /**
+  * Register a listener for events defined in {@linkcode RolldownWatcherWatcherEventMap}.
+  */
+  on<E extends keyof RolldownWatcherWatcherEventMap>(event: E, listener: (...args: RolldownWatcherWatcherEventMap[E]) => MaybePromise<void>): this;
+  /**
+  * Unregister a listener for events defined in {@linkcode RolldownWatcherWatcherEventMap}.
+  */
+  off<E extends keyof RolldownWatcherWatcherEventMap>(event: E, listener: (...args: RolldownWatcherWatcherEventMap[E]) => MaybePromise<void>): this;
+  /**
+  * Unregister all listeners for a specific event defined in {@linkcode RolldownWatcherWatcherEventMap}.
+  */
+  clear<E extends keyof RolldownWatcherWatcherEventMap>(event: E): void;
+  /**
+  * Close the watcher and stop listening for file changes.
+  */
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/api/watch/index.d.ts
+/**
+* The API compatible with Rollup's `watch` function.
+*
+* This function will rebuild the bundle when it detects that the individual modules have changed on disk.
+*
+* Note that when using this function, it is your responsibility to call `event.result.close()` in response to the `BUNDLE_END` event to avoid resource leaks.
+*
+* @param input The watch options object or the list of them.
+* @returns A watcher object.
+*
+* @example
+* ```js
+* import { watch } from 'rolldown';
+*
+* const watcher = watch({ /* ... *\/ });
+* watcher.on('event', (event) => {
+*   if (event.code === 'BUNDLE_END') {
+*     console.log(event.duration);
+*     event.result.close();
+*   }
+* });
+*
+* // Stop watching
+* watcher.close();
+* ```
+*
+* @experimental
+* @category Programmatic APIs
+*/
+declare function watch(input: WatchOptions | WatchOptions[]): RolldownWatcher;
+//#endregion
+//#region src/binding-magic-string.d.ts
+interface RolldownMagicString extends BindingMagicString {
+  readonly isRolldownMagicString: true;
+  /** Accepts a string or RegExp pattern. RegExp supports `$&`, `$$`, and `$N` substitutions. */
+  replace(from: string | RegExp, to: string): this;
+  /** Accepts a string or RegExp pattern. RegExp must have the global (`g`) flag. */
+  replaceAll(from: string | RegExp, to: string): this;
+}
+type RolldownMagicStringConstructor = Omit<typeof BindingMagicString, "prototype"> & {
+  new (...args: ConstructorParameters<typeof BindingMagicString>): RolldownMagicString;
+  prototype: RolldownMagicString;
+};
+/**
+* A native MagicString implementation powered by Rust.
+*
+* @experimental
+*/
+declare const RolldownMagicString: RolldownMagicStringConstructor;
+//#endregion
+//#region src/log/log-handler.d.ts
+type LoggingFunction = (log: RolldownLog | string | (() => RolldownLog | string)) => void;
+type LoggingFunctionWithPosition = (log: RolldownLog | string | (() => RolldownLog | string), pos?: number | {
+  column: number;
+  line: number;
+}) => void;
+type WarningHandlerWithDefault = (warning: RolldownLog, defaultHandler: LoggingFunction) => void;
+//#endregion
+//#region src/options/generated/checks-options.d.ts
+interface ChecksOptions {
+  /**
+  * Whether to emit warnings when detecting circular dependency.
+  *
+  * Circular dependencies lead to a bigger bundle size and sometimes cause execution order issues and are better to avoid.
+  *
+  *
+  * @default false
+  * */
+  circularDependency?: boolean;
+  /**
+  * Whether to emit warnings when detecting uses of direct `eval`s.
+  *
+  * See [Avoiding Direct `eval` in Troubleshooting page](https://rolldown.rs/guide/troubleshooting#avoiding-direct-eval) for more details.
+  * @default true
+  * */
+  eval?: boolean;
+  /**
+  * Whether to emit warnings when the `output.globals` option is missing when needed.
+  *
+  * See [`output.globals`](https://rolldown.rs/reference/OutputOptions.globals).
+  * @default true
+  * */
+  missingGlobalName?: boolean;
+  /**
+  * Whether to emit warnings when the `output.name` option is missing when needed.
+  *
+  * See [`output.name`](https://rolldown.rs/reference/OutputOptions.name).
+  * @default true
+  * */
+  missingNameOptionForIifeExport?: boolean;
+  /**
+  * Whether to emit warnings when the way to export values is ambiguous.
+  *
+  * See [`output.exports`](https://rolldown.rs/reference/OutputOptions.exports).
+  * @default true
+  * */
+  mixedExports?: boolean;
+  /**
+  * Whether to emit warnings when an entrypoint cannot be resolved.
+  * @default true
+  * */
+  unresolvedEntry?: boolean;
+  /**
+  * Whether to emit warnings when an import cannot be resolved.
+  * @default true
+  * */
+  unresolvedImport?: boolean;
+  /**
+  * Whether to emit warnings when files generated have the same name with different contents.
+  *
+  *
+  * @default true
+  * */
+  filenameConflict?: boolean;
+  /**
+  * Whether to emit warnings when a CommonJS variable is used in an ES module.
+  *
+  * CommonJS variables like `module` and `exports` are treated as global variables in ES modules and may not work as expected.
+  *
+  *
+  * @default true
+  * */
+  commonJsVariableInEsm?: boolean;
+  /**
+  * Whether to emit warnings when an imported variable is not exported.
+  *
+  * If the code is importing a variable that is not exported by the imported module, the value will always be `undefined`. This might be a mistake in the code.
+  *
+  *
+  * @default true
+  * */
+  importIsUndefined?: boolean;
+  /**
+  * Whether to emit warnings when `import.meta` is not supported with the output format and is replaced with an empty object (`{}`).
+  *
+  * See [`import.meta` in Non-ESM Output Formats page](https://rolldown.rs/in-depth/non-esm-output-formats#import-meta) for more details.
+  * @default true
+  * */
+  emptyImportMeta?: boolean;
+  /**
+  * Whether to emit warnings when detecting tolerated transform.
+  * @default true
+  * */
+  toleratedTransform?: boolean;
+  /**
+  * Whether to emit warnings when a namespace is called as a function.
+  *
+  * A module namespace object is an object and not a function. Calling it as a function will cause a runtime error.
+  *
+  *
+  * @default true
+  * */
+  cannotCallNamespace?: boolean;
+  /**
+  * Whether to emit warnings when a config value is overridden by another config value with a higher priority.
+  *
+  *
+  * @default true
+  * */
+  configurationFieldConflict?: boolean;
+  /**
+  * Whether to emit warnings when a plugin that is covered by a built-in feature is used.
+  *
+  * Using built-in features is generally more performant than using plugins.
+  * @default true
+  * */
+  preferBuiltinFeature?: boolean;
+  /**
+  * Whether to emit warnings when Rolldown could not clean the output directory.
+  *
+  * See [`output.cleanDir`](https://rolldown.rs/reference/OutputOptions.cleanDir).
+  * @default true
+  * */
+  couldNotCleanDirectory?: boolean;
+  /**
+  * Whether to emit warnings when plugins take significant time during the build process.
+  *
+  *
+  * @default true
+  * */
+  pluginTimings?: boolean;
+  /**
+  * Whether to emit warnings when both the code and postBanner contain shebang
+  *
+  * Having multiple shebangs in a file is a syntax error.
+  * @default true
+  * */
+  duplicateShebang?: boolean;
+  /**
+  * Whether to emit warnings when a tsconfig option or combination of options is not supported.
+  * @default true
+  * */
+  unsupportedTsconfigOption?: boolean;
+  /**
+  * Whether to emit warnings when a module is dynamically imported but also statically imported, making the dynamic import ineffective for code splitting.
+  * @default true
+  * */
+  ineffectiveDynamicImport?: boolean;
+  /**
+  * Whether to emit info logs when a barrel module has a very large number of re-exports (more than 5000).
+  *
+  * Such modules can significantly slow down module resolution. Consider using
+  * [`@rolldown/plugin-transform-imports`](https://github.com/rolldown/plugins/tree/main/packages/transform-imports)
+  * to rewrite barrel imports at the source level so the barrel file is never loaded.
+  * @default true
+  * */
+  largeBarrelModules?: boolean;
+}
+//#endregion
+//#region src/options/transform-options.d.ts
+interface TransformOptions extends Omit<TransformOptions$1, "sourceType" | "lang" | "cwd" | "sourcemap" | "define" | "inject" | "jsx"> {
+  /**
+  * Replace global variables or [property accessors](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_accessors) with the provided values.
+  *
+  * See Oxc's [`define` option](https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement.html#define) for more details.
+  *
+  * @example
+  * **Replace the global variable `IS_PROD` with `true`**
+  * ```js [rolldown.config.js]
+  * export default defineConfig({
+  *   transform: { define: { IS_PROD: 'true' } }
+  * })
+  * ```
+  * Result:
+  * ```js
+  * // Input
+  * if (IS_PROD) {
+  *   console.log('Production mode')
+  * }
+  *
+  * // After bundling
+  * if (true) {
+  *   console.log('Production mode')
+  * }
+  * ```
+  *
+  * **Replace the property accessor `process.env.NODE_ENV` with `'production'`**
+  * ```js [rolldown.config.js]
+  * export default defineConfig({
+  *   transform: { define: { 'process.env.NODE_ENV': "'production'" } }
+  * })
+  * ```
+  * Result:
+  * ```js
+  * // Input
+  * if (process.env.NODE_ENV === 'production') {
+  *   console.log('Production mode')
+  * }
+  *
+  * // After bundling
+  * if ('production' === 'production') {
+  *   console.log('Production mode')
+  * }
+  * ```
+  */
+  define?: Record<string, string>;
+  /**
+  * Inject import statements on demand.
+  *
+  * The API is aligned with `@rollup/plugin-inject`.
+  *
+  * See Oxc's [`inject` option](https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement.html#inject) for more details.
+  *
+  * #### Supported patterns
+  * ```js
+  * {
+  *   // import { Promise } from 'es6-promise'
+  *   Promise: ['es6-promise', 'Promise'],
+  *
+  *   // import { Promise as P } from 'es6-promise'
+  *   P: ['es6-promise', 'Promise'],
+  *
+  *   // import $ from 'jquery'
+  *   $: 'jquery',
+  *
+  *   // import * as fs from 'node:fs'
+  *   fs: ['node:fs', '*'],
+  *
+  *   // Inject shims for property access pattern
+  *   'Object.assign': path.resolve( 'src/helpers/object-assign.js' ),
+  * }
+  * ```
+  */
+  inject?: Record<string, string | [string, string]>;
+  /**
+  * Remove labeled statements with these label names.
+  *
+  * Labeled statements are JavaScript statements prefixed with a label identifier.
+  * This option allows you to strip specific labeled statements from the output,
+  * which is useful for removing debug-only code in production builds.
+  *
+  * @example
+  * ```js rolldown.config.js
+  * export default defineConfig({
+  *   transform: { dropLabels: ['DEBUG', 'DEV'] }
+  * })
+  * ```
+  * Result:
+  * ```js
+  * // Input
+  * DEBUG: console.log('Debug info');
+  * DEV: {
+  *   console.log('Development mode');
+  * }
+  * console.log('Production code');
+  *
+  * // After bundling
+  * console.log('Production code');
+  * ```
+  */
+  dropLabels?: string[];
+  /**
+  * Controls how JSX syntax is transformed.
+  *
+  * - If set to `false`, an error will be thrown if JSX syntax is encountered.
+  * - If set to `'react'`, JSX syntax will be transformed to classic runtime React code.
+  * - If set to `'react-jsx'`, JSX syntax will be transformed to automatic runtime React code.
+  * - If set to `'preserve'`, JSX syntax will be preserved as-is.
+  */
+  jsx?: false | "react" | "react-jsx" | "preserve" | JsxOptions;
+}
+//#endregion
+//#region src/options/normalized-input-options.d.ts
+/** @category Plugin APIs */
+interface NormalizedInputOptions {
+  /** @see {@linkcode InputOptions.input | input} */
+  input: string[] | Record<string, string>;
+  /** @see {@linkcode InputOptions.cwd | cwd} */
+  cwd: string;
+  /** @see {@linkcode InputOptions.platform | platform} */
+  platform: InputOptions["platform"];
+  /** @see {@linkcode InputOptions.shimMissingExports | shimMissingExports} */
+  shimMissingExports: boolean;
+  /** @see {@linkcode InputOptions.context | context} */
+  context: string;
+  /** @see {@linkcode InputOptions.plugins | plugins} */
+  plugins: RolldownPlugin[];
+}
+//#endregion
+//#region src/options/normalized-output-options.d.ts
+type PathsFunction = (id: string) => string;
+/**
+* A normalized version of {@linkcode ModuleFormat}.
+* @category Plugin APIs
+*/
+type InternalModuleFormat = "es" | "cjs" | "iife" | "umd";
+/** @category Plugin APIs */
+interface NormalizedOutputOptions {
+  /** @see {@linkcode OutputOptions.name | name} */
+  name: string | undefined;
+  /** @see {@linkcode OutputOptions.file | file} */
+  file: string | undefined;
+  /** @see {@linkcode OutputOptions.dir | dir} */
+  dir: string | undefined;
+  /** @see {@linkcode OutputOptions.entryFileNames | entryFileNames} */
+  entryFileNames: string | ChunkFileNamesFunction;
+  /** @see {@linkcode OutputOptions.chunkFileNames | chunkFileNames} */
+  chunkFileNames: string | ChunkFileNamesFunction;
+  /** @see {@linkcode OutputOptions.assetFileNames | assetFileNames} */
+  assetFileNames: string | AssetFileNamesFunction;
+  /** @see {@linkcode OutputOptions.format | format} */
+  format: InternalModuleFormat;
+  /** @see {@linkcode OutputOptions.exports | exports} */
+  exports: NonNullable<OutputOptions["exports"]>;
+  /** @see {@linkcode OutputOptions.sourcemap | sourcemap} */
+  sourcemap: boolean | "inline" | "hidden";
+  /** @see {@linkcode OutputOptions.sourcemapBaseUrl | sourcemapBaseUrl} */
+  sourcemapBaseUrl: string | undefined;
+  /** @see {@linkcode OutputOptions.codeSplitting | codeSplitting} */
+  codeSplitting: boolean;
+  /** @deprecated Use `codeSplitting` instead. */
+  inlineDynamicImports: boolean;
+  /** @see {@linkcode OutputOptions.dynamicImportInCjs | dynamicImportInCjs} */
+  dynamicImportInCjs: boolean;
+  /** @see {@linkcode OutputOptions.externalLiveBindings | externalLiveBindings} */
+  externalLiveBindings: boolean;
+  /** @see {@linkcode OutputOptions.banner | banner} */
+  banner: AddonFunction;
+  /** @see {@linkcode OutputOptions.footer | footer} */
+  footer: AddonFunction;
+  /** @see {@linkcode OutputOptions.postBanner | postBanner} */
+  postBanner: AddonFunction;
+  /** @see {@linkcode OutputOptions.postFooter | postFooter} */
+  postFooter: AddonFunction;
+  /** @see {@linkcode OutputOptions.intro | intro} */
+  intro: AddonFunction;
+  /** @see {@linkcode OutputOptions.outro | outro} */
+  outro: AddonFunction;
+  /** @see {@linkcode OutputOptions.esModule | esModule} */
+  esModule: boolean | "if-default-prop";
+  /** @see {@linkcode OutputOptions.extend | extend} */
+  extend: boolean;
+  /** @see {@linkcode OutputOptions.globals | globals} */
+  globals: Record<string, string> | GlobalsFunction;
+  /** @see {@linkcode OutputOptions.paths | paths} */
+  paths: Record<string, string> | PathsFunction | undefined;
+  /** @see {@linkcode OutputOptions.hashCharacters | hashCharacters} */
+  hashCharacters: "base64" | "base36" | "hex";
+  /** @see {@linkcode OutputOptions.sourcemapDebugIds | sourcemapDebugIds} */
+  sourcemapDebugIds: boolean;
+  /** @see {@linkcode OutputOptions.sourcemapExcludeSources | sourcemapExcludeSources} */
+  sourcemapExcludeSources: boolean;
+  /** @see {@linkcode OutputOptions.sourcemapIgnoreList | sourcemapIgnoreList} */
+  sourcemapIgnoreList: boolean | SourcemapIgnoreListOption | StringOrRegExp | undefined;
+  /** @see {@linkcode OutputOptions.sourcemapPathTransform | sourcemapPathTransform} */
+  sourcemapPathTransform: SourcemapPathTransformOption | undefined;
+  /** @see {@linkcode OutputOptions.minify | minify} */
+  minify: false | MinifyOptions | "dce-only";
+  /**
+  * @deprecated Use `comments.legal` instead.
+  * @see {@linkcode OutputOptions.legalComments | legalComments}
+  */
+  legalComments: "none" | "inline";
+  /** @see {@linkcode OutputOptions.comments | comments} */
+  comments: Required<CommentsOptions>;
+  /** @see {@linkcode OutputOptions.polyfillRequire | polyfillRequire} */
+  polyfillRequire: boolean;
+  /** @see {@linkcode OutputOptions.plugins | plugins} */
+  plugins: RolldownPlugin[];
+  /** @see {@linkcode OutputOptions.preserveModules | preserveModules} */
+  preserveModules: boolean;
+  /** @see {@linkcode OutputOptions.virtualDirname | virtualDirname} */
+  virtualDirname: string;
+  /** @see {@linkcode OutputOptions.preserveModulesRoot | preserveModulesRoot} */
+  preserveModulesRoot?: string;
+  /** @see {@linkcode OutputOptions.topLevelVar | topLevelVar} */
+  topLevelVar?: boolean;
+  /** @see {@linkcode OutputOptions.minifyInternalExports | minifyInternalExports} */
+  minifyInternalExports?: boolean;
+}
+//#endregion
+//#region src/plugin/fs.d.ts
+/** @category Plugin APIs */
+interface RolldownFsModule {
+  appendFile(path: string, data: string | Uint8Array, options?: {
+    encoding?: BufferEncoding | null;
+    mode?: string | number;
+    flag?: string | number;
+  }): Promise<void>;
+  copyFile(source: string, destination: string, mode?: string | number): Promise<void>;
+  mkdir(path: string, options?: {
+    recursive?: boolean;
+    mode?: string | number;
+  }): Promise<void>;
+  mkdtemp(prefix: string): Promise<string>;
+  readdir(path: string, options?: {
+    withFileTypes?: false;
+  }): Promise<string[]>;
+  readdir(path: string, options?: {
+    withFileTypes: true;
+  }): Promise<RolldownDirectoryEntry[]>;
+  readFile(path: string, options?: {
+    encoding?: null;
+    flag?: string | number;
+    signal?: AbortSignal;
+  }): Promise<Uint8Array>;
+  readFile(path: string, options?: {
+    encoding: BufferEncoding;
+    flag?: string | number;
+    signal?: AbortSignal;
+  }): Promise<string>;
+  realpath(path: string): Promise<string>;
+  rename(oldPath: string, newPath: string): Promise<void>;
+  rmdir(path: string, options?: {
+    recursive?: boolean;
+  }): Promise<void>;
+  stat(path: string): Promise<RolldownFileStats>;
+  lstat(path: string): Promise<RolldownFileStats>;
+  unlink(path: string): Promise<void>;
+  writeFile(path: string, data: string | Uint8Array, options?: {
+    encoding?: BufferEncoding | null;
+    mode?: string | number;
+    flag?: string | number;
+  }): Promise<void>;
+}
+/** @category Plugin APIs */
+type BufferEncoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+/** @category Plugin APIs */
+interface RolldownDirectoryEntry {
+  isFile(): boolean;
+  isDirectory(): boolean;
+  isSymbolicLink(): boolean;
+  name: string;
+}
+/** @category Plugin APIs */
+interface RolldownFileStats {
+  isFile(): boolean;
+  isDirectory(): boolean;
+  isSymbolicLink(): boolean;
+  size: number;
+  mtime: Date;
+  ctime: Date;
+  atime: Date;
+  birthtime: Date;
+}
+//#endregion
+//#region src/plugin/hook-filter.d.ts
+/** @category Plugin APIs */
+type GeneralHookFilter<Value = StringOrRegExp> = MaybeArray<Value> | {
+  include?: MaybeArray<Value>;
+  exclude?: MaybeArray<Value>;
+};
+interface FormalModuleTypeFilter {
+  include?: ModuleType[];
+}
+/** @category Plugin APIs */
+type ModuleTypeFilter = ModuleType[] | FormalModuleTypeFilter;
+/**
+* A filter to be used to do a pre-test to determine whether the hook should be called.
+*
+* See [Plugin Hook Filters page](https://rolldown.rs/apis/plugin-api/hook-filters) for more details.
+*
+* @category Plugin APIs
+*/
+interface HookFilter {
+  /**
+  * A filter based on the module `id`.
+  *
+  * If the value is a string, it is treated as a glob pattern.
+  * The string type is not available for {@linkcode Plugin.resolveId | resolveId} hook.
+  *
+  * @example
+  * Include all `id`s that contain `node_modules` in the path.
+  * ```js
+  * { id: '**'+'/node_modules/**' }
+  * ```
+  * @example
+  * Include all `id`s that contain `node_modules` or `src` in the path.
+  * ```js
+  * { id: ['**'+'/node_modules/**', '**'+'/src/**'] }
+  * ```
+  * @example
+  * Include all `id`s that start with `http`
+  * ```js
+  * { id: /^http/ }
+  * ```
+  * @example
+  * Exclude all `id`s that contain `node_modules` in the path.
+  * ```js
+  * { id: { exclude: '**'+'/node_modules/**' } }
+  * ```
+  * @example
+  * Formal pattern to define includes and excludes.
+  * ```js
+  * { id : {
+  *   include: ['**'+'/foo/**', /bar/],
+  *   exclude: ['**'+'/baz/**', /qux/]
+  * }}
+  * ```
+  */
+  id?: GeneralHookFilter;
+  /**
+  * A filter based on the module's `moduleType`.
+  *
+  * Only available for {@linkcode Plugin.transform | transform} hook.
+  */
+  moduleType?: ModuleTypeFilter;
+  /**
+  * A filter based on the module's code.
+  *
+  * Only available for {@linkcode Plugin.transform | transform} hook.
+  */
+  code?: GeneralHookFilter;
+}
+//#endregion
+//#region src/plugin/minimal-plugin-context.d.ts
+/** @category Plugin APIs */
+interface PluginContextMeta {
+  /**
+  * A property for Rollup compatibility. A dummy value is set by Rolldown.
+  * @example `'4.23.0'`
+  */
+  rollupVersion: string;
+  /**
+  * The currently running version of Rolldown.
+  * @example `'1.0.0'`
+  */
+  rolldownVersion: string;
+  /**
+  * Whether Rolldown was started via {@linkcode watch | rolldown.watch()} or
+  * from the command line with `--watch`.
+  */
+  watchMode: boolean;
+}
+/** @category Plugin APIs */
+interface MinimalPluginContext {
+  /**
+  * Similar to {@linkcode warn | this.warn}, except that it will also abort
+  * the bundling process with an error.
+  *
+  * If an Error instance is passed, it will be used as-is, otherwise a new Error
+  * instance will be created with the given error message and all additional
+  * provided properties.
+  *
+  * In all hooks except the {@linkcode Plugin.onLog | onLog} hook, the error will
+  * be augmented with {@linkcode RolldownLog.code | code: "PLUGIN_ERROR"} and
+  * {@linkcode RolldownLog.plugin | plugin: plugin.name} properties.
+  * If a `code` property already exists and the code does not start with `PLUGIN_`,
+  * it will be renamed to {@linkcode RolldownLog.pluginCode | pluginCode}.
+  *
+  * @group Logging Methods
+  */
+  error: (e: RolldownError | string) => never;
+  /**
+  * Generate a `"info"` level log.
+  *
+  * {@linkcode RolldownLog.code | code} will be set to `"PLUGIN_LOG"` by Rolldown.
+  * As these logs are displayed by default, use them for information that is not a warning
+  * but makes sense to display to all users on every build.
+  *
+  *
+  *
+  * @inlineType LoggingFunction
+  * @group Logging Methods
+  */
+  info: LoggingFunction;
+  /**
+  * Generate a `"warn"` level log.
+  *
+  * Just like internally generated warnings, these logs will be first passed to and
+  * filtered by plugin {@linkcode Plugin.onLog | onLog} hooks before they are forwarded
+  * to custom {@linkcode InputOptions.onLog | onLog} or
+  * {@linkcode InputOptions.onwarn | onwarn} handlers or printed to the console.
+  *
+  * We encourage you to use objects with a {@linkcode RolldownLog.pluginCode | pluginCode}
+  * property as that will allow users to easily filter for those logs in an `onLog` handler.
+  *
+  *
+  *
+  * @inlineType LoggingFunction
+  * @group Logging Methods
+  */
+  warn: LoggingFunction;
+  /**
+  * Generate a `"debug"` level log.
+  *
+  * {@linkcode RolldownLog.code | code} will be set to `"PLUGIN_LOG"` by Rolldown.
+  * Make sure to add a distinctive {@linkcode RolldownLog.pluginCode | pluginCode} to
+  * those logs for easy filtering.
+  *
+  *
+  *
+  * @inlineType LoggingFunction
+  * @group Logging Methods
+  */
+  debug: LoggingFunction;
+  /** An object containing potentially useful metadata. */
+  meta: PluginContextMeta;
+}
+//#endregion
+//#region src/plugin/parallel-plugin.d.ts
+type ParallelPlugin = {
+  _parallel: {
+    fileUrl: string;
+    options: unknown;
+  };
+};
+/** @internal */
+type DefineParallelPluginResult<Options> = (options: Options) => ParallelPlugin;
+declare function defineParallelPlugin<Options>(pluginPath: string): DefineParallelPluginResult<Options>;
+//#endregion
+//#region src/plugin/plugin-context.d.ts
+/**
+* Either a {@linkcode name} or a {@linkcode fileName} can be supplied.
+* If a {@linkcode fileName} is provided, it will be used unmodified as the name
+* of the generated file, throwing an error if this causes a conflict.
+* Otherwise, if a {@linkcode name} is supplied, this will be used as substitution
+* for `[name]` in the corresponding
+* {@linkcode OutputOptions.assetFileNames | output.assetFileNames} pattern, possibly
+* adding a unique number to the end of the file name to avoid conflicts.
+* If neither a {@linkcode name} nor {@linkcode fileName} is supplied, a default name will be used.
+*
+* @category Plugin APIs
+*/
+interface EmittedAsset {
+  type: "asset";
+  name?: string;
+  fileName?: string;
+  /**
+  * An absolute path to the original file if this asset corresponds to a file on disk.
+  *
+  * This property will be passed on to subsequent plugin hooks that receive a
+  * {@linkcode PreRenderedAsset} or an {@linkcode OutputAsset} like
+  * {@linkcode Plugin.generateBundle | generateBundle}.
+  * In watch mode, Rolldown will also automatically watch this file for changes and
+  * trigger a rebuild if it changes. Therefore, it is not necessary to call
+  * {@linkcode PluginContext.addWatchFile | this.addWatchFile} for this file.
+  */
+  originalFileName?: string;
+  source: AssetSource;
+}
+/**
+* Either a {@linkcode name} or a {@linkcode fileName} can be supplied.
+* If a {@linkcode fileName} is provided, it will be used unmodified as the name
+* of the generated file, throwing an error if this causes a conflict.
+* Otherwise, if a {@linkcode name} is supplied, this will be used as substitution
+* for `[name]` in the corresponding
+* {@linkcode OutputOptions.chunkFileNames | output.chunkFileNames} pattern, possibly
+* adding a unique number to the end of the file name to avoid conflicts.
+* If neither a {@linkcode name} nor {@linkcode fileName} is supplied, a default name will be used.
+*
+* @category Plugin APIs
+*/
+interface EmittedChunk {
+  type: "chunk";
+  name?: string;
+  fileName?: string;
+  /**
+  * When provided, this will override
+  * {@linkcode InputOptions.preserveEntrySignatures | preserveEntrySignatures} for this particular
+  * chunk.
+  */
+  preserveSignature?: "strict" | "allow-extension" | "exports-only" | false;
+  /**
+  * The module id of the entry point of the chunk.
+  *
+  * It will be passed through build hooks just like regular entry points,
+  * starting with {@linkcode Plugin.resolveId | resolveId}.
+  */
+  id: string;
+  /**
+  * The value to be passed to {@linkcode Plugin.resolveId | resolveId}'s {@linkcode importer} parameter when resolving the entry point.
+  * This is important to properly resolve relative paths. If it is not provided,
+  * paths will be resolved relative to the current working directory.
+  */
+  importer?: string;
+}
+/** @category Plugin APIs */
+interface EmittedPrebuiltChunk {
+  type: "prebuilt-chunk";
+  fileName: string;
+  /**
+  * A semantic name for the chunk. If not provided, `fileName` will be used.
+  */
+  name?: string;
+  /**
+  * The code of this chunk.
+  */
+  code: string;
+  /**
+  * The list of exported variable names from this chunk.
+  *
+  * This should be provided if the chunk exports any variables.
+  */
+  exports?: string[];
+  /**
+  * The corresponding source map for this chunk.
+  */
+  map?: SourceMap;
+  sourcemapFileName?: string;
+  /**
+  * The module id of the facade module for this chunk, if any.
+  */
+  facadeModuleId?: string;
+  /**
+  * Whether this chunk corresponds to an entry point.
+  */
+  isEntry?: boolean;
+  /**
+  * Whether this chunk corresponds to a dynamic entry point.
+  */
+  isDynamicEntry?: boolean;
+}
+/** @inline @category Plugin APIs */
+type EmittedFile = EmittedAsset | EmittedChunk | EmittedPrebuiltChunk;
+/** @category Plugin APIs */
+interface PluginContextResolveOptions {
+  /**
+  * The value for {@linkcode ResolveIdExtraOptions.kind | kind} passed to
+  * {@linkcode Plugin.resolveId | resolveId} hooks.
+  */
+  kind?: BindingPluginContextResolveOptions["importKind"];
+  /**
+  * The value for {@linkcode ResolveIdExtraOptions.isEntry | isEntry} passed to
+  * {@linkcode Plugin.resolveId | resolveId} hooks.
+  *
+  * @default `false` if there's an importer, `true` otherwise.
+  */
+  isEntry?: boolean;
+  /**
+  * Whether the {@linkcode Plugin.resolveId | resolveId} hook of the plugin from
+  * which {@linkcode PluginContext.resolve | this.resolve} is called will be skipped
+  * when resolving.
+  *
+  *
+  *
+  * @default true
+  */
+  skipSelf?: boolean;
+  /**
+  * Plugin-specific options.
+  *
+  * See [Custom resolver options section](https://rolldown.rs/apis/plugin-api/inter-plugin-communication#custom-resolver-options) for more details.
+  */
+  custom?: CustomPluginOptions;
+}
+/** @inline */
+type GetModuleInfo = (moduleId: string) => ModuleInfo | null;
+/** @category Plugin APIs */
+interface PluginContext extends MinimalPluginContext {
+  /**
+  * Provides abstract access to the file system.
+  */
+  fs: RolldownFsModule;
+  /**
+  * Emits a new file that is included in the build output.
+  * You can emit chunks, prebuilt chunks or assets.
+  *
+  *
+  *
+  * @returns A `referenceId` for the emitted file that can be used in various places to reference the emitted file.
+  */
+  emitFile(file: EmittedFile): string;
+  /**
+  * Get the file name of a chunk or asset that has been emitted via
+  * {@linkcode emitFile | this.emitFile}.
+  *
+  * @returns The file name of the emitted file. Relative to {@linkcode OutputOptions.dir | output.dir}.
+  */
+  getFileName(referenceId: string): string;
+  /**
+  * Get all module ids in the current module graph.
+  *
+  * @returns
+  * An iterator of module ids. It can be iterated via
+  * ```js
+  * for (const moduleId of this.getModuleIds()) {
+  *   // ...
+  * }
+  * ```
+  * or converted into an array via `Array.from(this.getModuleIds())`.
+  */
+  getModuleIds(): IterableIterator<string>;
+  /**
+  * Get additional information about the module in question.
+  *
+  *
+  *
+  * @returns Module information for that module. `null` if the module could not be found.
+  * @group Methods
+  */
+  getModuleInfo: GetModuleInfo;
+  /**
+  * Adds additional files to be monitored in watch mode so that changes to these files will trigger rebuilds.
+  *
+  *
+  */
+  addWatchFile(id: string): void;
+  /**
+  * Loads and parses the module corresponding to the given id, attaching additional
+  * meta information to the module if provided. This will trigger the same
+  * {@linkcode Plugin.load | load}, {@linkcode Plugin.transform | transform} and
+  * {@linkcode Plugin.moduleParsed | moduleParsed} hooks as if the module was imported
+  * by another module.
+  *
+  *
+  */
+  load(options: {
+    id: string;
+    resolveDependencies?: boolean;
+  } & Partial<PartialNull<ModuleOptions>>): Promise<ModuleInfo>;
+  /**
+  * Use Rolldown's internal parser to parse code to an [ESTree-compatible](https://github.com/estree/estree) AST.
+  */
+  parse(input: string, options?: ParserOptions | null): Program;
+  /**
+  * Resolve imports to module ids (i.e. file names) using the same plugins that Rolldown uses,
+  * and determine if an import should be external.
+  *
+  * When calling this function from a {@linkcode Plugin.resolveId | resolveId} hook, you should
+  * always check if it makes sense for you to pass along the
+  * {@link PluginContextResolveOptions | options}.
+  *
+  * @returns
+  * If `Promise<null>` is returned, the import could not be resolved by Rolldown or any plugin
+  * but was not explicitly marked as external by the user.
+  * If an absolute external id is returned that should remain absolute in the output either
+  * via the
+  * {@linkcode InputOptions.makeAbsoluteExternalsRelative | makeAbsoluteExternalsRelative}
+  * option or by explicit plugin choice in the {@linkcode Plugin.resolveId | resolveId} hook,
+  * `external` will be `"absolute"` instead of `true`.
+  */
+  resolve(source: string, importer?: string, options?: PluginContextResolveOptions): Promise<ResolvedId | null>;
+}
+//#endregion
+//#region src/plugin/transform-plugin-context.d.ts
+/** @category Plugin APIs */
+interface TransformPluginContext extends PluginContext {
+  /**
+  * Same as {@linkcode PluginContext.debug}, but a `position` param can be supplied.
+  *
+  * @inlineType LoggingFunctionWithPosition
+  * @group Logging Methods
+  */
+  debug: LoggingFunctionWithPosition;
+  /**
+  * Same as {@linkcode PluginContext.info}, but a `position` param can be supplied.
+  *
+  * @inlineType LoggingFunctionWithPosition
+  * @group Logging Methods
+  */
+  info: LoggingFunctionWithPosition;
+  /**
+  * Same as {@linkcode PluginContext.warn}, but a `position` param can be supplied.
+  *
+  * @inlineType LoggingFunctionWithPosition
+  * @group Logging Methods
+  */
+  warn: LoggingFunctionWithPosition;
+  /**
+  * Same as {@linkcode PluginContext.error}, but the `id` of the current module will
+  * also be added and a `position` param can be supplied.
+  */
+  error(e: RolldownError | string, pos?: number | {
+    column: number;
+    line: number;
+  }): never;
+  /**
+  * Get the combined source maps of all previous plugins.
+  */
+  getCombinedSourcemap(): SourceMap;
+}
+//#endregion
+//#region src/types/module-side-effects.d.ts
+interface ModuleSideEffectsRule {
+  test?: RegExp;
+  external?: boolean;
+  sideEffects: boolean;
+}
+type ModuleSideEffectsOption = boolean | readonly string[] | ModuleSideEffectsRule[] | ((id: string, external: boolean) => boolean | undefined) | "no-external";
+/**
+* When passing an object, you can fine-tune the tree-shaking behavior.
+*/
+type TreeshakingOptions = {
+  /**
+  * **Values:**
+  *
+  * - **`true`**: All modules are assumed to have side effects and will be included in the bundle even if none of their exports are used.
+  * - **`false`**: No modules have side effects. This enables aggressive tree-shaking, removing any modules whose exports are not used.
+  * - **`string[]`**: Array of module IDs that have side effects. Only modules in this list will be preserved if unused; all others can be tree-shaken when their exports are unused.
+  * - **`'no-external'`**: Assumes no external modules have side effects while preserving the default behavior for local modules.
+  * - **`ModuleSideEffectsRule[]`**: Array of rules with `test`, `external`, and `sideEffects` properties for fine-grained control.
+  * - **`function`**: Function that receives `(id, external)` and returns whether the module has side effects.
+  *
+  * **Important:** Setting this to `false` or using an array/string assumes that your modules and their dependencies have no side effects other than their exports. Only use this if you're certain that removing unused modules won't break your application.
+  *
+  * > [!NOTE]
+  * > **Performance: Prefer `ModuleSideEffectsRule[]` over functions**
+  * >
+  * > When possible, use rule-based configuration instead of functions. Rules are processed entirely in Rust, while JavaScript functions require runtime calls between Rust and JavaScript, which can hurt CPU utilization during builds.
+  * >
+  * > **Functions should be a last resort**: Only use the function signature when your logic cannot be expressed with patterns or simple string matching.
+  * >
+  * > **Rule advantages**: `ModuleSideEffectsRule[]` provides better performance by avoiding Rust-JavaScript runtime calls, clearer intent, and easier maintenance.
+  *
+  * @example
+  * ```js
+  * // Assume no modules have side effects (aggressive tree-shaking)
+  * treeshake: {
+  *   moduleSideEffects: false
+  * }
+  *
+  * // Only specific modules have side effects (string array)
+  * treeshake: {
+  *   moduleSideEffects: [
+  *     'lodash',
+  *     'react-dom',
+  *   ]
+  * }
+  *
+  * // Use rules for pattern matching and granular control
+  * treeshake: {
+  *   moduleSideEffects: [
+  *     { test: /^node:/, sideEffects: true },
+  *     { test: /\.css$/, sideEffects: true },
+  *     { test: /some-package/, sideEffects: false, external: false },
+  *   ]
+  * }
+  *
+  * // Custom function to determine side effects
+  * treeshake: {
+  *   moduleSideEffects: (id, external) => {
+  *     if (external) return false; // external modules have no side effects
+  *     return id.includes('/side-effects/') || id.endsWith('.css');
+  *   }
+  * }
+  *
+  * // Assume no external modules have side effects
+  * treeshake: {
+  *   moduleSideEffects: 'no-external',
+  * }
+  * ```
+  *
+  * **Common Use Cases:**
+  * - **CSS files**: `{ test: /\.css$/, sideEffects: true }` - preserve CSS imports
+  * - **Polyfills**: Add specific polyfill modules to the array
+  * - **Plugins**: Modules that register themselves globally on import
+  * - **Library development**: Set to `false` for libraries where unused exports should be removed
+  *
+  * @default true
+  */
+  moduleSideEffects?: ModuleSideEffectsOption;
+  /**
+  * Whether to respect `/*@__PURE__*\/` annotations and other tree-shaking hints in the code.
+  *
+  * See [related Oxc documentation](https://oxc.rs/docs/guide/usage/minifier/dead-code-elimination#pure-annotations) for more details.
+  *
+  * @default true
+  */
+  annotations?: boolean;
+  /**
+  * Array of function names that should be considered pure (no side effects) even if they can't be automatically detected as pure.
+  *
+  * See [related Oxc documentation](https://oxc.rs/docs/guide/usage/minifier/dead-code-elimination#define-pure-functions) for more details.
+  *
+  * @example
+  * ```js
+  * treeshake: {
+  *   manualPureFunctions: ['console.log', 'debug.trace']
+  * }
+  * ```
+  * @default []
+  */
+  manualPureFunctions?: readonly string[];
+  /**
+  * Whether to assume that accessing unknown global properties might have side effects.
+  *
+  * See [related Oxc documentation](https://oxc.rs/docs/guide/usage/minifier/dead-code-elimination#ignoring-global-variable-access-side-effects) for more details.
+  *
+  * @default true
+  */
+  unknownGlobalSideEffects?: boolean;
+  /**
+  * Whether to assume that invalid import statements might have side effects.
+  *
+  * See [related Oxc documentation](https://oxc.rs/docs/guide/usage/minifier/dead-code-elimination#ignoring-invalid-import-statement-side-effects) for more details.
+  *
+  * @default false
+  */
+  invalidImportSideEffects?: boolean;
+  /**
+  * Whether to enable tree-shaking for CommonJS modules. When `true`, unused exports from CommonJS modules can be eliminated from the bundle, similar to ES modules. When disabled, CommonJS modules will always be included in their entirety.
+  *
+  * This option allows rolldown to analyze `exports.property` assignments in CommonJS modules and remove unused exports while preserving the module's side effects.
+  *
+  * @example
+  * ```js
+  * // source.js (CommonJS)
+  * exports.used = 'This will be kept';
+  * exports.unused = 'This will be tree-shaken away';
+  *
+  * // main.js
+  * import { used } from './source.js';
+  * // With commonjs: true, only the 'used' export is included in the bundle
+  * // With commonjs: false, both exports are included
+  * ```
+  * @default true
+  */
+  commonjs?: boolean;
+  /**
+  * Controls whether reading properties from objects is considered to have side effects.
+  *
+  * Set to `false` for more aggressive tree-shaking behavior.
+  *
+  * See [related Oxc documentation](https://oxc.rs/docs/guide/usage/minifier/dead-code-elimination#ignoring-property-read-side-effects) for more details.
+  *
+  * @default 'always'
+  */
+  propertyReadSideEffects?: false | "always";
+  /**
+  * Controls whether writing properties to objects is considered to have side effects.
+  *
+  * Set to `false` for more aggressive behavior.
+  *
+  * @default 'always'
+  */
+  propertyWriteSideEffects?: false | "always";
+};
+//#endregion
+//#region src/types/output-bundle.d.ts
+/** @category Plugin APIs */
+interface OutputBundle {
+  [fileName: string]: OutputAsset | OutputChunk;
+}
+//#endregion
+//#region src/types/sourcemap.d.ts
+/** @category Plugin APIs */
+interface ExistingRawSourceMap {
+  file?: string | null;
+  mappings: string;
+  names?: string[];
+  sources?: (string | null)[];
+  sourcesContent?: (string | null | undefined)[];
+  sourceRoot?: string;
+  version?: number;
+  x_google_ignoreList?: number[];
+}
+/** @inline @category Plugin APIs */
+type SourceMapInput = ExistingRawSourceMap | string | null;
+//#endregion
+//#region src/utils/error.d.ts
+/**
+* The error type that is thrown by Rolldown for the whole build.
+*/
+type BundleError = Error & {
+  /**
+  * The individual errors that happened during the build.
+  *
+  * This property is a getter to avoid unnecessary expansion of error details when the error is logged.
+  */
+  errors?: RolldownError[];
+};
+//#endregion
+//#region src/constants/version.d.ts
+/**
+* The version of Rolldown.
+* @example `'1.0.0'`
+*
+* @category Plugin APIs
+*/
+declare const VERSION: string;
+//#endregion
+//#region src/constants/index.d.ts
+/**
+* Runtime helper module ID
+*/
+declare const RUNTIME_MODULE_ID = "\0rolldown/runtime.js";
+//#endregion
+//#region src/builtin-plugin/utils.d.ts
+declare class BuiltinPlugin {
+  name: BindingBuiltinPluginName;
+  _options?: unknown;
+  /** Vite-specific option to control plugin ordering */
+  enforce?: "pre" | "post";
+  constructor(name: BindingBuiltinPluginName, _options?: unknown);
+}
+//#endregion
+//#region src/constants/plugin.d.ts
+declare const ENUMERATED_INPUT_PLUGIN_HOOK_NAMES: readonly ["options", "buildStart", "resolveId", "load", "transform", "moduleParsed", "buildEnd", "onLog", "resolveDynamicImport", "closeBundle", "closeWatcher", "watchChange"];
+declare const ENUMERATED_OUTPUT_PLUGIN_HOOK_NAMES: readonly ["augmentChunkHash", "outputOptions", "renderChunk", "renderStart", "renderError", "writeBundle", "generateBundle"];
+declare const ENUMERATED_PLUGIN_HOOK_NAMES: [...typeof ENUMERATED_INPUT_PLUGIN_HOOK_NAMES, ...typeof ENUMERATED_OUTPUT_PLUGIN_HOOK_NAMES, "footer", "banner", "intro", "outro"];
+/**
+* Names of all defined hooks. It's like
+* ```ts
+* type DefinedHookNames = {
+*   options: 'options',
+*   buildStart: 'buildStart',
+*   ...
+* }
+* ```
+*/
+type DefinedHookNames = { readonly [K in (typeof ENUMERATED_PLUGIN_HOOK_NAMES)[number]]: K };
+/**
+* Names of all defined hooks. It's like
+* ```js
+* const DEFINED_HOOK_NAMES ={
+*   options: 'options',
+*   buildStart: 'buildStart',
+*   ...
+* }
+* ```
+*/
+declare const DEFINED_HOOK_NAMES: DefinedHookNames;
+//#endregion
+//#region src/plugin/with-filter.d.ts
+type OverrideFilterObject = {
+  transform?: HookFilterExtension<"transform">["filter"];
+  resolveId?: HookFilterExtension<"resolveId">["filter"];
+  load?: HookFilterExtension<"load">["filter"];
+  pluginNamePattern?: StringOrRegExp[];
+};
+/**
+* A helper function to add plugin hook filters to a plugin or an array of plugins.
+*
+* @example
+* ```ts
+* import yaml from '@rollup/plugin-yaml';
+* import { defineConfig } from 'rolldown';
+* import { withFilter } from 'rolldown/filter';
+*
+* export default defineConfig({
+*   plugins: [
+*     // Run the transform hook of the `yaml` plugin
+*     // only for modules which end in `.yaml`
+*     withFilter(
+*       yaml({}),
+*       { transform: { id: /\.yaml$/ } },
+*     ),
+*   ],
+* });
+* ```
+*
+* @category Config
+*/
+declare function withFilter<A, T extends RolldownPluginOption<A>>(pluginOption: T, filterObject: OverrideFilterObject | OverrideFilterObject[]): T;
+//#endregion
+//#region src/plugin/index.d.ts
+type ModuleSideEffects = boolean | "no-treeshake" | null;
+/** @category Plugin APIs */
+type ModuleType = "js" | "jsx" | "ts" | "tsx" | "json" | "text" | "base64" | "dataurl" | "binary" | "empty" | (string & {});
+/** @category Plugin APIs */
+type ImportKind = BindingHookResolveIdExtraArgs["kind"];
+/** @category Plugin APIs */
+interface CustomPluginOptions {
+  [plugin: string]: any;
+}
+/** @category Plugin APIs */
+interface ModuleOptions {
+  moduleSideEffects: ModuleSideEffects;
+  /** See [Custom module meta-data section](https://rolldown.rs/apis/plugin-api/inter-plugin-communication#custom-module-meta-data) for more details. */
+  meta: CustomPluginOptions;
+  invalidate?: boolean;
+  packageJsonPath?: string;
+}
+/** @category Plugin APIs */
+interface ResolvedId extends ModuleOptions {
+  external: boolean | "absolute";
+  id: string;
+}
+interface SpecifiedModuleOptions {
+  /**
+  * Indicates whether the module has side effects to Rolldown.
+  *
+  * - If `false` is set and no other module imports anything from this module, then this module will not be included in the bundle even if the module would have side effects.
+  * - If `true` is set, Rolldown will use its default algorithm to include all statements in the module that has side effects.
+  * - If `"no-treeshake"` is set, treeshaking will be disabled for this module, and this module will be included in one of the chunks even if it is empty.
+  *
+  * The precedence of this option is as follows (highest to lowest):
+  * 1. {@linkcode Plugin.transform | transform} hook's returned `moduleSideEffects` option
+  * 2. {@linkcode Plugin.load | load} hook's returned `moduleSideEffects` option
+  * 3. {@linkcode Plugin.resolveId | resolveId} hook's returned `moduleSideEffects` option
+  * 4. {@linkcode TreeshakingOptions.moduleSideEffects | treeshake.moduleSideEffects} option
+  * 5. `sideEffects` field in the `package.json` file
+  * 6. `true` (default)
+  */
+  moduleSideEffects?: ModuleSideEffects | null;
+}
+/** @category Plugin APIs */
+interface PartialResolvedId extends SpecifiedModuleOptions, Partial<PartialNull<ModuleOptions>> {
+  /**
+  * Whether this id should be treated as external.
+  *
+  * Relative external ids, i.e. ids starting with `./` or `../`, will not be internally
+  * converted to an absolute id and converted back to a relative id in the output,
+  * but are instead included in the output unchanged.
+  * If you want relative ids to be re-normalized and deduplicated instead, return
+  * an absolute file system location as id and choose `external: "relative"`.
+  *
+  * - If `true`, absolute ids will be converted to relative ids based on the user's choice for the {@linkcode InputOptions.makeAbsoluteExternalsRelative | makeAbsoluteExternalsRelative} option.
+  * - If `'relative'`, absolute ids will always be converted to relative ids.
+  * - If `'absolute'`, absolute ids will always be kept as absolute ids.
+  */
+  external?: boolean | "absolute" | "relative";
+  id: string;
+}
+/** @category Plugin APIs */
+interface SourceDescription extends SpecifiedModuleOptions, Partial<PartialNull<ModuleOptions>> {
+  code: string;
+  /**
+  * The source map for the transformation.
+  *
+  * If the transformation does not move code, you can preserve existing sourcemaps by setting this to `null`.
+  *
+  * See [Source Code Transformations section](https://rolldown.rs/apis/plugin-api/transformations#source-code-transformations) for more details.
+  */
+  map?: SourceMapInput;
+  moduleType?: ModuleType;
+}
+/** @inline */
+interface ResolveIdExtraOptions {
+  /**
+  * Plugin-specific options.
+  *
+  * See [Custom resolver options section](https://rolldown.rs/apis/plugin-api/inter-plugin-communication#custom-resolver-options) for more details.
+  */
+  custom?: CustomPluginOptions;
+  /**
+  * Whether this is resolution for an entry point.
+  *
+  *
+  */
+  isEntry: boolean;
+  /**
+  * The kind of import being resolved.
+  *
+  * - `import-statement`: `import { foo } from './lib.js';`
+  * - `dynamic-import`: `import('./lib.js')`
+  * - `require-call`: `require('./lib.js')`
+  * - `import-rule`: `@import 'bg-color.css'` (experimental)
+  * - `url-token`: `url('./icon.png')` (experimental)
+  * - `new-url`: `new URL('./worker.js', import.meta.url)` (experimental)
+  * - `hot-accept`: `import.meta.hot.accept('./lib.js', () => {})` (experimental)
+  */
+  kind: BindingHookResolveIdExtraArgs["kind"];
+}
+/** @inline @category Plugin APIs */
+type ResolveIdResult = string | NullValue | false | PartialResolvedId;
+/** @inline @category Plugin APIs */
+type LoadResult = NullValue | string | SourceDescription;
+/** @inline @category Plugin APIs */
+type TransformResult = NullValue | string | (Omit<SourceDescription, "code"> & {
+  code?: string | RolldownMagicString;
+});
+type RenderedChunkMeta = {
+  /**
+  * Contains information about all chunks that are being rendered.
+  * This is useful to explore the entire chunk graph.
+  */
+  chunks: Record<string, RenderedChunk>;
+  /**
+  * A lazily-created MagicString instance for the chunk's code.
+  * Use this to perform string transformations with automatic source map support.
+  * This is only available when `experimental.nativeMagicString` is enabled.
+  */
+  magicString?: RolldownMagicString;
+};
+/** @category Plugin APIs */
+interface FunctionPluginHooks {
+  /**
+  * A function that receives and filters logs and warnings generated by Rolldown and
+  * plugins before they are passed to the {@linkcode InputOptions.onLog | onLog} option
+  * or printed to the console.
+  *
+  * If `false` is returned, the log will be filtered out.
+  * Otherwise, the log will be handed to the `onLog` hook of the next plugin,
+  * the {@linkcode InputOptions.onLog | onLog} option, or printed to the console.
+  * Plugins can also change the log level of a log or turn a log into an error by passing
+  * the `log` object to {@linkcode MinimalPluginContext.error | this.error},
+  * {@linkcode MinimalPluginContext.warn | this.warn},
+  * {@linkcode MinimalPluginContext.info | this.info} or
+  * {@linkcode MinimalPluginContext.debug | this.debug} and returning `false`.
+  *
+  *
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.onLog]: (this: MinimalPluginContext, level: LogLevel, log: RolldownLog) => NullValue | boolean;
+  /**
+  * Replaces or manipulates the options object passed to {@linkcode rolldown | rolldown()}.
+  *
+  * Returning `null` does not replace anything.
+  *
+  * If you just need to read the options, it is recommended to use
+  * the {@linkcode buildStart} hook as that hook has access to the options
+  * after the transformations from all `options` hooks have been taken into account.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.options]: (this: MinimalPluginContext, options: InputOptions) => NullValue | InputOptions;
+  /**
+  * Replaces or manipulates the output options object passed to
+  * {@linkcode RolldownBuild.generate | bundle.generate()} or
+  * {@linkcode RolldownBuild.write | bundle.write()}.
+  *
+  * Returning null does not replace anything.
+  *
+  * If you just need to read the output options, it is recommended to use
+  * the {@linkcode renderStart} hook as this hook has access to the output options
+  * after the transformations from all `outputOptions` hooks have been taken into account.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.outputOptions]: (this: MinimalPluginContext, options: OutputOptions) => NullValue | OutputOptions;
+  /**
+  * Called on each {@linkcode rolldown | rolldown()} build.
+  *
+  * This is the recommended hook to use when you need access to the options passed to {@linkcode rolldown | rolldown()} as it takes the transformations by all options hooks into account and also contains the right default values for unset options.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.buildStart]: (this: PluginContext, options: NormalizedInputOptions) => void;
+  /**
+  * Defines a custom resolver.
+  *
+  * A resolver can be useful for e.g. locating third-party dependencies.
+  *
+  * Returning `null` defers to other `resolveId` hooks and eventually the default resolution behavior.
+  * Returning `false` signals that `source` should be treated as an external module and not included in the bundle. If this happens for a relative import, the id will be renormalized the same way as when the {@linkcode InputOptions.external} option is used.
+  * If you return an object, then it is possible to resolve an import to a different id while excluding it from the bundle at the same time.
+  *
+  * Note that while `resolveId` will be called for each import of a module and can therefore
+  * resolve to the same `id` many times, values for `external`, `meta` or `moduleSideEffects`
+  * can only be set once before the module is loaded. The reason is that after this call,
+  * Rolldown will continue with the {@linkcode load} and {@linkcode transform} hooks for that
+  * module that may override these values and should take precedence if they do so.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.resolveId]: (this: PluginContext, source: string, importer: string | undefined, extraOptions: ResolveIdExtraOptions) => ResolveIdResult;
+  /**
+  * Defines a custom resolver for dynamic imports.
+  *
+  * @deprecated
+  * This hook exists only for Rollup compatibility. Please use {@linkcode resolveId} instead.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.resolveDynamicImport]: (this: PluginContext, source: string, importer: string | undefined) => ResolveIdResult;
+  /**
+  * Defines a custom loader.
+  *
+  * Returning `null` defers to other `load` hooks or the built-in loading mechanism.
+  *
+  * You can use {@linkcode PluginContext.getModuleInfo | this.getModuleInfo()} to find out the previous values of `meta`, `moduleSideEffects` inside this hook.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.load]: (this: PluginContext, id: string) => MaybePromise<LoadResult>;
+  /**
+  * Can be used to transform individual modules.
+  *
+  * Note that it's possible to return only properties and no code transformations.
+  *
+  * You can use {@linkcode PluginContext.getModuleInfo | this.getModuleInfo()} to find out the previous values of `meta`, `moduleSideEffects` inside this hook.
+  *
+  *
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.transform]: (this: TransformPluginContext, code: string, id: string, meta: BindingTransformHookExtraArgs & {
+    moduleType: ModuleType;
+    magicString?: RolldownMagicString;
+    ast?: Program;
+  }) => TransformResult;
+  /**
+  * This hook is called each time a module has been fully parsed by Rolldown.
+  *
+  * This hook will wait until all imports are resolved so that the information in
+  * {@linkcode ModuleInfo.importedIds | moduleInfo.importedIds},
+  * {@linkcode ModuleInfo.dynamicallyImportedIds | moduleInfo.dynamicallyImportedIds}
+  * are complete and accurate. Note however that information about importing modules
+  * may be incomplete as additional importers could be discovered later.
+  * If you need this information, use the {@linkcode buildEnd} hook.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.moduleParsed]: (this: PluginContext, moduleInfo: ModuleInfo) => void;
+  /**
+  * Called when Rolldown has finished bundling, but before Output Generation Hooks.
+  * If an error occurred during the build, it is passed on to this hook.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.buildEnd]: (this: PluginContext, err?: Error) => void;
+  /**
+  * Called initially each time {@linkcode RolldownBuild.generate | bundle.generate()} or
+  * {@linkcode RolldownBuild.write | bundle.write()} is called.
+  *
+  * To get notified when generation has completed, use the {@linkcode generateBundle} and
+  * {@linkcode renderError} hooks.
+  *
+  * This is the recommended hook to use when you need access to the output options passed to
+  * {@linkcode RolldownBuild.generate | bundle.generate()} or
+  * {@linkcode RolldownBuild.write | bundle.write()} as it takes the transformations by all outputOptions hooks into account and also contains the right default values for unset options.
+  *
+  * It also receives the input options passed to {@linkcode rolldown | rolldown()} so that
+  * plugins that can be used as output plugins, i.e. plugins that only use generate phase hooks,
+  * can get access to them.
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.renderStart]: (this: PluginContext, outputOptions: NormalizedOutputOptions, inputOptions: NormalizedInputOptions) => void;
+  /**
+  * Can be used to transform individual chunks. Called for each Rolldown output chunk file.
+  *
+  * Returning null will apply no transformations. If you change code in this hook and want to support source maps, you need to return a map describing your changes, see [Source Code Transformations section](https://rolldown.rs/apis/plugin-api/transformations#source-code-transformations).
+  *
+  * `chunk` is mutable and changes applied in this hook will propagate to other plugins and
+  * to the generated bundle.
+  * That means if you add or remove imports or exports in this hook, you should update
+  * {@linkcode RenderedChunk.imports | imports}, {@linkcode RenderedChunk.importedBindings | importedBindings} and/or {@linkcode RenderedChunk.exports | exports} accordingly.
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.renderChunk]: (this: PluginContext, code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions, meta: RenderedChunkMeta) => NullValue | string | RolldownMagicString | {
+    code: string | RolldownMagicString;
+    map?: SourceMapInput;
+  };
+  /**
+  * Can be used to augment the hash of individual chunks. Called for each Rolldown output chunk.
+  *
+  * Returning a falsy value will not modify the hash.
+  * Truthy values will be used as an additional source for hash calculation.
+  *
+  *
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.augmentChunkHash]: (this: PluginContext, chunk: RenderedChunk) => string | void;
+  /**
+  * Called when Rolldown encounters an error during
+  * {@linkcode RolldownBuild.generate | bundle.generate()} or
+  * {@linkcode RolldownBuild.write | bundle.write()}.
+  *
+  * To get notified when generation completes successfully, use the
+  * {@linkcode generateBundle} hook.
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.renderError]: (this: PluginContext, error: Error) => void;
+  /**
+  * Called at the end of {@linkcode RolldownBuild.generate | bundle.generate()} or
+  * immediately before the files are written in
+  * {@linkcode RolldownBuild.write | bundle.write()}.
+  *
+  * To modify the files after they have been written, use the {@linkcode writeBundle} hook.
+  *
+  *
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.generateBundle]: (this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle, isWrite: boolean) => void;
+  /**
+  * Called only at the end of {@linkcode RolldownBuild.write | bundle.write()} once
+  * all files have been written.
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.writeBundle]: (this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle) => void;
+  /**
+  * Can be used to clean up any external service that may be running.
+  *
+  * Rolldown's CLI will make sure this hook is called after each run, but it is the responsibility
+  * of users of the JavaScript API to manually call
+  * {@linkcode RolldownBuild.close | bundle.close()} once they are done generating bundles.
+  * For that reason, any plugin relying on this feature should carefully mention this in
+  * its documentation.
+  *
+  * If a plugin wants to retain resources across builds in watch mode, they can check for
+  * {@linkcode PluginContextMeta.watchMode | this.meta.watchMode} in this hook and perform
+  * the necessary cleanup for watch mode in closeWatcher.
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.closeBundle]: (this: PluginContext, error?: Error) => void;
+  /**
+  * Notifies a plugin whenever Rolldown has detected a change to a monitored file in watch mode.
+  *
+  * If a build is currently running, this hook is called once the build finished.
+  * It will be called once for every file that changed.
+  *
+  * This hook cannot be used by output plugins.
+  *
+  * If you need to be notified immediately when a file changed, you can use the {@linkcode WatcherOptions.onInvalidate | watch.onInvalidate} option.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.watchChange]: (this: PluginContext, id: string, event: {
+    event: ChangeEvent;
+  }) => void;
+  /**
+  * Notifies a plugin when the watcher process will close so that all open resources can be closed too.
+  *
+  * This hook cannot be used by output plugins.
+  *
+  * @group Build Hooks
+  */
+  [DEFINED_HOOK_NAMES.closeWatcher]: (this: PluginContext) => void;
+}
+type ChangeEvent = "create" | "update" | "delete";
+type PluginOrder = "pre" | "post" | null;
+/** @inline */
+type ObjectHookMeta = {
+  order?: PluginOrder;
+};
+/**
+* A hook in a function or an object form with additional properties.
+*
+* @typeParam T - The type of the hook function.
+* @typeParam O - Additional properties that are specific to some hooks.
+*
+*
+*
+* @category Plugin APIs
+*/
+type ObjectHook<T, O = {}> = T | ({
+  handler: T;
+} & ObjectHookMeta & O);
+type SyncPluginHooks = DefinedHookNames["augmentChunkHash" | "onLog" | "outputOptions"];
+/** @category Plugin APIs */
+type AsyncPluginHooks = Exclude<keyof FunctionPluginHooks, SyncPluginHooks>;
+type FirstPluginHooks = DefinedHookNames["load" | "resolveDynamicImport" | "resolveId"];
+type SequentialPluginHooks = DefinedHookNames["augmentChunkHash" | "generateBundle" | "onLog" | "options" | "outputOptions" | "renderChunk" | "transform"];
+interface AddonHooks {
+  /**
+  * A hook equivalent to {@linkcode OutputOptions.banner | output.banner} option.
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.banner]: AddonHook;
+  /**
+  * A hook equivalent to {@linkcode OutputOptions.footer | output.footer} option.
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.footer]: AddonHook;
+  /**
+  * A hook equivalent to {@linkcode OutputOptions.intro | output.intro} option.
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.intro]: AddonHook;
+  /**
+  * A hook equivalent to {@linkcode OutputOptions.outro | output.outro} option.
+  *
+  * @group Output Generation Hooks
+  */
+  [DEFINED_HOOK_NAMES.outro]: AddonHook;
+}
+type OutputPluginHooks = DefinedHookNames["augmentChunkHash" | "generateBundle" | "outputOptions" | "renderChunk" | "renderError" | "renderStart" | "writeBundle"];
+/** @internal */
+type ParallelPluginHooks = Exclude<keyof FunctionPluginHooks | keyof AddonHooks, FirstPluginHooks | SequentialPluginHooks>;
+/** @category Plugin APIs */
+type HookFilterExtension<K extends keyof FunctionPluginHooks> = K extends "transform" ? {
+  filter?: HookFilter | TopLevelFilterExpression[];
+} : K extends "load" ? {
+  filter?: Pick<HookFilter, "id"> | TopLevelFilterExpression[];
+} : K extends "resolveId" ? {
+  filter?: {
+    id?: GeneralHookFilter<RegExp>;
+  } | TopLevelFilterExpression[];
+} : K extends "renderChunk" ? {
+  filter?: Pick<HookFilter, "code"> | TopLevelFilterExpression[];
+} : {};
+type PluginHooks = { [K in keyof FunctionPluginHooks]: ObjectHook<K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K], HookFilterExtension<K> & (K extends ParallelPluginHooks ? {
+  /**
+  * @deprecated
+  * this is only for rollup Plugin type compatibility.
+  * hooks always work as `sequential: true`.
+  */
+  sequential?: boolean;
+} : {})> };
+type AddonHookFunction = (this: PluginContext, chunk: RenderedChunk) => string | Promise<string>;
+type AddonHook = string | AddonHookFunction;
+interface OutputPlugin extends Partial<{ [K in keyof PluginHooks as K & OutputPluginHooks]: PluginHooks[K] }>, Partial<{ [K in keyof AddonHooks]: ObjectHook<AddonHook> }> {
+  /** The name of the plugin, for use in error messages and logs. */
+  name: string;
+  /** The version of the plugin, for use in inter-plugin communication scenarios. */
+  version?: string;
+}
+/**
+* The Plugin interface.
+*
+* See [Plugin API document](https://rolldown.rs/apis/plugin-api) for details.
+*
+* @typeParam A - The type of the {@link Plugin.api | api} property.
+*
+* @category Plugin APIs
+*/
+interface Plugin<A = any> extends OutputPlugin, Partial<PluginHooks> {
+  /**
+  * Used for inter-plugin communication.
+  */
+  api?: A;
+}
+type RolldownPlugin<A = any> = Plugin<A> | BuiltinPlugin | ParallelPlugin;
+type RolldownPluginOption<A = any> = MaybePromise<NullValue<RolldownPlugin<A>> | {
+  name: string;
+} | false | RolldownPluginOption[]>;
+type RolldownOutputPlugin = OutputPlugin | BuiltinPlugin;
+type RolldownOutputPluginOption = MaybePromise<NullValue<RolldownOutputPlugin> | {
+  name: string;
+} | false | RolldownOutputPluginOption[]>;
+//#endregion
+//#region src/options/input-options.d.ts
+/**
+* @inline
+*/
+type InputOption = string | string[] | Record<string, string>;
+/**
+* @param id The id of the module being checked.
+* @param parentId The id of the module importing the id being checked.
+* @param isResolved Whether the id has been resolved.
+* @returns Whether the module should be treated as external.
+*/
+type ExternalOptionFunction = (id: string, parentId: string | undefined, isResolved: boolean) => NullValue<boolean>;
+/** @inline */
+type ExternalOption = StringOrRegExp | StringOrRegExp[] | ExternalOptionFunction;
+interface ChunkOptimizationOptions {
+  /**
+  * Merge common chunks into existing entry chunks when it is safe.
+  *
+  * This can reduce the number of emitted chunks by moving shared/common modules
+  * into an entry chunk that already depends on them. Rolldown only applies the
+  * merge when it does not create a circular chunk dependency or change strict
+  * entry export signatures. This pass also covers safe empty-facade cleanup.
+  *
+  * @default true
+  */
+  mergeCommonChunks?: boolean;
+  /**
+  * Avoid emitting redundant chunk loads for dynamic entries.
+  *
+  * This pass can reduce dynamic-entry dependent chunks when the shared modules
+  * are guaranteed to be loaded by every importer of that dynamic entry.
+  *
+  * @default true
+  */
+  avoidRedundantChunkLoads?: boolean;
+}
+type ModuleTypes = Record<string, "js" | "jsx" | "ts" | "tsx" | "json" | "text" | "base64" | "dataurl" | "binary" | "empty" | "css" | "asset" | "copy">;
+interface WatcherFileWatcherOptions {
+  /**
+  * Whether to use polling-based file watching instead of native OS events.
+  *
+  * Polling is useful for environments where native FS events are unreliable,
+  * such as network mounts, Docker volumes, or WSL2.
+  *
+  * @default false
+  */
+  usePolling?: boolean;
+  /**
+  * Interval between each poll in milliseconds.
+  *
+  * This option is only used when {@linkcode usePolling} is `true`.
+  *
+  * @default 100
+  */
+  pollInterval?: number;
+  /**
+  * Whether to compare file contents for poll-based watchers.
+  * When enabled, poll watchers will check file contents to determine if they actually changed.
+  *
+  * This option is only used when {@linkcode usePolling} is `true`.
+  *
+  * @default false
+  */
+  compareContentsForPolling?: boolean;
+  /**
+  * Whether to use debounced event delivery at the filesystem level.
+  * This coalesces rapid filesystem events before they reach the build coordinator.
+  * @default false
+  */
+  useDebounce?: boolean;
+  /**
+  * Debounce delay in milliseconds for fs-level debounced watchers.
+  * Only used when {@linkcode useDebounce} is `true`.
+  * @default 10
+  */
+  debounceDelay?: number;
+  /**
+  * Tick rate in milliseconds for the debouncer's internal polling.
+  * Only used when {@linkcode useDebounce} is `true`.
+  * When undefined, auto-selects 1/4 of debounceDelay.
+  */
+  debounceTickRate?: number;
+}
+interface WatcherOptions {
+  /**
+  * Whether to skip the {@linkcode RolldownBuild.write | bundle.write()} step when a rebuild is triggered.
+  * @default false
+  */
+  skipWrite?: boolean;
+  /**
+  * Configures how long Rolldown will wait for further changes until it triggers
+  * a rebuild in milliseconds.
+  *
+  * Even if this value is set to 0, there's a small debounce timeout configured
+  * in the file system watcher. Setting this to a value greater than 0 will mean
+  * that Rolldown will only trigger a rebuild if there was no change for the
+  * configured number of milliseconds. If several configurations are watched,
+  * Rolldown will use the largest configured build delay.
+  *
+  * This option is useful if you use a tool that regenerates multiple source files
+  * very slowly. Rebuilding immediately after the first change could cause Rolldown
+  * to generate a broken intermediate build before generating a successful final
+  * build, which can be confusing and distracting.
+  *
+  * @default 0
+  */
+  buildDelay?: number;
+  /**
+  * File watcher options for configuring how file changes are detected.
+  */
+  watcher?: WatcherFileWatcherOptions;
+  /**
+  * @deprecated Use {@linkcode watcher} instead.
+  */
+  notify?: WatcherFileWatcherOptions;
+  /**
+  * Filter to limit the file-watching to certain files.
+  *
+  * Strings are treated as glob patterns.
+  * Note that this only filters the module graph but does not allow adding
+  * additional watch files.
+  *
+  * @example
+  * ```js
+  * export default defineConfig({
+  *   watch: {
+  *     include: 'src/**',
+  *   },
+  * })
+  * ```
+  * @default []
+  */
+  include?: StringOrRegExp | StringOrRegExp[];
+  /**
+  * Filter to prevent files from being watched.
+  *
+  * Strings are treated as glob patterns.
+  *
+  * @example
+  * ```js
+  * export default defineConfig({
+  *   watch: {
+  *     exclude: 'node_modules/**',
+  *   },
+  * })
+  * ```
+  * @default []
+  */
+  exclude?: StringOrRegExp | StringOrRegExp[];
+  /**
+  * An optional function that will be called immediately every time
+  * a module changes that is part of the build.
+  *
+  * This is different from the {@linkcode Plugin.watchChange | watchChange} plugin hook, which is
+  * only called once the running build has finished. This may for
+  * instance be used to prevent additional steps from being performed
+  * if we know another build will be started anyway once the current
+  * build finished. This callback may be called multiple times per
+  * build as it tracks every change.
+  *
+  * @param id The id of the changed module.
+  */
+  onInvalidate?: (id: string) => void;
+  /**
+  * Whether to clear the screen when a rebuild is triggered.
+  * @default true
+  */
+  clearScreen?: boolean;
+}
+/** @inline */
+type MakeAbsoluteExternalsRelative = boolean | "ifRelativeSource";
+type DevModeOptions = boolean | {
+  host?: string;
+  port?: number;
+  implement?: string;
+  lazy?: boolean;
+};
+type OptimizationOptions = {
+  /**
+  * Inline imported constant values during bundling instead of preserving variable references.
+  *
+  * When enabled, constant values from imported modules will be inlined at their usage sites,
+  * potentially reducing bundle size and improving runtime performance by eliminating variable lookups.
+  *
+  * **Options:**
+  * - `true`: equivalent to `{ mode: 'all', pass: 1 }`, enabling constant inlining for all eligible constants with a single pass.
+  * - `false`: Disable constant inlining
+  * - `{ mode: 'smart' | 'all', pass?: number }`:
+  *   - `mode: 'smart'`: Only inline constants in specific scenarios where it is likely to reduce bundle size and improve performance.
+  *     Smart mode inlines constants in these specific scenarios:
+  *     1. `if (test) {} else {}` - condition expressions in if statements
+  *     2. `test ? a : b` - condition expressions in ternary operators
+  *     3. `test1 || test2` - logical OR expressions
+  *     4. `test1 && test2` - logical AND expressions
+  *     5. `test1 ?? test2` - nullish coalescing expressions
+  *  - `mode: 'all'`: Inline all imported constants wherever they are used.
+  *  - `pass`: Number of passes to perform for inlining constants.
+  *
+  * @example
+  * ```js
+  * // Input files:
+  * // constants.js
+  * export const API_URL = 'https://api.example.com';
+  *
+  * // main.js
+  * import { API_URL } from './constants.js';
+  * console.log(API_URL);
+  *
+  * // With inlineConst: true, the bundled output becomes:
+  * console.log('https://api.example.com');
+  *
+  * // Instead of:
+  * const API_URL = 'https://api.example.com';
+  * console.log(API_URL);
+  * ```
+  *
+  * @default { mode: 'smart', pass: 1 }
+  */
+  inlineConst?: boolean | {
+    mode?: "all" | "smart";
+    pass?: number;
+  };
+  /**
+  * Use PIFE pattern for module wrappers.
+  *
+  * Enabling this option improves the start up performance of the generated bundle with the cost of a slight increase in bundle size.
+  *
+  *
+  *
+  * @default true
+  */
+  pifeForModuleWrappers?: boolean;
+};
+/** @inline */
+type AttachDebugOptions = "none" | "simple" | "full";
+/** @inline */
+type ChunkModulesOrder = "exec-order" | "module-id";
+/** @inline */
+type OnLogFunction = (level: LogLevel, log: RolldownLog, defaultHandler: LogOrStringHandler) => void;
+/** @inline */
+type OnwarnFunction = (warning: RolldownLog, defaultHandler: (warning: RolldownLogWithString | (() => RolldownLogWithString)) => void) => void;
+interface InputOptions {
+  /**
+  * Defines entries and location(s) of entry modules for the bundle. Relative paths are resolved based on the {@linkcode cwd} option.
+  *
+  */
+  input?: InputOption;
+  /**
+  * The list of plugins to use.
+  *
+  * Falsy plugins will be ignored, which can be used to easily activate or deactivate plugins. Nested plugins will be flattened. Async plugins will be awaited and resolved.
+  *
+  * See [Plugin API document](https://rolldown.rs/apis/plugin-api) for more details about creating plugins.
+  *
+  * @example
+  * ```js
+  * import { defineConfig } from 'rolldown'
+  *
+  * export default defineConfig({
+  *   plugins: [
+  *     examplePlugin1(),
+  *     // Conditional plugins
+  *     process.env.ENV1 && examplePlugin2(),
+  *     // Nested plugins arrays are flattened
+  *     [examplePlugin3(), examplePlugin4()],
+  *   ]
+  * })
+  * ```
+  */
+  plugins?: RolldownPluginOption;
+  /**
+  * Specifies which modules should be treated as external and not bundled. External modules will be left as import statements in the output.
+  *
+  */
+  external?: ExternalOption;
+  /**
+  * Options for built-in module resolution feature.
+  */
+  resolve?: {
+    /**
+    * Substitute one package for another.
+    *
+    * One use case for this feature is replacing a node-only package with a browser-friendly package in third-party code that you don't control.
+    *
+    * @example
+    * ```js
+    * resolve: {
+    *   alias: {
+    *     '@': '/src',
+    *     'utils': './src/utils',
+    *   }
+    * }
+    * ```
+    * > [!WARNING]
+    * > `resolve.alias` will not call [`resolveId`](/reference/Interface.Plugin#resolveid) hooks of other plugin.
+    * > If you want to call `resolveId` hooks of other plugin, use `viteAliasPlugin` from `rolldown/experimental` instead.
+    * > You could find more discussion in [this issue](https://github.com/rolldown/rolldown/issues/3615)
+    */
+    alias?: Record<string, string[] | string | false>;
+    /**
+    * Fields in package.json to check for aliased paths.
+    *
+    * This option is expected to be used for `browser` field support.
+    *
+    * @default
+    * - `[['browser']]` for `browser` platform
+    * - `[]` for other platforms
+    */
+    aliasFields?: string[][];
+    /**
+    * Condition names to use when resolving exports in package.json.
+    *
+    * @default
+    * Defaults based on platform and import kind:
+    * - `browser` platform
+    *   - `["import", "browser", "default"]` for import statements
+    *   - `["require", "browser", "default"]` for require() calls
+    * - `node` platform
+    *   - `["import", "node", "default"]` for import statements
+    *   - `["require", "node", "default"]` for require() calls
+    * - `neutral` platform
+    *   - `["import", "default"]` for import statements
+    *   - `["require", "default"]` for require() calls
+    */
+    conditionNames?: string[];
+    /**
+    * Map of extensions to alternative extensions.
+    *
+    * With writing `import './foo.js'` in a file, you want to resolve it to `foo.ts` instead of `foo.js`.
+    * You can achieve this by setting: `extensionAlias: { '.js': ['.ts', '.js'] }`.
+    */
+    extensionAlias?: Record<string, string[]>;
+    /**
+    * Fields in package.json to check for exports.
+    *
+    * @default `[['exports']]`
+    */
+    exportsFields?: string[][];
+    /**
+    * Extensions to try when resolving files. These are tried in order from first to last.
+    *
+    * @default `['.tsx', '.ts', '.jsx', '.js', '.json']`
+    */
+    extensions?: string[];
+    /**
+    * Fields in package.json to check for entry points.
+    *
+    * @default
+    * Defaults based on platform:
+    * - `node` platform: `['main', 'module']`
+    * - `browser` platform: `['browser', 'module', 'main']`
+    * - `neutral` platform: `[]`
+    */
+    mainFields?: string[];
+    /**
+    * Filenames to try when resolving directories.
+    * @default ['index']
+    */
+    mainFiles?: string[];
+    /**
+    * Directories to search for modules.
+    * @default ['node_modules']
+    */
+    modules?: string[];
+    /**
+    * Whether to follow symlinks when resolving modules.
+    * @default true
+    */
+    symlinks?: boolean;
+    /**
+    * @deprecated Use the top-level {@linkcode tsconfig} option instead.
+    */
+    tsconfigFilename?: string;
+  };
+  /**
+  * The working directory to use when resolving relative paths in the configuration.
+  * @default process.cwd()
+  */
+  cwd?: string;
+  /**
+  * Expected platform where the code run.
+  *
+  *  When the platform is set to neutral:
+  *    - When bundling is enabled the default output format is set to esm, which uses the export syntax introduced with ECMAScript 2015 (i.e. ES6). You can change the output format if this default is not appropriate.
+  *    - The main fields setting is empty by default. If you want to use npm-style packages, you will likely have to configure this to be something else such as main for the standard main field used by node.
+  *    - The conditions setting does not automatically include any platform-specific values.
+  *
+  * @default
+  * - `'node'` if the format is `'cjs'`
+  * - `'browser'` for other formats
+  *
+  */
+  platform?: "node" | "browser" | "neutral";
+  /**
+  * When `true`, creates shim variables for missing exports instead of throwing an error.
+  * @default false
+  *
+  */
+  shimMissingExports?: boolean;
+  /**
+  * Controls tree-shaking (dead code elimination).
+  *
+  * See the [In-depth Dead Code Elimination Guide](https://rolldown.rs/in-depth/dead-code-elimination) for more details.
+  *
+  * When `false`, tree-shaking will be disabled.
+  * When `true`, it is equivalent to setting each options to the default value.
+  *
+  * @default true
+  */
+  treeshake?: boolean | TreeshakingOptions;
+  /**
+  * Controls the verbosity of console logging during the build.
+  *
+  *
+  *
+  * @default 'info'
+  */
+  logLevel?: LogLevelOption;
+  /**
+  * A function that intercepts log messages. If not supplied, logs are printed to the console.
+  *
+  *
+  *
+  * @example
+  * ```js
+  * export default defineConfig({
+  *   onLog(level, log, defaultHandler) {
+  *     if (log.code === 'CIRCULAR_DEPENDENCY') {
+  *       return; // Ignore circular dependency warnings
+  *     }
+  *     if (level === 'warn') {
+  *       defaultHandler('error', log); // turn other warnings into errors
+  *     } else {
+  *       defaultHandler(level, log); // otherwise, just print the log
+  *     }
+  *   }
+  * })
+  * ```
+  */
+  onLog?: OnLogFunction;
+  /**
+  * A function that will intercept warning messages.
+  *
+  *
+  *
+  * @deprecated
+  * This is a legacy API. Consider using {@linkcode onLog} instead for better control over all log types.
+  *
+  *
+  */
+  onwarn?: OnwarnFunction;
+  /**
+  * Maps file patterns to module types, controlling how files are processed.
+  *
+  * This is conceptually similar to [esbuild's `loader`](https://esbuild.github.io/api/#loader) option, allowing you to specify how each file extensions should be handled.
+  *
+  * See [the In-Depth Guide](https://rolldown.rs/in-depth/module-types) for more details.
+  *
+  * @example
+  * ```js
+  * import { defineConfig } from 'rolldown'
+  *
+  * export default defineConfig({
+  *   moduleTypes: {
+  *     '.frag': 'text',
+  *   }
+  * })
+  * ```
+  */
+  moduleTypes?: ModuleTypes;
+  /**
+  * Experimental features that may change in future releases and can introduce behavior change without a major version bump.
+  * @experimental
+  */
+  experimental?: {
+    /**
+    * Enable Vite compatible mode.
+    * @default false
+    * @hidden This option is only meant to be used by Vite. It is not recommended to use this option directly.
+    */
+    viteMode?: boolean;
+    /**
+    * When enabled, `new URL()` calls will be transformed to a stable asset URL which includes the updated name and content hash.
+    * It is necessary to pass `import.meta.url` as the second argument to the
+    * `new URL` constructor, otherwise no transform will be applied.
+    * :::warning
+    * JavaScript and TypeScript files referenced via `new URL('./file.js', import.meta.url)` or `new URL('./file.ts', import.meta.url)` will **not** be transformed or bundled. The file will be copied as-is, meaning TypeScript files remain untransformed and dependencies are not resolved.
+    *
+    * The expected behavior for JS/TS files is still being discussed and may
+    * change in future releases. See [#7258](https://github.com/rolldown/rolldown/issues/7258) for more context.
+    * :::
+    * @example
+    * ```js
+    * // main.js
+    * const url = new URL('./styles.css', import.meta.url);
+    * console.log(url);
+    *
+    * // Example output after bundling WITHOUT the option (default)
+    * const url = new URL('./styles.css', import.meta.url);
+    * console.log(url);
+    *
+    * // Example output after bundling WITH `experimental.resolveNewUrlToAsset` set to `true`
+    * const url = new URL('assets/styles-CjdrdY7X.css', import.meta.url);
+    * console.log(url);
+    * ```
+    * @default false
+    */
+    resolveNewUrlToAsset?: boolean;
+    /**
+    * Dev mode related options.
+    * @hidden not ready for public usage yet
+    */
+    devMode?: DevModeOptions;
+    /**
+    * Control which order should be used when rendering modules in a chunk.
+    *
+    * Available options:
+    * - `exec-order`: Almost equivalent to the topological order of the module graph, but specially handling when module graph has cycle.
+    * - `module-id`: This is more friendly for gzip compression, especially for some javascript static asset lib (e.g. icon library)
+    *
+    * > [!NOTE]
+    * > Try to sort the modules by their module id if possible (Since rolldown scope hoist all modules in the chunk, we only try to sort those modules by module id if we could ensure runtime behavior is correct after sorting).
+    *
+    * @default 'exec-order'
+    */
+    chunkModulesOrder?: ChunkModulesOrder;
+    /**
+    * Attach debug information to the output bundle.
+    *
+    * Available modes:
+    * - `none`: No debug information is attached.
+    * - `simple`: Attach comments indicating which files the bundled code comes from. These comments could be removed by the minifier.
+    * - `full`: Attach detailed debug information to the output bundle. These comments are using legal comment syntax, so they won't be removed by the minifier.
+    *
+    * @default 'simple'
+    *
+    *
+    */
+    attachDebugInfo?: AttachDebugOptions;
+    /**
+    * Enables automatic generation of a chunk import map asset during build.
+    *
+    * This map only includes chunks with hashed filenames, where keys are derived from the facade module
+    * name or primary chunk name. It produces stable and unique hash-based filenames, effectively preventing
+    * cascading cache invalidation caused by content hashes and maximizing browser cache reuse.
+    *
+    * The output defaults to `importmap.json` unless overridden via `fileName`. A base URL prefix
+    * (default `"/"`) can be applied to all paths. The resulting JSON is a valid import map and can be
+    * directly injected into HTML via `<script type="importmap">`.
+    *
+    * @example
+    * ```js
+    * {
+    *   experimental: {
+    *     chunkImportMap: {
+    *       baseUrl: '/',
+    *       fileName: 'importmap.json'
+    *     }
+    *   },
+    *   plugins: [
+    *     {
+    *       name: 'inject-import-map',
+    *       generateBundle(_, bundle) {
+    *         const chunkImportMap = bundle['importmap.json'];
+    *         if (chunkImportMap?.type === 'asset') {
+    *           const htmlPath = path.resolve('index.html');
+    *           let html = fs.readFileSync(htmlPath, 'utf-8');
+    *
+    *           html = html.replace(
+    *             /<script\s+type="importmap"[^>]*>[\s\S]*?<\/script>/i,
+    *             `<script type="importmap">${chunkImportMap.source}<\/script>`
+    *           );
+    *
+    *           fs.writeFileSync(htmlPath, html);
+    *           delete bundle['importmap.json'];
+    *         }
+    *       }
+    *     }
+    *   ]
+    * }
+    * ```
+    *
+    * > [!TIP]
+    * > If you want to learn more, you can check out the example here: [examples/chunk-import-map](https://github.com/rolldown/rolldown/tree/main/examples/chunk-import-map)
+    *
+    * @default false
+    */
+    chunkImportMap?: boolean | {
+      baseUrl?: string;
+      fileName?: string;
+    };
+    /**
+    * Enable on-demand wrapping of modules.
+    * @default false
+    * @hidden not ready for public usage yet
+    */
+    onDemandWrapping?: boolean;
+    /**
+    * Enable incremental build support. Required to be used with `watch` mode.
+    * @default false
+    */
+    incrementalBuild?: boolean;
+    /**
+    * Use native Rust implementation of MagicString for source map generation.
+    *
+    * [MagicString](https://github.com/rich-harris/magic-string) is a JavaScript library commonly used by bundlers
+    * for string manipulation and source map generation. When enabled, rolldown will use a native Rust
+    * implementation of MagicString instead of the JavaScript version, providing significantly better performance
+    * during source map generation and code transformation.
+    *
+    * **Benefits**
+    *
+    * - **Improved Performance**: The native Rust implementation is typically faster than the JavaScript version,
+    *   especially for large codebases with extensive source maps.
+    * - **Background Processing**: Source map generation is performed asynchronously in a background thread,
+    *   allowing the main bundling process to continue without blocking. This parallel processing can significantly
+    *   reduce overall build times when working with JavaScript transform hooks.
+    * - **Better Integration**: Seamless integration with rolldown's native Rust architecture.
+    *
+    * @example
+    * ```js
+    * export default {
+    *   experimental: {
+    *     nativeMagicString: true
+    *   },
+    *   output: {
+    *     sourcemap: true
+    *   }
+    * }
+    * ```
+    *
+    * > [!NOTE]
+    * > This is an experimental feature. While it aims to provide identical behavior to the JavaScript
+    * > implementation, there may be edge cases. Please report any discrepancies you encounter.
+    * > For a complete working example, see [examples/native-magic-string](https://github.com/rolldown/rolldown/tree/main/examples/native-magic-string)
+    * @default false
+    */
+    nativeMagicString?: boolean;
+    /**
+    * Control chunk optimizations.
+    *
+    * `true` enables both common-chunk merging and redundant dynamic chunk-load avoidance.
+    * `false` disables all chunk optimizations. Use the object form to control
+    * `mergeCommonChunks` and `avoidRedundantChunkLoads` separately.
+    *
+    * These optimizations are automatically disabled when any module uses top-level await (TLA) or contains TLA dependencies,
+    * as they could affect execution order guarantees.
+    *
+    * @default true
+    */
+    chunkOptimization?: boolean | ChunkOptimizationOptions;
+    /**
+    * Control whether to enable lazy barrel optimization.
+    *
+    * Lazy barrel optimization avoids compiling unused re-export modules in side-effect-free barrel modules,
+    * significantly improving build performance for large codebases with many barrel modules.
+    *
+    * @see {@link https://rolldown.rs/in-depth/lazy-barrel-optimization | Lazy Barrel Documentation}
+    * @default false
+    */
+    lazyBarrel?: boolean;
+  };
+  /**
+  * Configure how the code is transformed. This process happens after the `transform` hook.
+  *
+  * @example
+  * **Enable legacy decorators**
+  * ```js
+  * export default defineConfig({
+  *   transform: {
+  *     decorator: {
+  *       legacy: true,
+  *     },
+  *   },
+  * })
+  * ```
+  * Note that if you have correct `tsconfig.json` file, Rolldown will automatically detect and enable legacy decorators support.
+  *
+  *
+  */
+  transform?: TransformOptions;
+  /**
+  * Watch mode related options.
+  *
+  * These options only take effect when running with the [`--watch`](/apis/cli#w-watch) flag, or using {@linkcode watch | watch()} API.
+  *
+  *
+  *
+  * @experimental
+  */
+  watch?: WatcherOptions | false;
+  /**
+  * Controls which warnings are emitted during the build process. Each option can be set to `true` (emit warning) or `false` (suppress warning).
+  */
+  checks?: ChecksOptions;
+  /**
+  * Determines if absolute external paths should be converted to relative paths in the output.
+  *
+  * This does not only apply to paths that are absolute in the source but also to paths that are resolved to an absolute path by either a plugin or Rolldown core.
+  *
+  *
+  */
+  makeAbsoluteExternalsRelative?: MakeAbsoluteExternalsRelative;
+  /**
+  * Devtools integration options.
+  * @experimental
+  */
+  devtools?: {
+    sessionId?: string;
+  };
+  /**
+  * Controls how entry chunk exports are preserved.
+  *
+  * This determines whether Rolldown needs to create facade chunks (additional wrapper chunks) to maintain the exact export signatures of entry modules, or whether it can combine entry modules with other chunks for optimization.
+  *
+  * @default `'exports-only'`
+  *
+  */
+  preserveEntrySignatures?: false | "strict" | "allow-extension" | "exports-only";
+  /**
+  * Configure optimization features for the bundler.
+  */
+  optimization?: OptimizationOptions;
+  /**
+  * The value of `this` at the top level of each module. **Normally, you don't need to set this option.**
+  * @default undefined
+  * @example
+  * **Set custom context**
+  * ```js
+  * export default {
+  *   context: 'globalThis',
+  *   output: {
+  *     format: 'iife',
+  *   },
+  * };
+  * ```
+  *
+  */
+  context?: string;
+  /**
+  * Configures TypeScript configuration file resolution and usage.
+  *
+  * @default true
+  */
+  tsconfig?: boolean | string;
+}
+//#endregion
+//#region src/types/rolldown-options.d.ts
+interface RolldownOptions extends InputOptions {
+  output?: OutputOptions | OutputOptions[];
+}
+//#endregion
+//#region src/utils/define-config.d.ts
+/**
+* Type for `default export` of `rolldown.config.js` file.
+* @category Config
+*/
+type ConfigExport = RolldownOptions | RolldownOptions[] | RolldownOptionsFunction;
+/** @category Config */
+type RolldownOptionsFunction = (commandLineArguments: Record<string, any>) => MaybePromise<RolldownOptions | RolldownOptions[]>;
+/**
+* A helper to define a rolldown configuration with type hints.
+*
+* @example
+* ```js [rolldown.config.js]
+* import { defineConfig } from 'rolldown';
+*
+* export default defineConfig({
+*   input: 'src/main.js',
+*   output: {
+*     file: 'bundle.js',
+*   },
+* });
+* ```
+*
+* @category Config
+*/
+declare function defineConfig(config: RolldownOptions): RolldownOptions;
+declare function defineConfig(config: RolldownOptions[]): RolldownOptions[];
+declare function defineConfig(config: RolldownOptionsFunction): RolldownOptionsFunction;
+declare function defineConfig(config: ConfigExport): ConfigExport;
+//#endregion
+export { PluginContextMeta as $, RolldownPluginOption as A, CodeSplittingGroup as At, OutputBundle as B, PreRenderedAsset as Bt, ParallelPluginHooks as C, build as Ct, ResolveIdResult as D, BuiltinModuleTag as Dt, ResolveIdExtraOptions as E, AdvancedChunksOptions as Et, RUNTIME_MODULE_ID as F, GeneratedCodePreset as Ft, EmittedFile as G, OutputChunk as Gt, TransformPluginContext as H, PartialNull as Ht, VERSION as I, GlobalsFunction as It, PluginContext as J, RolldownOutput as Jt, EmittedPrebuiltChunk as K, RenderedChunk as Kt, BundleError as L, MinifyOptions as Lt, TransformResult as M, CodeSplittingOptions as Mt, withFilter as N, CommentsOptions as Nt, ResolvedId as O, ChunkFileNamesFunction as Ot, BuiltinPlugin as P, GeneratedCodeOptions as Pt, MinimalPluginContext as Q, SourcemapIgnoreListOption as Qt, ExistingRawSourceMap as R, ModuleFormat as Rt, ObjectHook as S, BuildOptions as St, Plugin as T, AdvancedChunksGroup as Tt, EmittedAsset as U, StringOrRegExp as Ut, TreeshakingOptions as V, MaybePromise as Vt, EmittedChunk as W, OutputAsset as Wt, DefineParallelPluginResult as X, freeExternalMemory as Xt, PluginContextResolveOptions as Y, SourceMap as Yt, defineParallelPlugin as Z, ModuleInfo as Zt, HookFilterExtension as _, RolldownWatcherEvent as _t, ChunkOptimizationOptions as a, RolldownFileStats as at, ModuleOptions as b, rolldown as bt, InputOption as c, NormalizedOutputOptions as ct, OptimizationOptions as d, ChecksOptions as dt, GeneralHookFilter as et, WatcherFileWatcherOptions as f, LoggingFunction as ft, FunctionPluginHooks as g, RolldownWatcher as gt, CustomPluginOptions as h, watch as ht, RolldownOptions as i, RolldownDirectoryEntry as it, SourceDescription as j, CodeSplittingNameFunction as jt, RolldownPlugin as k, ChunkingContext as kt, InputOptions as l, NormalizedInputOptions as lt, AsyncPluginHooks as m, RolldownMagicString as mt, RolldownOptionsFunction as n, ModuleTypeFilter as nt, ExternalOption as o, RolldownFsModule as ot, WatcherOptions as p, WarningHandlerWithDefault as pt, GetModuleInfo as q, RenderedModule as qt, defineConfig as r, BufferEncoding as rt, ExternalOptionFunction as s, InternalModuleFormat as st, ConfigExport as t, HookFilter as tt, ModuleTypes as u, TransformOptions as ut, ImportKind as v, RolldownWatcherWatcherEventMap as vt, PartialResolvedId as w, AddonFunction as wt, ModuleType as x, RolldownBuild as xt, LoadResult as y, WatchOptions as yt, SourceMapInput as z, OutputOptions as zt };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/define-config-DJOr6Iwt.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/define-config-DJOr6Iwt.mjs
new file mode 100644
index 0000000..902af91
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/define-config-DJOr6Iwt.mjs
@@ -0,0 +1,6 @@
+//#region src/utils/define-config.ts
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+export { defineConfig as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/error-CkdMJ9ps.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/error-CkdMJ9ps.mjs
new file mode 100644
index 0000000..c0be385
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/error-CkdMJ9ps.mjs
@@ -0,0 +1,85 @@
+import { t as require_binding } from "./binding-C9S351wt.mjs";
+//#region src/types/sourcemap.ts
+function bindingifySourcemap(map) {
+	if (map == null) return;
+	return { inner: typeof map === "string" ? map : {
+		file: map.file ?? void 0,
+		mappings: map.mappings,
+		sourceRoot: "sourceRoot" in map ? map.sourceRoot ?? void 0 : void 0,
+		sources: map.sources?.map((s) => s ?? void 0),
+		sourcesContent: map.sourcesContent?.map((s) => s ?? void 0),
+		names: map.names,
+		x_google_ignoreList: map.x_google_ignoreList,
+		debugId: "debugId" in map ? map.debugId : void 0
+	} };
+}
+require_binding();
+function unwrapBindingResult(container) {
+	if (typeof container === "object" && container !== null && "isBindingErrors" in container && container.isBindingErrors) throw aggregateBindingErrorsIntoJsError(container.errors);
+	return container;
+}
+function normalizeBindingResult(container) {
+	if (typeof container === "object" && container !== null && "isBindingErrors" in container && container.isBindingErrors) return aggregateBindingErrorsIntoJsError(container.errors);
+	return container;
+}
+function normalizeBindingError(e) {
+	return e.type === "JsError" ? e.field0 : Object.assign(/* @__PURE__ */ new Error(), {
+		code: e.field0.kind,
+		kind: e.field0.kind,
+		message: e.field0.message,
+		id: e.field0.id,
+		exporter: e.field0.exporter,
+		loc: e.field0.loc,
+		pos: e.field0.pos,
+		stack: void 0
+	});
+}
+function aggregateBindingErrorsIntoJsError(rawErrors) {
+	const errors = rawErrors.map(normalizeBindingError);
+	let summary = `Build failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
+	for (let i = 0; i < errors.length; i++) {
+		summary += "\n";
+		if (i >= 5) {
+			summary += "...";
+			break;
+		}
+		summary += getErrorMessage(errors[i]);
+	}
+	const wrapper = new Error(summary);
+	Object.defineProperty(wrapper, "errors", {
+		configurable: true,
+		enumerable: true,
+		get: () => errors,
+		set: (value) => Object.defineProperty(wrapper, "errors", {
+			configurable: true,
+			enumerable: true,
+			value
+		})
+	});
+	return wrapper;
+}
+function getErrorMessage(e) {
+	if (Object.hasOwn(e, "kind")) return e.message;
+	let s = "";
+	if (e.plugin) s += `[plugin ${e.plugin}]`;
+	const id = e.id ?? e.loc?.file;
+	if (id) {
+		s += " " + id;
+		if (e.loc) s += `:${e.loc.line}:${e.loc.column}`;
+	}
+	if (s) s += "\n";
+	const message = `${e.name ?? "Error"}: ${e.message}`;
+	s += message;
+	if (e.frame) s = joinNewLine(s, e.frame);
+	if (e.stack) s = joinNewLine(s, e.stack.replace(message, ""));
+	if (e.cause) {
+		s = joinNewLine(s, "Caused by:");
+		s = joinNewLine(s, getErrorMessage(e.cause).split("\n").map((line) => "  " + line).join("\n"));
+	}
+	return s;
+}
+function joinNewLine(s1, s2) {
+	return s1.replace(/\n+$/, "") + "\n" + s2.replace(/^\n+/, "");
+}
+//#endregion
+export { bindingifySourcemap as a, unwrapBindingResult as i, normalizeBindingError as n, normalizeBindingResult as r, aggregateBindingErrorsIntoJsError as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/get-log-filter-semyr3Lj.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/get-log-filter-semyr3Lj.d.mts
new file mode 100644
index 0000000..a52e5af
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/get-log-filter-semyr3Lj.d.mts
@@ -0,0 +1,35 @@
+import { a as RolldownLog } from "./logging-C6h4g8dA.mjs";
+
+//#region src/get-log-filter.d.ts
+/**
+* @param filters A list of log filters to apply
+* @returns A function that tests whether a log should be output
+*
+* @category Config
+*/
+type GetLogFilter = (filters: string[]) => (log: RolldownLog) => boolean;
+/**
+* A helper function to generate log filters using the same syntax as the CLI.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'rolldown';
+* import { getLogFilter } from 'rolldown/getLogFilter';
+*
+* const logFilter = getLogFilter(['code:FOO', 'code:BAR']);
+*
+* export default defineConfig({
+* 	input: 'main.js',
+* 	onLog(level, log, handler) {
+* 		if (logFilter(log)) {
+* 			handler(level, log);
+* 		}
+* 	}
+* });
+* ```
+*
+* @category Config
+*/
+declare const getLogFilter: GetLogFilter;
+//#endregion
+export { getLogFilter as n, GetLogFilter as t };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/load-config-CYoi2Wo1.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/load-config-CYoi2Wo1.mjs
new file mode 100644
index 0000000..2f4147a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/load-config-CYoi2Wo1.mjs
@@ -0,0 +1,120 @@
+import { t as rolldown } from "./rolldown-CWsV1rrO.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { readdir } from "node:fs/promises";
+import { cwd } from "node:process";
+import { pathToFileURL } from "node:url";
+//#region src/utils/load-config.ts
+async function bundleTsConfig(configFile, isEsm) {
+	const dirnameVarName = "injected_original_dirname";
+	const filenameVarName = "injected_original_filename";
+	const importMetaUrlVarName = "injected_original_import_meta_url";
+	const bundle = await rolldown({
+		input: configFile,
+		platform: "node",
+		resolve: { mainFields: ["main"] },
+		transform: { define: {
+			__dirname: dirnameVarName,
+			__filename: filenameVarName,
+			"import.meta.url": importMetaUrlVarName,
+			"import.meta.dirname": dirnameVarName,
+			"import.meta.filename": filenameVarName
+		} },
+		treeshake: false,
+		external: [/^[\w@][^:]/],
+		plugins: [{
+			name: "inject-file-scope-variables",
+			transform: {
+				filter: { id: /\.[cm]?[jt]s$/ },
+				async handler(code, id) {
+					return {
+						code: `const ${dirnameVarName} = ${JSON.stringify(path.dirname(id))};const ${filenameVarName} = ${JSON.stringify(id)};const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(id).href)};` + code,
+						map: null
+					};
+				}
+			}
+		}]
+	});
+	const outputDir = path.dirname(configFile);
+	const fileName = (await bundle.write({
+		dir: outputDir,
+		format: isEsm ? "esm" : "cjs",
+		sourcemap: "inline",
+		entryFileNames: `rolldown.config.[hash]${path.extname(configFile).replace("ts", "js")}`
+	})).output.find((chunk) => chunk.type === "chunk" && chunk.isEntry).fileName;
+	return path.join(outputDir, fileName);
+}
+const SUPPORTED_JS_CONFIG_FORMATS = [
+	".js",
+	".mjs",
+	".cjs"
+];
+const SUPPORTED_TS_CONFIG_FORMATS = [
+	".ts",
+	".mts",
+	".cts"
+];
+const SUPPORTED_CONFIG_FORMATS = [...SUPPORTED_JS_CONFIG_FORMATS, ...SUPPORTED_TS_CONFIG_FORMATS];
+const DEFAULT_CONFIG_BASE = "rolldown.config";
+async function findConfigFileNameInCwd() {
+	const filesInWorkingDirectory = new Set(await readdir(cwd()));
+	for (const extension of SUPPORTED_CONFIG_FORMATS) {
+		const fileName = `${DEFAULT_CONFIG_BASE}${extension}`;
+		if (filesInWorkingDirectory.has(fileName)) return fileName;
+	}
+	throw new Error("No `rolldown.config` configuration file found.");
+}
+async function loadTsConfig(configFile) {
+	const file = await bundleTsConfig(configFile, isFilePathESM(configFile));
+	try {
+		return (await import(pathToFileURL(file).href)).default;
+	} finally {
+		fs.unlink(file, () => {});
+	}
+}
+function isFilePathESM(filePath) {
+	if (/\.m[jt]s$/.test(filePath)) return true;
+	else if (/\.c[jt]s$/.test(filePath)) return false;
+	else {
+		const pkg = findNearestPackageData(path.dirname(filePath));
+		if (pkg) return pkg.type === "module";
+		return false;
+	}
+}
+function findNearestPackageData(basedir) {
+	while (basedir) {
+		const pkgPath = path.join(basedir, "package.json");
+		if (tryStatSync(pkgPath)?.isFile()) try {
+			return JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+		} catch {}
+		const nextBasedir = path.dirname(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return null;
+}
+function tryStatSync(file) {
+	try {
+		return fs.statSync(file, { throwIfNoEntry: false });
+	} catch {}
+}
+/**
+* Load config from a file in a way that Rolldown does.
+*
+* @param configPath The path to the config file. If empty, it will look for `rolldown.config` with supported extensions in the current working directory.
+* @returns The loaded config export
+*
+* @category Config
+*/
+async function loadConfig(configPath) {
+	const ext = path.extname(configPath = configPath || await findConfigFileNameInCwd());
+	try {
+		if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext) || process.env.NODE_OPTIONS?.includes("--import=tsx") && SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) return (await import(pathToFileURL(configPath).href)).default;
+		else if (SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) return await loadTsConfig(path.resolve(configPath));
+		else throw new Error(`Unsupported config format. Expected: \`${SUPPORTED_CONFIG_FORMATS.join(",")}\` but got \`${ext}\``);
+	} catch (err) {
+		throw new Error("Error happened while loading config.", { cause: err });
+	}
+}
+//#endregion
+export { loadConfig as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/logging-C6h4g8dA.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/logging-C6h4g8dA.d.mts
new file mode 100644
index 0000000..2e7298e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/logging-C6h4g8dA.d.mts
@@ -0,0 +1,50 @@
+//#region src/log/logging.d.ts
+/** @inline */
+type LogLevel = "info" | "debug" | "warn";
+/** @inline */
+type LogLevelOption = LogLevel | "silent";
+/** @inline */
+type LogLevelWithError = LogLevel | "error";
+interface RolldownLog {
+  binding?: string;
+  cause?: unknown;
+  /**
+  * The log code for this log object.
+  * @example 'PLUGIN_ERROR'
+  */
+  code?: string;
+  exporter?: string;
+  frame?: string;
+  hook?: string;
+  id?: string;
+  ids?: string[];
+  loc?: {
+    column: number;
+    file?: string;
+    line: number;
+  };
+  /**
+  * The message for this log object.
+  * @example 'The "transform" hook used by the output plugin "rolldown-plugin-foo" is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.'
+  */
+  message: string;
+  meta?: any;
+  names?: string[];
+  plugin?: string;
+  pluginCode?: unknown;
+  pos?: number;
+  reexporter?: string;
+  stack?: string;
+  url?: string;
+}
+/** @inline */
+type RolldownLogWithString = RolldownLog | string;
+/** @category Plugin APIs */
+interface RolldownError extends RolldownLog {
+  name?: string;
+  stack?: string;
+  watchFiles?: string[];
+}
+type LogOrStringHandler = (level: LogLevelWithError, log: RolldownLogWithString) => void;
+//#endregion
+export { RolldownLog as a, RolldownError as i, LogLevelOption as n, RolldownLogWithString as o, LogOrStringHandler as r, LogLevel as t };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/logs-D80CXhvg.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/logs-D80CXhvg.mjs
new file mode 100644
index 0000000..5a620af
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/logs-D80CXhvg.mjs
@@ -0,0 +1,180 @@
+//#region src/utils/code-frame.ts
+function spaces(index) {
+	let result = "";
+	while (index--) result += " ";
+	return result;
+}
+function tabsToSpaces(value) {
+	return value.replace(/^\t+/, (match) => match.split("	").join("  "));
+}
+const LINE_TRUNCATE_LENGTH = 120;
+const MIN_CHARACTERS_SHOWN_AFTER_LOCATION = 10;
+const ELLIPSIS = "...";
+function getCodeFrame(source, line, column) {
+	let lines = source.split("\n");
+	if (line > lines.length) return "";
+	const maxLineLength = Math.max(tabsToSpaces(lines[line - 1].slice(0, column)).length + MIN_CHARACTERS_SHOWN_AFTER_LOCATION + 3, LINE_TRUNCATE_LENGTH);
+	const frameStart = Math.max(0, line - 3);
+	let frameEnd = Math.min(line + 2, lines.length);
+	lines = lines.slice(frameStart, frameEnd);
+	while (!/\S/.test(lines[lines.length - 1])) {
+		lines.pop();
+		frameEnd -= 1;
+	}
+	const digits = String(frameEnd).length;
+	return lines.map((sourceLine, index) => {
+		const isErrorLine = frameStart + index + 1 === line;
+		let lineNumber = String(index + frameStart + 1);
+		while (lineNumber.length < digits) lineNumber = ` ${lineNumber}`;
+		let displayedLine = tabsToSpaces(sourceLine);
+		if (displayedLine.length > maxLineLength) displayedLine = `${displayedLine.slice(0, maxLineLength - 3)}${ELLIPSIS}`;
+		if (isErrorLine) {
+			const indicator = spaces(digits + 2 + tabsToSpaces(sourceLine.slice(0, column)).length) + "^";
+			return `${lineNumber}: ${displayedLine}\n${indicator}`;
+		}
+		return `${lineNumber}: ${displayedLine}`;
+	}).join("\n");
+}
+//#endregion
+//#region src/log/locate-character/index.js
+/** @typedef {import('./types').Location} Location */
+/**
+* @param {import('./types').Range} range
+* @param {number} index
+*/
+function rangeContains(range, index) {
+	return range.start <= index && index < range.end;
+}
+/**
+* @param {string} source
+* @param {import('./types').Options} [options]
+*/
+function getLocator(source, options = {}) {
+	const { offsetLine = 0, offsetColumn = 0 } = options;
+	let start = 0;
+	const ranges = source.split("\n").map((line, i) => {
+		const end = start + line.length + 1;
+		/** @type {import('./types').Range} */
+		const range = {
+			start,
+			end,
+			line: i
+		};
+		start = end;
+		return range;
+	});
+	let i = 0;
+	/**
+	* @param {string | number} search
+	* @param {number} [index]
+	* @returns {Location | undefined}
+	*/
+	function locator(search, index) {
+		if (typeof search === "string") search = source.indexOf(search, index ?? 0);
+		if (search === -1) return void 0;
+		let range = ranges[i];
+		const d = search >= range.end ? 1 : -1;
+		while (range) {
+			if (rangeContains(range, search)) return {
+				line: offsetLine + range.line,
+				column: offsetColumn + search - range.start,
+				character: search
+			};
+			i += d;
+			range = ranges[i];
+		}
+	}
+	return locator;
+}
+/**
+* @param {string} source
+* @param {string | number} search
+* @param {import('./types').Options} [options]
+* @returns {Location | undefined}
+*/
+function locate(source, search, options) {
+	return getLocator(source, options)(search, options && options.startIndex);
+}
+//#endregion
+//#region src/log/logs.ts
+const INVALID_LOG_POSITION = "INVALID_LOG_POSITION", PLUGIN_ERROR = "PLUGIN_ERROR", INPUT_HOOK_IN_OUTPUT_PLUGIN = "INPUT_HOOK_IN_OUTPUT_PLUGIN", CYCLE_LOADING = "CYCLE_LOADING", MULTIPLE_WATCHER_OPTION = "MULTIPLE_WATCHER_OPTION", PARSE_ERROR = "PARSE_ERROR";
+function logParseError(message, id, pos) {
+	return {
+		code: PARSE_ERROR,
+		id,
+		message,
+		pos
+	};
+}
+function logInvalidLogPosition(pluginName) {
+	return {
+		code: INVALID_LOG_POSITION,
+		message: `Plugin "${pluginName}" tried to add a file position to a log or warning. This is only supported in the "transform" hook at the moment and will be ignored.`
+	};
+}
+function logInputHookInOutputPlugin(pluginName, hookName) {
+	return {
+		code: INPUT_HOOK_IN_OUTPUT_PLUGIN,
+		message: `The "${hookName}" hook used by the output plugin ${pluginName} is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.`
+	};
+}
+function logCycleLoading(pluginName, moduleId) {
+	return {
+		code: CYCLE_LOADING,
+		message: `Found the module "${moduleId}" cycle loading at ${pluginName} plugin, it maybe blocking fetching modules.`
+	};
+}
+function logMultipleWatcherOption() {
+	return {
+		code: MULTIPLE_WATCHER_OPTION,
+		message: `Found multiple watcher options at watch options, using first one to start watcher.`
+	};
+}
+function logPluginError(error, plugin, { hook, id } = {}) {
+	try {
+		const code = error.code;
+		if (!error.pluginCode && code != null && (typeof code !== "string" || !code.startsWith("PLUGIN_"))) error.pluginCode = code;
+		error.code = PLUGIN_ERROR;
+		error.plugin = plugin;
+		if (hook) error.hook = hook;
+		if (id) error.id = id;
+	} catch (_) {} finally {
+		return error;
+	}
+}
+function error(base) {
+	if (!(base instanceof Error)) {
+		base = Object.assign(new Error(base.message), base);
+		Object.defineProperty(base, "name", {
+			value: "RolldownError",
+			writable: true
+		});
+	}
+	throw base;
+}
+function augmentCodeLocation(properties, pos, source, id) {
+	if (typeof pos === "object") {
+		const { line, column } = pos;
+		properties.loc = {
+			column,
+			file: id,
+			line
+		};
+	} else {
+		properties.pos = pos;
+		const location = locate(source, pos, { offsetLine: 1 });
+		if (!location) return;
+		const { line, column } = location;
+		properties.loc = {
+			column,
+			file: id,
+			line
+		};
+	}
+	if (properties.frame === void 0) {
+		const { line, column } = properties.loc;
+		properties.frame = getCodeFrame(source, line, column);
+	}
+}
+//#endregion
+export { logInvalidLogPosition as a, logPluginError as c, logInputHookInOutputPlugin as i, locate as l, error as n, logMultipleWatcherOption as o, logCycleLoading as r, logParseError as s, augmentCodeLocation as t, getCodeFrame as u };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/misc-DJYbNKZX.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/misc-DJYbNKZX.mjs
new file mode 100644
index 0000000..1dc8be5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/misc-DJYbNKZX.mjs
@@ -0,0 +1,21 @@
+//#region src/utils/misc.ts
+function arraify(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function isPromiseLike(value) {
+	return value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function unimplemented(info) {
+	if (info) throw new Error(`unimplemented: ${info}`);
+	throw new Error("unimplemented");
+}
+function unreachable(info) {
+	if (info) throw new Error(`unreachable: ${info}`);
+	throw new Error("unreachable");
+}
+function unsupported(info) {
+	throw new Error(`UNSUPPORTED: ${info}`);
+}
+function noop(..._args) {}
+//#endregion
+export { unreachable as a, unimplemented as i, isPromiseLike as n, unsupported as o, noop as r, arraify as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/normalize-string-or-regex-C-WttzRA.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/normalize-string-or-regex-C-WttzRA.mjs
new file mode 100644
index 0000000..c32ff8c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/normalize-string-or-regex-C-WttzRA.mjs
@@ -0,0 +1,68 @@
+import { n as __toESM, t as require_binding } from "./binding-C9S351wt.mjs";
+import { c as logPluginError, n as error } from "./logs-D80CXhvg.mjs";
+//#region src/builtin-plugin/utils.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+var BuiltinPlugin = class {
+	name;
+	_options;
+	/** Vite-specific option to control plugin ordering */
+	enforce;
+	constructor(name, _options) {
+		this.name = name;
+		this._options = _options;
+	}
+};
+function makeBuiltinPluginCallable(plugin) {
+	let callablePlugin = new import_binding.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+	const wrappedPlugin = plugin;
+	for (const key in callablePlugin) {
+		const wrappedHook = async function(...args) {
+			try {
+				return await callablePlugin[key](...args);
+			} catch (e) {
+				if (e instanceof Error && !e.stack?.includes("at ")) Error.captureStackTrace(e, wrappedPlugin[key]);
+				return error(logPluginError(e, plugin.name, {
+					hook: key,
+					id: key === "transform" ? args[2] : void 0
+				}));
+			}
+		};
+		const order = callablePlugin.getOrder(key);
+		if (order == void 0) wrappedPlugin[key] = wrappedHook;
+		else wrappedPlugin[key] = {
+			handler: wrappedHook,
+			order
+		};
+	}
+	return wrappedPlugin;
+}
+function bindingifyBuiltInPlugin(plugin) {
+	return {
+		__name: plugin.name,
+		options: plugin._options
+	};
+}
+function bindingifyManifestPlugin(plugin, pluginContextData) {
+	const { isOutputOptionsForLegacyChunks, ...options } = plugin._options;
+	return {
+		__name: plugin.name,
+		options: {
+			...options,
+			isLegacy: isOutputOptionsForLegacyChunks ? (opts) => {
+				return isOutputOptionsForLegacyChunks(pluginContextData.getOutputOptions(opts));
+			} : void 0
+		}
+	};
+}
+//#endregion
+//#region src/utils/normalize-string-or-regex.ts
+function normalizedStringOrRegex(pattern) {
+	if (!pattern) return;
+	if (!isReadonlyArray(pattern)) return [pattern];
+	return pattern;
+}
+function isReadonlyArray(input) {
+	return Array.isArray(input);
+}
+//#endregion
+export { makeBuiltinPluginCallable as a, bindingifyManifestPlugin as i, BuiltinPlugin as n, bindingifyBuiltInPlugin as r, normalizedStringOrRegex as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/parse-Ch28GO2f.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/parse-Ch28GO2f.mjs
new file mode 100644
index 0000000..518be37
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/parse-Ch28GO2f.mjs
@@ -0,0 +1,74 @@
+import { n as __toESM, t as require_binding } from "./binding-C9S351wt.mjs";
+//#region ../../node_modules/.pnpm/oxc-parser@0.130.0/node_modules/oxc-parser/src-js/wrap.js
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+function wrap(result) {
+	let program, module, comments, errors;
+	return {
+		get program() {
+			if (!program) program = jsonParseAst(result.program);
+			return program;
+		},
+		get module() {
+			if (!module) module = result.module;
+			return module;
+		},
+		get comments() {
+			if (!comments) comments = result.comments;
+			return comments;
+		},
+		get errors() {
+			if (!errors) errors = result.errors;
+			return errors;
+		}
+	};
+}
+function jsonParseAst(programJson) {
+	const { node: program, fixes } = JSON.parse(programJson);
+	for (const fixPath of fixes) applyFix(program, fixPath);
+	return program;
+}
+function applyFix(program, fixPath) {
+	let node = program;
+	for (const key of fixPath) node = node[key];
+	if (node.bigint) node.value = BigInt(node.bigint);
+	else try {
+		node.value = RegExp(node.regex.pattern, node.regex.flags);
+	} catch {}
+}
+//#endregion
+//#region src/utils/parse.ts
+/**
+* Parse JS/TS source asynchronously on a separate thread.
+*
+* Note that not all of the workload can happen on a separate thread.
+* Parsing on Rust side does happen in a separate thread, but deserialization of the AST to JS objects
+* has to happen on current thread. This synchronous deserialization work typically outweighs
+* the asynchronous parsing by a factor of between 3 and 20.
+*
+* i.e. the majority of the workload cannot be parallelized by using this method.
+*
+* Generally {@linkcode parseSync} is preferable to use as it does not have the overhead of spawning a thread.
+* If you need to parallelize parsing multiple files, it is recommended to use worker threads.
+*
+* @category Utilities
+*/
+async function parse(filename, sourceText, options) {
+	return wrap(await (0, import_binding.parse)(filename, sourceText, options));
+}
+/**
+* Parse JS/TS source synchronously on current thread.
+*
+* This is generally preferable over {@linkcode parse} (async) as it does not have the overhead
+* of spawning a thread, and the majority of the workload cannot be parallelized anyway
+* (see {@linkcode parse} documentation for details).
+*
+* If you need to parallelize parsing multiple files, it is recommended to use worker threads
+* with {@linkcode parseSync} rather than using {@linkcode parse}.
+*
+* @category Utilities
+*/
+function parseSync(filename, sourceText, options) {
+	return wrap((0, import_binding.parseSync)(filename, sourceText, options));
+}
+//#endregion
+export { parseSync as n, parse as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/prompt-U5ajztzG.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/prompt-U5ajztzG.mjs
new file mode 100644
index 0000000..493675d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/prompt-U5ajztzG.mjs
@@ -0,0 +1,847 @@
+import process$1, { stdin, stdout } from "node:process";
+import { WriteStream } from "node:tty";
+import f from "node:readline";
+//#region ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/chunks/prompt.mjs
+function getDefaultExportFromCjs(x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var src;
+var hasRequiredSrc;
+function requireSrc() {
+	if (hasRequiredSrc) return src;
+	hasRequiredSrc = 1;
+	const ESC = "\x1B";
+	const CSI = `${ESC}[`;
+	const beep = "\x07";
+	const cursor = {
+		to(x, y) {
+			if (!y) return `${CSI}${x + 1}G`;
+			return `${CSI}${y + 1};${x + 1}H`;
+		},
+		move(x, y) {
+			let ret = "";
+			if (x < 0) ret += `${CSI}${-x}D`;
+			else if (x > 0) ret += `${CSI}${x}C`;
+			if (y < 0) ret += `${CSI}${-y}A`;
+			else if (y > 0) ret += `${CSI}${y}B`;
+			return ret;
+		},
+		up: (count = 1) => `${CSI}${count}A`,
+		down: (count = 1) => `${CSI}${count}B`,
+		forward: (count = 1) => `${CSI}${count}C`,
+		backward: (count = 1) => `${CSI}${count}D`,
+		nextLine: (count = 1) => `${CSI}E`.repeat(count),
+		prevLine: (count = 1) => `${CSI}F`.repeat(count),
+		left: `${CSI}G`,
+		hide: `${CSI}?25l`,
+		show: `${CSI}?25h`,
+		save: `${ESC}7`,
+		restore: `${ESC}8`
+	};
+	src = {
+		cursor,
+		scroll: {
+			up: (count = 1) => `${CSI}S`.repeat(count),
+			down: (count = 1) => `${CSI}T`.repeat(count)
+		},
+		erase: {
+			screen: `${CSI}2J`,
+			up: (count = 1) => `${CSI}1J`.repeat(count),
+			down: (count = 1) => `${CSI}J`.repeat(count),
+			line: `${CSI}2K`,
+			lineEnd: `${CSI}K`,
+			lineStart: `${CSI}1K`,
+			lines(count) {
+				let clear = "";
+				for (let i = 0; i < count; i++) clear += this.line + (i < count - 1 ? cursor.up() : "");
+				if (count) clear += cursor.left;
+				return clear;
+			}
+		},
+		beep
+	};
+	return src;
+}
+var srcExports = requireSrc();
+var picocolors = { exports: {} };
+var hasRequiredPicocolors;
+function requirePicocolors() {
+	if (hasRequiredPicocolors) return picocolors.exports;
+	hasRequiredPicocolors = 1;
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	picocolors.exports = createColors();
+	picocolors.exports.createColors = createColors;
+	return picocolors.exports;
+}
+const e = /* @__PURE__ */ getDefaultExportFromCjs(/* @__PURE__ */ requirePicocolors());
+function J({ onlyFirst: t = false } = {}) {
+	const F = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");
+	return new RegExp(F, t ? void 0 : "g");
+}
+const Q = J();
+function T$1(t) {
+	if (typeof t != "string") throw new TypeError(`Expected a \`string\`, got \`${typeof t}\``);
+	return t.replace(Q, "");
+}
+function O(t) {
+	return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var P$1 = { exports: {} };
+(function(t) {
+	var u = {};
+	t.exports = u, u.eastAsianWidth = function(e) {
+		var s = e.charCodeAt(0), i = e.length == 2 ? e.charCodeAt(1) : 0, D = s;
+		return 55296 <= s && s <= 56319 && 56320 <= i && i <= 57343 && (s &= 1023, i &= 1023, D = s << 10 | i, D += 65536), D == 12288 || 65281 <= D && D <= 65376 || 65504 <= D && D <= 65510 ? "F" : D == 8361 || 65377 <= D && D <= 65470 || 65474 <= D && D <= 65479 || 65482 <= D && D <= 65487 || 65490 <= D && D <= 65495 || 65498 <= D && D <= 65500 || 65512 <= D && D <= 65518 ? "H" : 4352 <= D && D <= 4447 || 4515 <= D && D <= 4519 || 4602 <= D && D <= 4607 || 9001 <= D && D <= 9002 || 11904 <= D && D <= 11929 || 11931 <= D && D <= 12019 || 12032 <= D && D <= 12245 || 12272 <= D && D <= 12283 || 12289 <= D && D <= 12350 || 12353 <= D && D <= 12438 || 12441 <= D && D <= 12543 || 12549 <= D && D <= 12589 || 12593 <= D && D <= 12686 || 12688 <= D && D <= 12730 || 12736 <= D && D <= 12771 || 12784 <= D && D <= 12830 || 12832 <= D && D <= 12871 || 12880 <= D && D <= 13054 || 13056 <= D && D <= 19903 || 19968 <= D && D <= 42124 || 42128 <= D && D <= 42182 || 43360 <= D && D <= 43388 || 44032 <= D && D <= 55203 || 55216 <= D && D <= 55238 || 55243 <= D && D <= 55291 || 63744 <= D && D <= 64255 || 65040 <= D && D <= 65049 || 65072 <= D && D <= 65106 || 65108 <= D && D <= 65126 || 65128 <= D && D <= 65131 || 110592 <= D && D <= 110593 || 127488 <= D && D <= 127490 || 127504 <= D && D <= 127546 || 127552 <= D && D <= 127560 || 127568 <= D && D <= 127569 || 131072 <= D && D <= 194367 || 177984 <= D && D <= 196605 || 196608 <= D && D <= 262141 ? "W" : 32 <= D && D <= 126 || 162 <= D && D <= 163 || 165 <= D && D <= 166 || D == 172 || D == 175 || 10214 <= D && D <= 10221 || 10629 <= D && D <= 10630 ? "Na" : D == 161 || D == 164 || 167 <= D && D <= 168 || D == 170 || 173 <= D && D <= 174 || 176 <= D && D <= 180 || 182 <= D && D <= 186 || 188 <= D && D <= 191 || D == 198 || D == 208 || 215 <= D && D <= 216 || 222 <= D && D <= 225 || D == 230 || 232 <= D && D <= 234 || 236 <= D && D <= 237 || D == 240 || 242 <= D && D <= 243 || 247 <= D && D <= 250 || D == 252 || D == 254 || D == 257 || D == 273 || D == 275 || D == 283 || 294 <= D && D <= 295 || D == 299 || 305 <= D && D <= 307 || D == 312 || 319 <= D && D <= 322 || D == 324 || 328 <= D && D <= 331 || D == 333 || 338 <= D && D <= 339 || 358 <= D && D <= 359 || D == 363 || D == 462 || D == 464 || D == 466 || D == 468 || D == 470 || D == 472 || D == 474 || D == 476 || D == 593 || D == 609 || D == 708 || D == 711 || 713 <= D && D <= 715 || D == 717 || D == 720 || 728 <= D && D <= 731 || D == 733 || D == 735 || 768 <= D && D <= 879 || 913 <= D && D <= 929 || 931 <= D && D <= 937 || 945 <= D && D <= 961 || 963 <= D && D <= 969 || D == 1025 || 1040 <= D && D <= 1103 || D == 1105 || D == 8208 || 8211 <= D && D <= 8214 || 8216 <= D && D <= 8217 || 8220 <= D && D <= 8221 || 8224 <= D && D <= 8226 || 8228 <= D && D <= 8231 || D == 8240 || 8242 <= D && D <= 8243 || D == 8245 || D == 8251 || D == 8254 || D == 8308 || D == 8319 || 8321 <= D && D <= 8324 || D == 8364 || D == 8451 || D == 8453 || D == 8457 || D == 8467 || D == 8470 || 8481 <= D && D <= 8482 || D == 8486 || D == 8491 || 8531 <= D && D <= 8532 || 8539 <= D && D <= 8542 || 8544 <= D && D <= 8555 || 8560 <= D && D <= 8569 || D == 8585 || 8592 <= D && D <= 8601 || 8632 <= D && D <= 8633 || D == 8658 || D == 8660 || D == 8679 || D == 8704 || 8706 <= D && D <= 8707 || 8711 <= D && D <= 8712 || D == 8715 || D == 8719 || D == 8721 || D == 8725 || D == 8730 || 8733 <= D && D <= 8736 || D == 8739 || D == 8741 || 8743 <= D && D <= 8748 || D == 8750 || 8756 <= D && D <= 8759 || 8764 <= D && D <= 8765 || D == 8776 || D == 8780 || D == 8786 || 8800 <= D && D <= 8801 || 8804 <= D && D <= 8807 || 8810 <= D && D <= 8811 || 8814 <= D && D <= 8815 || 8834 <= D && D <= 8835 || 8838 <= D && D <= 8839 || D == 8853 || D == 8857 || D == 8869 || D == 8895 || D == 8978 || 9312 <= D && D <= 9449 || 9451 <= D && D <= 9547 || 9552 <= D && D <= 9587 || 9600 <= D && D <= 9615 || 9618 <= D && D <= 9621 || 9632 <= D && D <= 9633 || 9635 <= D && D <= 9641 || 9650 <= D && D <= 9651 || 9654 <= D && D <= 9655 || 9660 <= D && D <= 9661 || 9664 <= D && D <= 9665 || 9670 <= D && D <= 9672 || D == 9675 || 9678 <= D && D <= 9681 || 9698 <= D && D <= 9701 || D == 9711 || 9733 <= D && D <= 9734 || D == 9737 || 9742 <= D && D <= 9743 || 9748 <= D && D <= 9749 || D == 9756 || D == 9758 || D == 9792 || D == 9794 || 9824 <= D && D <= 9825 || 9827 <= D && D <= 9829 || 9831 <= D && D <= 9834 || 9836 <= D && D <= 9837 || D == 9839 || 9886 <= D && D <= 9887 || 9918 <= D && D <= 9919 || 9924 <= D && D <= 9933 || 9935 <= D && D <= 9953 || D == 9955 || 9960 <= D && D <= 9983 || D == 10045 || D == 10071 || 10102 <= D && D <= 10111 || 11093 <= D && D <= 11097 || 12872 <= D && D <= 12879 || 57344 <= D && D <= 63743 || 65024 <= D && D <= 65039 || D == 65533 || 127232 <= D && D <= 127242 || 127248 <= D && D <= 127277 || 127280 <= D && D <= 127337 || 127344 <= D && D <= 127386 || 917760 <= D && D <= 917999 || 983040 <= D && D <= 1048573 || 1048576 <= D && D <= 1114109 ? "A" : "N";
+	}, u.characterLength = function(e) {
+		var s = this.eastAsianWidth(e);
+		return s == "F" || s == "W" || s == "A" ? 2 : 1;
+	};
+	function F(e) {
+		return e.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[^\uD800-\uDFFF]/g) || [];
+	}
+	u.length = function(e) {
+		for (var s = F(e), i = 0, D = 0; D < s.length; D++) i = i + this.characterLength(s[D]);
+		return i;
+	}, u.slice = function(e, s, i) {
+		textLen = u.length(e), s = s || 0, i = i || 1, s < 0 && (s = textLen + s), i < 0 && (i = textLen + i);
+		for (var D = "", C = 0, o = F(e), E = 0; E < o.length; E++) {
+			var a = o[E], n = u.length(a);
+			if (C >= s - (n == 2 ? 1 : 0)) if (C + n <= i) D += a;
+			else break;
+			C += n;
+		}
+		return D;
+	};
+})(P$1);
+var X = P$1.exports;
+const DD = O(X);
+var uD = function() {
+	return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67)\uDB40\uDC7F|(?:\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFC-\uDFFF])|\uD83D\uDC68(?:\uD83C\uDFFB(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|[\u2695\u2696\u2708]\uFE0F|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))?|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])\uFE0F|\u200D(?:(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D[\uDC66\uDC67])|\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC)?|(?:\uD83D\uDC69(?:\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC69(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83E\uDDD1(?:\u200D(?:\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDE36\u200D\uD83C\uDF2B|\uD83C\uDFF3\uFE0F\u200D\u26A7|\uD83D\uDC3B\u200D\u2744|(?:(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\uD83C\uDFF4\u200D\u2620|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])\u200D[\u2640\u2642]|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u2600-\u2604\u260E\u2611\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26B0\u26B1\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0\u26F1\u26F4\u26F7\u26F8\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u3030\u303D\u3297\u3299]|\uD83C[\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]|\uD83D[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3])\uFE0F|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDE35\u200D\uD83D\uDCAB|\uD83D\uDE2E\u200D\uD83D\uDCA8|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83E\uDDD1(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83D\uDC69(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83C\uDDF4\uD83C\uDDF2|\uD83D\uDC08\u200D\u2B1B|\u2764\uFE0F\u200D(?:\uD83D\uDD25|\uD83E\uDE79)|\uD83D\uDC41\uFE0F|\uD83C\uDFF3\uFE0F|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|[#\*0-9]\uFE0F\u20E3|\u2764\uFE0F|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|\uD83C\uDFF4|(?:[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270C\u270D]|\uD83D[\uDD74\uDD90])(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC08\uDC15\uDC3B\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE2E\uDE35\uDE36\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5]|\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD]|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF]|[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0D\uDD0E\uDD10-\uDD17\uDD1D\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78\uDD7A-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCB\uDDD0\uDDE0-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6]|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26A7\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5-\uDED7\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDD77\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
+};
+const FD = O(uD);
+function A$1(t, u = {}) {
+	if (typeof t != "string" || t.length === 0 || (u = {
+		ambiguousIsNarrow: true,
+		...u
+	}, t = T$1(t), t.length === 0)) return 0;
+	t = t.replace(FD(), "  ");
+	const F = u.ambiguousIsNarrow ? 1 : 2;
+	let e = 0;
+	for (const s of t) {
+		const i = s.codePointAt(0);
+		if (i <= 31 || i >= 127 && i <= 159 || i >= 768 && i <= 879) continue;
+		switch (DD.eastAsianWidth(s)) {
+			case "F":
+			case "W":
+				e += 2;
+				break;
+			case "A":
+				e += F;
+				break;
+			default: e += 1;
+		}
+	}
+	return e;
+}
+const m = 10, L$1 = (t = 0) => (u) => `\x1B[${u + t}m`, N = (t = 0) => (u) => `\x1B[${38 + t};5;${u}m`, I = (t = 0) => (u, F, e) => `\x1B[${38 + t};2;${u};${F};${e}m`, r = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	}
+};
+Object.keys(r.modifier);
+const tD = Object.keys(r.color), eD = Object.keys(r.bgColor);
+[...tD, ...eD];
+function sD() {
+	const t = /* @__PURE__ */ new Map();
+	for (const [u, F] of Object.entries(r)) {
+		for (const [e, s] of Object.entries(F)) r[e] = {
+			open: `\x1B[${s[0]}m`,
+			close: `\x1B[${s[1]}m`
+		}, F[e] = r[e], t.set(s[0], s[1]);
+		Object.defineProperty(r, u, {
+			value: F,
+			enumerable: false
+		});
+	}
+	return Object.defineProperty(r, "codes", {
+		value: t,
+		enumerable: false
+	}), r.color.close = "\x1B[39m", r.bgColor.close = "\x1B[49m", r.color.ansi = L$1(), r.color.ansi256 = N(), r.color.ansi16m = I(), r.bgColor.ansi = L$1(m), r.bgColor.ansi256 = N(m), r.bgColor.ansi16m = I(m), Object.defineProperties(r, {
+		rgbToAnsi256: {
+			value: (u, F, e) => u === F && F === e ? u < 8 ? 16 : u > 248 ? 231 : Math.round((u - 8) / 247 * 24) + 232 : 16 + 36 * Math.round(u / 255 * 5) + 6 * Math.round(F / 255 * 5) + Math.round(e / 255 * 5),
+			enumerable: false
+		},
+		hexToRgb: {
+			value: (u) => {
+				const F = /[a-f\d]{6}|[a-f\d]{3}/i.exec(u.toString(16));
+				if (!F) return [
+					0,
+					0,
+					0
+				];
+				let [e] = F;
+				e.length === 3 && (e = [...e].map((i) => i + i).join(""));
+				const s = Number.parseInt(e, 16);
+				return [
+					s >> 16 & 255,
+					s >> 8 & 255,
+					s & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (u) => r.rgbToAnsi256(...r.hexToRgb(u)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value: (u) => {
+				if (u < 8) return 30 + u;
+				if (u < 16) return 90 + (u - 8);
+				let F, e, s;
+				if (u >= 232) F = ((u - 232) * 10 + 8) / 255, e = F, s = F;
+				else {
+					u -= 16;
+					const C = u % 36;
+					F = Math.floor(u / 36) / 5, e = Math.floor(C / 6) / 5, s = C % 6 / 5;
+				}
+				const i = Math.max(F, e, s) * 2;
+				if (i === 0) return 30;
+				let D = 30 + (Math.round(s) << 2 | Math.round(e) << 1 | Math.round(F));
+				return i === 2 && (D += 60), D;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (u, F, e) => r.ansi256ToAnsi(r.rgbToAnsi256(u, F, e)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (u) => r.ansi256ToAnsi(r.hexToAnsi256(u)),
+			enumerable: false
+		}
+	}), r;
+}
+const iD = sD(), v = new Set(["\x1B", "›"]), CD = 39, w$1 = "\x07", W$1 = "[", rD = "]", R = "m", y = `${rD}8;;`, V$1 = (t) => `${v.values().next().value}${W$1}${t}${R}`, z = (t) => `${v.values().next().value}${y}${t}${w$1}`, ED = (t) => t.split(" ").map((u) => A$1(u)), _ = (t, u, F) => {
+	const e = [...u];
+	let s = false, i = false, D = A$1(T$1(t[t.length - 1]));
+	for (const [C, o] of e.entries()) {
+		const E = A$1(o);
+		if (D + E <= F ? t[t.length - 1] += o : (t.push(o), D = 0), v.has(o) && (s = true, i = e.slice(C + 1).join("").startsWith(y)), s) {
+			i ? o === w$1 && (s = false, i = false) : o === R && (s = false);
+			continue;
+		}
+		D += E, D === F && C < e.length - 1 && (t.push(""), D = 0);
+	}
+	!D && t[t.length - 1].length > 0 && t.length > 1 && (t[t.length - 2] += t.pop());
+}, nD = (t) => {
+	const u = t.split(" ");
+	let F = u.length;
+	for (; F > 0 && !(A$1(u[F - 1]) > 0);) F--;
+	return F === u.length ? t : u.slice(0, F).join(" ") + u.slice(F).join("");
+}, oD = (t, u, F = {}) => {
+	if (F.trim !== false && t.trim() === "") return "";
+	let e = "", s, i;
+	const D = ED(t);
+	let C = [""];
+	for (const [E, a] of t.split(" ").entries()) {
+		F.trim !== false && (C[C.length - 1] = C[C.length - 1].trimStart());
+		let n = A$1(C[C.length - 1]);
+		if (E !== 0 && (n >= u && (F.wordWrap === false || F.trim === false) && (C.push(""), n = 0), (n > 0 || F.trim === false) && (C[C.length - 1] += " ", n++)), F.hard && D[E] > u) {
+			const B = u - n, p = 1 + Math.floor((D[E] - B - 1) / u);
+			Math.floor((D[E] - 1) / u) < p && C.push(""), _(C, a, u);
+			continue;
+		}
+		if (n + D[E] > u && n > 0 && D[E] > 0) {
+			if (F.wordWrap === false && n < u) {
+				_(C, a, u);
+				continue;
+			}
+			C.push("");
+		}
+		if (n + D[E] > u && F.wordWrap === false) {
+			_(C, a, u);
+			continue;
+		}
+		C[C.length - 1] += a;
+	}
+	F.trim !== false && (C = C.map((E) => nD(E)));
+	const o = [...C.join(`
+`)];
+	for (const [E, a] of o.entries()) {
+		if (e += a, v.has(a)) {
+			const { groups: B } = new RegExp(`(?:\\${W$1}(?<code>\\d+)m|\\${y}(?<uri>.*)${w$1})`).exec(o.slice(E).join("")) || { groups: {} };
+			if (B.code !== void 0) {
+				const p = Number.parseFloat(B.code);
+				s = p === CD ? void 0 : p;
+			} else B.uri !== void 0 && (i = B.uri.length === 0 ? void 0 : B.uri);
+		}
+		const n = iD.codes.get(Number(s));
+		o[E + 1] === `
+` ? (i && (e += z("")), s && n && (e += V$1(n))) : a === `
+` && (s && n && (e += V$1(s)), i && (e += z(i)));
+	}
+	return e;
+};
+function G(t, u, F) {
+	return String(t).normalize().replace(/\r\n/g, `
+`).split(`
+`).map((e) => oD(e, u, F)).join(`
+`);
+}
+const c = {
+	actions: new Set([
+		"up",
+		"down",
+		"left",
+		"right",
+		"space",
+		"enter",
+		"cancel"
+	]),
+	aliases: new Map([
+		["k", "up"],
+		["j", "down"],
+		["h", "left"],
+		["l", "right"],
+		["", "cancel"],
+		["escape", "cancel"]
+	])
+};
+function k$1(t, u) {
+	if (typeof t == "string") return c.aliases.get(t) === u;
+	for (const F of t) if (F !== void 0 && k$1(F, u)) return true;
+	return false;
+}
+function lD(t, u) {
+	if (t === u) return;
+	const F = t.split(`
+`), e = u.split(`
+`), s = [];
+	for (let i = 0; i < Math.max(F.length, e.length); i++) F[i] !== e[i] && s.push(i);
+	return s;
+}
+globalThis.process.platform.startsWith("win");
+const S = Symbol("clack:cancel");
+function d$1(t, u) {
+	const F = t;
+	F.isTTY && F.setRawMode(u);
+}
+var AD = Object.defineProperty, pD = (t, u, F) => u in t ? AD(t, u, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: F
+}) : t[u] = F, h = (t, u, F) => (pD(t, typeof u != "symbol" ? u + "" : u, F), F);
+var x = class {
+	constructor(u, F = true) {
+		h(this, "input"), h(this, "output"), h(this, "_abortSignal"), h(this, "rl"), h(this, "opts"), h(this, "_render"), h(this, "_track", false), h(this, "_prevFrame", ""), h(this, "_subscribers", /* @__PURE__ */ new Map()), h(this, "_cursor", 0), h(this, "state", "initial"), h(this, "error", ""), h(this, "value");
+		const { input: e = stdin, output: s = stdout, render: i, signal: D, ...C } = u;
+		this.opts = C, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = i.bind(this), this._track = F, this._abortSignal = D, this.input = e, this.output = s;
+	}
+	unsubscribe() {
+		this._subscribers.clear();
+	}
+	setSubscriber(u, F) {
+		const e = this._subscribers.get(u) ?? [];
+		e.push(F), this._subscribers.set(u, e);
+	}
+	on(u, F) {
+		this.setSubscriber(u, { cb: F });
+	}
+	once(u, F) {
+		this.setSubscriber(u, {
+			cb: F,
+			once: true
+		});
+	}
+	emit(u, ...F) {
+		const e = this._subscribers.get(u) ?? [], s = [];
+		for (const i of e) i.cb(...F), i.once && s.push(() => e.splice(e.indexOf(i), 1));
+		for (const i of s) i();
+	}
+	prompt() {
+		return new Promise((u, F) => {
+			if (this._abortSignal) {
+				if (this._abortSignal.aborted) return this.state = "cancel", this.close(), u(S);
+				this._abortSignal.addEventListener("abort", () => {
+					this.state = "cancel", this.close();
+				}, { once: true });
+			}
+			const e = new WriteStream(0);
+			e._write = (s, i, D) => {
+				this._track && (this.value = this.rl?.line.replace(/\t/g, ""), this._cursor = this.rl?.cursor ?? 0, this.emit("value", this.value)), D();
+			}, this.input.pipe(e), this.rl = f.createInterface({
+				input: this.input,
+				output: e,
+				tabSize: 2,
+				prompt: "",
+				escapeCodeTimeout: 50
+			}), f.emitKeypressEvents(this.input, this.rl), this.rl.prompt(), this.opts.initialValue !== void 0 && this._track && this.rl.write(this.opts.initialValue), this.input.on("keypress", this.onKeypress), d$1(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+				this.output.write(srcExports.cursor.show), this.output.off("resize", this.render), d$1(this.input, false), u(this.value);
+			}), this.once("cancel", () => {
+				this.output.write(srcExports.cursor.show), this.output.off("resize", this.render), d$1(this.input, false), u(S);
+			});
+		});
+	}
+	onKeypress(u, F) {
+		if (this.state === "error" && (this.state = "active"), F?.name && (!this._track && c.aliases.has(F.name) && this.emit("cursor", c.aliases.get(F.name)), c.actions.has(F.name) && this.emit("cursor", F.name)), u && (u.toLowerCase() === "y" || u.toLowerCase() === "n") && this.emit("confirm", u.toLowerCase() === "y"), u === "	" && this.opts.placeholder && (this.value || (this.rl?.write(this.opts.placeholder), this.emit("value", this.opts.placeholder))), u && this.emit("key", u.toLowerCase()), F?.name === "return") {
+			if (this.opts.validate) {
+				const e = this.opts.validate(this.value);
+				e && (this.error = e instanceof Error ? e.message : e, this.state = "error", this.rl?.write(this.value));
+			}
+			this.state !== "error" && (this.state = "submit");
+		}
+		k$1([
+			u,
+			F?.name,
+			F?.sequence
+		], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+	}
+	close() {
+		this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), d$1(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+	}
+	restoreCursor() {
+		const u = G(this._prevFrame, process.stdout.columns, { hard: true }).split(`
+`).length - 1;
+		this.output.write(srcExports.cursor.move(-999, u * -1));
+	}
+	render() {
+		const u = G(this._render(this) ?? "", process.stdout.columns, { hard: true });
+		if (u !== this._prevFrame) {
+			if (this.state === "initial") this.output.write(srcExports.cursor.hide);
+			else {
+				const F = lD(this._prevFrame, u);
+				if (this.restoreCursor(), F && F?.length === 1) {
+					const e = F[0];
+					this.output.write(srcExports.cursor.move(0, e)), this.output.write(srcExports.erase.lines(1));
+					const s = u.split(`
+`);
+					this.output.write(s[e]), this._prevFrame = u, this.output.write(srcExports.cursor.move(0, s.length - e - 1));
+					return;
+				}
+				if (F && F?.length > 1) {
+					const e = F[0];
+					this.output.write(srcExports.cursor.move(0, e)), this.output.write(srcExports.erase.down());
+					const s = u.split(`
+`).slice(e);
+					this.output.write(s.join(`
+`)), this._prevFrame = u;
+					return;
+				}
+				this.output.write(srcExports.erase.down());
+			}
+			this.output.write(u), this.state === "initial" && (this.state = "active"), this._prevFrame = u;
+		}
+	}
+};
+var fD = class extends x {
+	get cursor() {
+		return this.value ? 0 : 1;
+	}
+	get _value() {
+		return this.cursor === 0;
+	}
+	constructor(u) {
+		super(u, false), this.value = !!u.initialValue, this.on("value", () => {
+			this.value = this._value;
+		}), this.on("confirm", (F) => {
+			this.output.write(srcExports.cursor.move(0, -1)), this.value = F, this.state = "submit", this.close();
+		}), this.on("cursor", () => {
+			this.value = !this.value;
+		});
+	}
+};
+var bD = Object.defineProperty, mD = (t, u, F) => u in t ? bD(t, u, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: F
+}) : t[u] = F, Y = (t, u, F) => (mD(t, typeof u != "symbol" ? u + "" : u, F), F);
+let wD = class extends x {
+	constructor(u) {
+		super(u, false), Y(this, "options"), Y(this, "cursor", 0), this.options = u.options, this.value = [...u.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: F }) => F === u.cursorAt), 0), this.on("key", (F) => {
+			F === "a" && this.toggleAll();
+		}), this.on("cursor", (F) => {
+			switch (F) {
+				case "left":
+				case "up":
+					this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+					break;
+				case "down":
+				case "right":
+					this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+					break;
+				case "space":
+					this.toggleValue();
+					break;
+			}
+		});
+	}
+	get _value() {
+		return this.options[this.cursor].value;
+	}
+	toggleAll() {
+		const u = this.value.length === this.options.length;
+		this.value = u ? [] : this.options.map((F) => F.value);
+	}
+	toggleValue() {
+		const u = this.value.includes(this._value);
+		this.value = u ? this.value.filter((F) => F !== this._value) : [...this.value, this._value];
+	}
+};
+var SD = Object.defineProperty, $D = (t, u, F) => u in t ? SD(t, u, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: F
+}) : t[u] = F, q = (t, u, F) => ($D(t, typeof u != "symbol" ? u + "" : u, F), F);
+var jD = class extends x {
+	constructor(u) {
+		super(u, false), q(this, "options"), q(this, "cursor", 0), this.options = u.options, this.cursor = this.options.findIndex(({ value: F }) => F === u.initialValue), this.cursor === -1 && (this.cursor = 0), this.changeValue(), this.on("cursor", (F) => {
+			switch (F) {
+				case "left":
+				case "up":
+					this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+					break;
+				case "down":
+				case "right":
+					this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+					break;
+			}
+			this.changeValue();
+		});
+	}
+	get _value() {
+		return this.options[this.cursor];
+	}
+	changeValue() {
+		this.value = this._value.value;
+	}
+};
+var PD = class extends x {
+	get valueWithCursor() {
+		if (this.state === "submit") return this.value;
+		if (this.cursor >= this.value.length) return `${this.value}\u2588`;
+		const u = this.value.slice(0, this.cursor), [F, ...e$1] = this.value.slice(this.cursor);
+		return `${u}${e.inverse(F)}${e$1.join("")}`;
+	}
+	get cursor() {
+		return this._cursor;
+	}
+	constructor(u) {
+		super(u), this.on("finalize", () => {
+			this.value || (this.value = u.defaultValue);
+		});
+	}
+};
+function ce() {
+	return process$1.platform !== "win32" ? process$1.env.TERM !== "linux" : !!process$1.env.CI || !!process$1.env.WT_SESSION || !!process$1.env.TERMINUS_SUBLIME || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+const V = ce(), u = (t, n) => V ? t : n, le = u("❯", ">"), L = u("■", "x"), W = u("▲", "x"), C = u("✔", "√"), o = u(""), d = u(""), k = u("●", ">"), P = u("○", " "), A = u("◻", "[•]"), T = u("◼", "[+]"), F = u("◻", "[ ]"), w = (t) => {
+	switch (t) {
+		case "initial":
+		case "active": return e.cyan(le);
+		case "cancel": return e.red(L);
+		case "error": return e.yellow(W);
+		case "submit": return e.green(C);
+	}
+}, B = (t) => {
+	const { cursor: n, options: s, style: r } = t, i = t.maxItems ?? Number.POSITIVE_INFINITY, a = Math.max(process.stdout.rows - 4, 0), c = Math.min(a, Math.max(i, 5));
+	let l = 0;
+	n >= l + c - 3 ? l = Math.max(Math.min(n - c + 3, s.length - c), 0) : n < l + 2 && (l = Math.max(n - 2, 0));
+	const $ = c < s.length && l > 0, p = c < s.length && l + c < s.length;
+	return s.slice(l, l + c).map((M, v, x) => {
+		const j = v === 0 && $, E = v === x.length - 1 && p;
+		return j || E ? e.dim("...") : r(M, v + l === n);
+	});
+}, he = (t) => new PD({
+	validate: t.validate,
+	placeholder: t.placeholder,
+	defaultValue: t.defaultValue,
+	initialValue: t.initialValue,
+	render() {
+		const n = `${e.gray(o)}
+${w(this.state)} ${t.message}
+`, s = t.placeholder ? e.inverse(t.placeholder[0]) + e.dim(t.placeholder.slice(1)) : e.inverse(e.hidden("_")), r = this.value ? this.valueWithCursor : s;
+		switch (this.state) {
+			case "error": return `${n.trim()}
+${e.yellow(o)} ${r}
+${e.yellow(d)} ${e.yellow(this.error)}
+`;
+			case "submit": return `${n}${e.gray(o)} ${e.dim(this.value || t.placeholder)}`;
+			case "cancel": return `${n}${e.gray(o)} ${e.strikethrough(e.dim(this.value ?? ""))}${this.value?.trim() ? `
+${e.gray(o)}` : ""}`;
+			default: return `${n}${e.cyan(o)} ${r}
+${e.cyan(d)}
+`;
+		}
+	}
+}).prompt(), ye = (t) => {
+	const n = t.active ?? "Yes", s = t.inactive ?? "No";
+	return new fD({
+		active: n,
+		inactive: s,
+		initialValue: t.initialValue ?? true,
+		render() {
+			const r = `${e.gray(o)}
+${w(this.state)} ${t.message}
+`, i = this.value ? n : s;
+			switch (this.state) {
+				case "submit": return `${r}${e.gray(o)} ${e.dim(i)}`;
+				case "cancel": return `${r}${e.gray(o)} ${e.strikethrough(e.dim(i))}
+${e.gray(o)}`;
+				default: return `${r}${e.cyan(o)} ${this.value ? `${e.green(k)} ${n}` : `${e.dim(P)} ${e.dim(n)}`} ${e.dim("/")} ${this.value ? `${e.dim(P)} ${e.dim(s)}` : `${e.green(k)} ${s}`}
+${e.cyan(d)}
+`;
+			}
+		}
+	}).prompt();
+}, ve = (t) => {
+	const n = (s, r) => {
+		const i = s.label ?? String(s.value);
+		switch (r) {
+			case "selected": return `${e.dim(i)}`;
+			case "active": return `${e.green(k)} ${i} ${s.hint ? e.dim(`(${s.hint})`) : ""}`;
+			case "cancelled": return `${e.strikethrough(e.dim(i))}`;
+			default: return `${e.dim(P)} ${e.dim(i)}`;
+		}
+	};
+	return new jD({
+		options: t.options,
+		initialValue: t.initialValue,
+		render() {
+			const s = `${e.gray(o)}
+${w(this.state)} ${t.message}
+`;
+			switch (this.state) {
+				case "submit": return `${s}${e.gray(o)} ${n(this.options[this.cursor], "selected")}`;
+				case "cancel": return `${s}${e.gray(o)} ${n(this.options[this.cursor], "cancelled")}
+${e.gray(o)}`;
+				default: return `${s}${e.cyan(o)} ${B({
+					cursor: this.cursor,
+					options: this.options,
+					maxItems: t.maxItems,
+					style: (r, i) => n(r, i ? "active" : "inactive")
+				}).join(`
+${e.cyan(o)}  `)}
+${e.cyan(d)}
+`;
+			}
+		}
+	}).prompt();
+}, fe = (t) => {
+	const n = (s, r) => {
+		const i = s.label ?? String(s.value);
+		return r === "active" ? `${e.cyan(A)} ${i} ${s.hint ? e.dim(`(${s.hint})`) : ""}` : r === "selected" ? `${e.green(T)} ${e.dim(i)}` : r === "cancelled" ? `${e.strikethrough(e.dim(i))}` : r === "active-selected" ? `${e.green(T)} ${i} ${s.hint ? e.dim(`(${s.hint})`) : ""}` : r === "submitted" ? `${e.dim(i)}` : `${e.dim(F)} ${e.dim(i)}`;
+	};
+	return new wD({
+		options: t.options,
+		initialValues: t.initialValues,
+		required: t.required ?? true,
+		cursorAt: t.cursorAt,
+		validate(s) {
+			if (this.required && s.length === 0) return `Please select at least one option.
+${e.reset(e.dim(`Press ${e.gray(e.bgWhite(e.inverse(" space ")))} to select, ${e.gray(e.bgWhite(e.inverse(" enter ")))} to submit`))}`;
+		},
+		render() {
+			const s = `${e.gray(o)}
+${w(this.state)} ${t.message}
+`, r = (i, a) => {
+				const c = this.value.includes(i.value);
+				return a && c ? n(i, "active-selected") : c ? n(i, "selected") : n(i, a ? "active" : "inactive");
+			};
+			switch (this.state) {
+				case "submit": return `${s}${e.gray(o)} ${this.options.filter(({ value: i }) => this.value.includes(i)).map((i) => n(i, "submitted")).join(e.dim(", ")) || e.dim("none")}`;
+				case "cancel": {
+					const i = this.options.filter(({ value: a }) => this.value.includes(a)).map((a) => n(a, "cancelled")).join(e.dim(", "));
+					return `${s}${e.gray(o)} ${i.trim() ? `${i}
+${e.gray(o)}` : ""}`;
+				}
+				case "error": {
+					const i = this.error.split(`
+`).map((a, c) => c === 0 ? `${e.yellow(d)} ${e.yellow(a)}` : `   ${a}`).join(`
+`);
+					return `${s + e.yellow(o)} ${B({
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: t.maxItems,
+						style: r
+					}).join(`
+${e.yellow(o)}  `)}
+${i}
+`;
+				}
+				default: return `${s}${e.cyan(o)} ${B({
+					options: this.options,
+					cursor: this.cursor,
+					maxItems: t.maxItems,
+					style: r
+				}).join(`
+${e.cyan(o)}  `)}
+${e.cyan(d)}
+`;
+			}
+		}
+	}).prompt();
+};
+`${e.gray(o)}`;
+const kCancel = Symbol.for("cancel");
+async function prompt(message, opts = {}) {
+	const handleCancel = (value) => {
+		if (typeof value !== "symbol" || value.toString() !== "Symbol(clack:cancel)") return value;
+		switch (opts.cancel) {
+			case "reject": {
+				const error = /* @__PURE__ */ new Error("Prompt cancelled.");
+				error.name = "ConsolaPromptCancelledError";
+				if (Error.captureStackTrace) Error.captureStackTrace(error, prompt);
+				throw error;
+			}
+			case "undefined": return;
+			case "null": return null;
+			case "symbol": return kCancel;
+			default:
+			case "default": return opts.default ?? opts.initial;
+		}
+	};
+	if (!opts.type || opts.type === "text") return await he({
+		message,
+		defaultValue: opts.default,
+		placeholder: opts.placeholder,
+		initialValue: opts.initial
+	}).then(handleCancel);
+	if (opts.type === "confirm") return await ye({
+		message,
+		initialValue: opts.initial
+	}).then(handleCancel);
+	if (opts.type === "select") return await ve({
+		message,
+		options: opts.options.map((o) => typeof o === "string" ? {
+			value: o,
+			label: o
+		} : o),
+		initialValue: opts.initial
+	}).then(handleCancel);
+	if (opts.type === "multiselect") return await fe({
+		message,
+		options: opts.options.map((o) => typeof o === "string" ? {
+			value: o,
+			label: o
+		} : o),
+		required: opts.required,
+		initialValues: opts.initial
+	}).then(handleCancel);
+	throw new Error(`Unknown prompt type: ${opts.type}`);
+}
+//#endregion
+export { prompt };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/resolve-tsconfig-DkVV0OYf.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/resolve-tsconfig-DkVV0OYf.mjs
new file mode 100644
index 0000000..82700c6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/resolve-tsconfig-DkVV0OYf.mjs
@@ -0,0 +1,113 @@
+import { n as __toESM, t as require_binding } from "./binding-C9S351wt.mjs";
+import { a as bindingifySourcemap, n as normalizeBindingError } from "./error-CkdMJ9ps.mjs";
+//#region src/utils/minify.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+/**
+* Minify asynchronously.
+*
+* Note: This function can be slower than {@linkcode minifySync} due to the overhead of spawning a thread.
+*
+* @category Utilities
+* @experimental
+*/
+async function minify(filename, sourceText, options) {
+	const inputMap = bindingifySourcemap(options?.inputMap);
+	const result = await (0, import_binding.minify)(filename, sourceText, options);
+	if (result.map && inputMap) result.map = {
+		version: 3,
+		...(0, import_binding.collapseSourcemaps)([inputMap, bindingifySourcemap(result.map)])
+	};
+	return result;
+}
+/**
+* Minify synchronously.
+*
+* @category Utilities
+* @experimental
+*/
+function minifySync(filename, sourceText, options) {
+	const inputMap = bindingifySourcemap(options?.inputMap);
+	const result = (0, import_binding.minifySync)(filename, sourceText, options);
+	if (result.map && inputMap) result.map = {
+		version: 3,
+		...(0, import_binding.collapseSourcemaps)([inputMap, bindingifySourcemap(result.map)])
+	};
+	return result;
+}
+//#endregion
+//#region src/utils/transform.ts
+const yarnPnp$1 = typeof process === "object" && !!process.versions?.pnp;
+/**
+* Transpile a JavaScript or TypeScript into a target ECMAScript version, asynchronously.
+*
+* Note: This function can be slower than `transformSync` due to the overhead of spawning a thread.
+*
+* @param filename The name of the file being transformed. If this is a
+* relative path, consider setting the {@linkcode TransformOptions#cwd} option.
+* @param sourceText The source code to transform.
+* @param options The transform options including tsconfig and inputMap. See {@linkcode TransformOptions} for more information.
+* @param cache Optional tsconfig cache for reusing resolved tsconfig across multiple transforms.
+* Only used when `options.tsconfig` is `true`.
+*
+* @returns a promise that resolves to an object containing the transformed code,
+* source maps, and any errors that occurred during parsing or transformation.
+*
+* @category Utilities
+* @experimental
+*/
+async function transform(filename, sourceText, options, cache) {
+	const result = await (0, import_binding.enhancedTransform)(filename, sourceText, options, cache, yarnPnp$1);
+	return {
+		...result,
+		errors: result.errors.map(normalizeBindingError),
+		warnings: result.warnings.map((w) => w.field0)
+	};
+}
+/**
+* Transpile a JavaScript or TypeScript into a target ECMAScript version.
+*
+* @param filename The name of the file being transformed. If this is a
+* relative path, consider setting the {@linkcode TransformOptions#cwd} option.
+* @param sourceText The source code to transform.
+* @param options The transform options including tsconfig and inputMap. See {@linkcode TransformOptions} for more information.
+* @param cache Optional tsconfig cache for reusing resolved tsconfig across multiple transforms.
+* Only used when `options.tsconfig` is `true`.
+*
+* @returns an object containing the transformed code, source maps, and any errors
+* that occurred during parsing or transformation.
+*
+* @category Utilities
+* @experimental
+*/
+function transformSync(filename, sourceText, options, cache) {
+	const result = (0, import_binding.enhancedTransformSync)(filename, sourceText, options, cache, yarnPnp$1);
+	return {
+		...result,
+		errors: result.errors.map(normalizeBindingError),
+		warnings: result.warnings.map((w) => w.field0)
+	};
+}
+//#endregion
+//#region src/utils/resolve-tsconfig.ts
+const yarnPnp = typeof process === "object" && !!process.versions?.pnp;
+/**
+* Cache for tsconfig resolution to avoid redundant file system operations.
+*
+* The cache stores resolved tsconfig configurations keyed by their file paths.
+* When transforming multiple files in the same project, tsconfig lookups are
+* deduplicated, improving performance.
+*
+* @category Utilities
+* @experimental
+*/
+var TsconfigCache = class extends import_binding.TsconfigCache {
+	constructor() {
+		super(yarnPnp);
+	}
+};
+/** @hidden This is only expected to be used by Vite */
+function resolveTsconfig(filename, cache) {
+	return (0, import_binding.resolveTsconfig)(filename, cache, yarnPnp);
+}
+//#endregion
+export { minify as a, transformSync as i, resolveTsconfig as n, minifySync as o, transform as r, TsconfigCache as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/rolldown-CWsV1rrO.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/rolldown-CWsV1rrO.mjs
new file mode 100644
index 0000000..9ee9511
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/rolldown-CWsV1rrO.mjs
@@ -0,0 +1,40 @@
+import { c as validateOption, t as RolldownBuild, u as PluginDriver } from "./rolldown-build-BVD3dIdE.mjs";
+//#region src/api/rolldown/index.ts
+/**
+* The API compatible with Rollup's `rollup` function.
+*
+* Unlike Rollup, the module graph is not built until the methods of the bundle object are called.
+*
+* @param input The input options object.
+* @returns A Promise that resolves to a bundle object.
+*
+* @example
+* ```js
+* import { rolldown } from 'rolldown';
+*
+* let bundle, failed = false;
+* try {
+*   bundle = await rolldown({
+*     input: 'src/main.js',
+*   });
+*   await bundle.write({
+*     format: 'esm',
+*   });
+* } catch (e) {
+*   console.error(e);
+*   failed = true;
+* }
+* if (bundle) {
+*   await bundle.close();
+* }
+* process.exitCode = failed ? 1 : 0;
+* ```
+*
+* @category Programmatic APIs
+*/
+const rolldown = async (input) => {
+	validateOption("input", input);
+	return new RolldownBuild(await PluginDriver.callOptionsHook(input));
+};
+//#endregion
+export { rolldown as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/rolldown-build-BVD3dIdE.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/rolldown-build-BVD3dIdE.mjs
new file mode 100644
index 0000000..9dc70f4
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/rolldown-build-BVD3dIdE.mjs
@@ -0,0 +1,3283 @@
+import { n as __toESM, t as require_binding } from "./binding-C9S351wt.mjs";
+import { i as logInputHookInOutputPlugin, n as error } from "./logs-D80CXhvg.mjs";
+import { n as BuiltinPlugin } from "./normalize-string-or-regex-C-WttzRA.mjs";
+import { c as __decorate, d as PlainObjectLike, f as MinimalPluginContextImpl, h as LOG_LEVEL_DEBUG, i as transformModuleInfo, l as transformAssetSource, m as normalizeLog, o as transformToRollupOutput, p as normalizeHook, s as transformRenderedChunk, t as bindingifyInputOptions, u as lazyProp, v as LOG_LEVEL_WARN, x as VERSION, y as logLevelPriority } from "./bindingify-input-options-BnfFBV6b.mjs";
+import { i as unimplemented } from "./misc-DJYbNKZX.mjs";
+import { i as unwrapBindingResult } from "./error-CkdMJ9ps.mjs";
+import { Worker } from "node:worker_threads";
+import path, { sep } from "node:path";
+import { formatWithOptions, styleText } from "node:util";
+import process$1 from "node:process";
+import * as tty from "node:tty";
+import os from "node:os";
+//#region src/log/logger.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+function getLogger(plugins, onLog, logLevel, watchMode) {
+	const minimalPriority = logLevelPriority[logLevel];
+	const logger = (level, log, skipped = /* @__PURE__ */ new Set()) => {
+		if (logLevelPriority[level] < minimalPriority) return;
+		for (const plugin of getSortedPlugins("onLog", plugins)) {
+			if (skipped.has(plugin)) continue;
+			const { onLog: pluginOnLog } = plugin;
+			if (pluginOnLog) {
+				const getLogHandler = (level) => {
+					if (logLevelPriority[level] < minimalPriority) return () => {};
+					return (log) => logger(level, normalizeLog(log), new Set(skipped).add(plugin));
+				};
+				if (("handler" in pluginOnLog ? pluginOnLog.handler : pluginOnLog).call({
+					debug: getLogHandler("debug"),
+					error: (log) => error(normalizeLog(log)),
+					info: getLogHandler("info"),
+					meta: {
+						rollupVersion: "4.23.0",
+						rolldownVersion: VERSION,
+						watchMode
+					},
+					warn: getLogHandler("warn"),
+					pluginName: plugin.name || "unknown"
+				}, level, log) === false) return;
+			}
+		}
+		onLog(level, log);
+	};
+	return logger;
+}
+const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
+	const { onwarn, onLog } = config;
+	const defaultOnLog = getDefaultOnLog(printLog, onwarn);
+	if (onLog) {
+		const minimalPriority = logLevelPriority[logLevel];
+		return (level, log) => onLog(level, addLogToString(log), (level, handledLog) => {
+			if (level === "error") return error(normalizeLog(handledLog));
+			if (logLevelPriority[level] >= minimalPriority) defaultOnLog(level, normalizeLog(handledLog));
+		});
+	}
+	return defaultOnLog;
+};
+const getDefaultOnLog = (printLog, onwarn) => onwarn ? (level, log) => {
+	if (level === "warn") onwarn(addLogToString(log), (warning) => printLog(LOG_LEVEL_WARN, normalizeLog(warning)));
+	else printLog(level, log);
+} : printLog;
+const addLogToString = (log) => {
+	Object.defineProperty(log, "toString", {
+		value: () => getExtendedLogMessage(log),
+		writable: true
+	});
+	return log;
+};
+const defaultPrintLog = (level, log) => {
+	const message = getExtendedLogMessage(log);
+	switch (level) {
+		case LOG_LEVEL_WARN: return console.warn(message);
+		case LOG_LEVEL_DEBUG: return console.debug(message);
+		default: return console.info(message);
+	}
+};
+const getExtendedLogMessage = (log) => {
+	let prefix = "";
+	if (log.plugin) prefix += `(${log.plugin} plugin) `;
+	if (log.loc) prefix += `${relativeId(log.loc.file)} (${log.loc.line}:${log.loc.column}) `;
+	return prefix + log.message;
+};
+function relativeId(id) {
+	if (!path.isAbsolute(id)) return id;
+	return path.relative(path.resolve(), id);
+}
+//#endregion
+//#region src/constants/plugin.ts
+const ENUMERATED_INPUT_PLUGIN_HOOK_NAMES = [
+	"options",
+	"buildStart",
+	"resolveId",
+	"load",
+	"transform",
+	"moduleParsed",
+	"buildEnd",
+	"onLog",
+	"resolveDynamicImport",
+	"closeBundle",
+	"closeWatcher",
+	"watchChange"
+];
+const ENUMERATED_OUTPUT_PLUGIN_HOOK_NAMES = [
+	"augmentChunkHash",
+	"outputOptions",
+	"renderChunk",
+	"renderStart",
+	"renderError",
+	"writeBundle",
+	"generateBundle"
+];
+const ENUMERATED_PLUGIN_HOOK_NAMES = [
+	...ENUMERATED_INPUT_PLUGIN_HOOK_NAMES,
+	...ENUMERATED_OUTPUT_PLUGIN_HOOK_NAMES,
+	"footer",
+	"banner",
+	"intro",
+	"outro"
+];
+ENUMERATED_PLUGIN_HOOK_NAMES[0], ENUMERATED_PLUGIN_HOOK_NAMES[0], ENUMERATED_PLUGIN_HOOK_NAMES[1], ENUMERATED_PLUGIN_HOOK_NAMES[1], ENUMERATED_PLUGIN_HOOK_NAMES[2], ENUMERATED_PLUGIN_HOOK_NAMES[2], ENUMERATED_PLUGIN_HOOK_NAMES[3], ENUMERATED_PLUGIN_HOOK_NAMES[3], ENUMERATED_PLUGIN_HOOK_NAMES[4], ENUMERATED_PLUGIN_HOOK_NAMES[4], ENUMERATED_PLUGIN_HOOK_NAMES[5], ENUMERATED_PLUGIN_HOOK_NAMES[5], ENUMERATED_PLUGIN_HOOK_NAMES[6], ENUMERATED_PLUGIN_HOOK_NAMES[6], ENUMERATED_PLUGIN_HOOK_NAMES[7], ENUMERATED_PLUGIN_HOOK_NAMES[7], ENUMERATED_PLUGIN_HOOK_NAMES[8], ENUMERATED_PLUGIN_HOOK_NAMES[8], ENUMERATED_PLUGIN_HOOK_NAMES[9], ENUMERATED_PLUGIN_HOOK_NAMES[9], ENUMERATED_PLUGIN_HOOK_NAMES[10], ENUMERATED_PLUGIN_HOOK_NAMES[10], ENUMERATED_PLUGIN_HOOK_NAMES[11], ENUMERATED_PLUGIN_HOOK_NAMES[11], ENUMERATED_PLUGIN_HOOK_NAMES[12], ENUMERATED_PLUGIN_HOOK_NAMES[12], ENUMERATED_PLUGIN_HOOK_NAMES[13], ENUMERATED_PLUGIN_HOOK_NAMES[13], ENUMERATED_PLUGIN_HOOK_NAMES[14], ENUMERATED_PLUGIN_HOOK_NAMES[14], ENUMERATED_PLUGIN_HOOK_NAMES[15], ENUMERATED_PLUGIN_HOOK_NAMES[15], ENUMERATED_PLUGIN_HOOK_NAMES[16], ENUMERATED_PLUGIN_HOOK_NAMES[16], ENUMERATED_PLUGIN_HOOK_NAMES[17], ENUMERATED_PLUGIN_HOOK_NAMES[17], ENUMERATED_PLUGIN_HOOK_NAMES[18], ENUMERATED_PLUGIN_HOOK_NAMES[18], ENUMERATED_PLUGIN_HOOK_NAMES[19], ENUMERATED_PLUGIN_HOOK_NAMES[19], ENUMERATED_PLUGIN_HOOK_NAMES[20], ENUMERATED_PLUGIN_HOOK_NAMES[20], ENUMERATED_PLUGIN_HOOK_NAMES[21], ENUMERATED_PLUGIN_HOOK_NAMES[21], ENUMERATED_PLUGIN_HOOK_NAMES[22], ENUMERATED_PLUGIN_HOOK_NAMES[22];
+//#endregion
+//#region src/utils/async-flatten.ts
+async function asyncFlatten(array) {
+	do
+		array = (await Promise.all(array)).flat(Infinity);
+	while (array.some((v) => v?.then));
+	return array;
+}
+//#endregion
+//#region src/utils/normalize-plugin-option.ts
+const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
+function checkOutputPluginOption(plugins, onLog) {
+	for (const plugin of plugins) for (const hook of ENUMERATED_INPUT_PLUGIN_HOOK_NAMES) if (hook in plugin) {
+		delete plugin[hook];
+		onLog(LOG_LEVEL_WARN, logInputHookInOutputPlugin(plugin.name, hook));
+	}
+	return plugins;
+}
+function normalizePlugins(plugins, anonymousPrefix) {
+	for (const [index, plugin] of plugins.entries()) {
+		if ("_parallel" in plugin) continue;
+		if (plugin instanceof BuiltinPlugin) continue;
+		if (!plugin.name) plugin.name = `${anonymousPrefix}${index + 1}`;
+	}
+	return plugins;
+}
+const ANONYMOUS_PLUGIN_PREFIX = "at position ";
+const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = "at output position ";
+//#endregion
+//#region src/plugin/plugin-driver.ts
+var PluginDriver = class {
+	static async callOptionsHook(inputOptions, watchMode = false) {
+		const logLevel = inputOptions.logLevel || "info";
+		const plugins = getSortedPlugins("options", getObjectPlugins(await normalizePluginOption(inputOptions.plugins)));
+		const logger = getLogger(plugins, getOnLog(inputOptions, logLevel), logLevel, watchMode);
+		for (const plugin of plugins) {
+			const name = plugin.name || "unknown";
+			const options = plugin.options;
+			if (options) {
+				const { handler } = normalizeHook(options);
+				const result = await handler.call(new MinimalPluginContextImpl(logger, logLevel, name, watchMode, "onLog"), inputOptions);
+				if (result) inputOptions = result;
+			}
+		}
+		return inputOptions;
+	}
+	static callOutputOptionsHook(rawPlugins, outputOptions, onLog, logLevel, watchMode) {
+		const sortedPlugins = getSortedPlugins("outputOptions", getObjectPlugins(rawPlugins));
+		for (const plugin of sortedPlugins) {
+			const name = plugin.name || "unknown";
+			const options = plugin.outputOptions;
+			if (options) {
+				const { handler } = normalizeHook(options);
+				const result = handler.call(new MinimalPluginContextImpl(onLog, logLevel, name, watchMode), outputOptions);
+				if (result) outputOptions = result;
+			}
+		}
+		return outputOptions;
+	}
+};
+function getObjectPlugins(plugins) {
+	return plugins.filter((plugin) => {
+		if (!plugin) return;
+		if ("_parallel" in plugin) return;
+		if (plugin instanceof BuiltinPlugin) return;
+		return plugin;
+	});
+}
+function getSortedPlugins(hookName, plugins) {
+	const pre = [];
+	const normal = [];
+	const post = [];
+	for (const plugin of plugins) {
+		const hook = plugin[hookName];
+		if (hook) {
+			if (typeof hook === "object") {
+				if (hook.order === "pre") {
+					pre.push(plugin);
+					continue;
+				}
+				if (hook.order === "post") {
+					post.push(plugin);
+					continue;
+				}
+			}
+			normal.push(plugin);
+		}
+	}
+	return [
+		...pre,
+		...normal,
+		...post
+	];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/valibot@1.4.0_typescript@6.0.3/node_modules/valibot/dist/index.mjs
+let store$4;
+const DEFAULT_CONFIG = {
+	lang: void 0,
+	message: void 0,
+	abortEarly: void 0,
+	abortPipeEarly: void 0
+};
+/**
+* Returns the global configuration.
+*
+* @param config The config to merge.
+*
+* @returns The configuration.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config$1) {
+	if (!config$1 && true) return DEFAULT_CONFIG;
+	return {
+		lang: config$1?.lang ?? store$4?.lang,
+		message: config$1?.message,
+		abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+		abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+	};
+}
+let store$3;
+/**
+* Returns a global error message.
+*
+* @param lang The language of the message.
+*
+* @returns The error message.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalMessage(lang) {
+	return store$3?.get(lang);
+}
+let store$2;
+/**
+* Returns a schema error message.
+*
+* @param lang The language of the message.
+*
+* @returns The error message.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getSchemaMessage(lang) {
+	return store$2?.get(lang);
+}
+let store$1;
+/**
+* Returns a specific error message.
+*
+* @param reference The identifier reference.
+* @param lang The language of the message.
+*
+* @returns The error message.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getSpecificMessage(reference, lang) {
+	return store$1?.get(reference)?.get(lang);
+}
+/**
+* Stringifies an unknown input to a literal or type string.
+*
+* @param input The unknown input.
+*
+* @returns A literal or type string.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _stringify(input) {
+	const type = typeof input;
+	if (type === "string") return `"${input}"`;
+	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+	return type;
+}
+/**
+* Adds an issue to the dataset.
+*
+* @param context The issue context.
+* @param label The issue label.
+* @param dataset The input dataset.
+* @param config The configuration.
+* @param other The optional props.
+*
+* @internal
+*/
+function _addIssue(context, label, dataset, config$1, other) {
+	const input = other && "input" in other ? other.input : dataset.value;
+	const expected = other?.expected ?? context.expects ?? null;
+	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+	const issue = {
+		kind: context.kind,
+		type: context.type,
+		input,
+		expected,
+		received,
+		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+		requirement: context.requirement,
+		path: other?.path,
+		issues: other?.issues,
+		lang: config$1.lang,
+		abortEarly: config$1.abortEarly,
+		abortPipeEarly: config$1.abortPipeEarly
+	};
+	const isSchema = context.kind === "schema";
+	const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+	if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+	if (isSchema) dataset.typed = false;
+	if (dataset.issues) dataset.issues.push(issue);
+	else dataset.issues = [issue];
+}
+const _standardCache = /* @__PURE__ */ new WeakMap();
+/**
+* Returns the Standard Schema properties.
+*
+* @param context The schema context.
+*
+* @returns The Standard Schema properties.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _getStandardProps(context) {
+	let cached = _standardCache.get(context);
+	if (!cached) {
+		cached = {
+			version: 1,
+			vendor: "valibot",
+			validate(value$1) {
+				return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+			}
+		};
+		_standardCache.set(context, cached);
+	}
+	return cached;
+}
+/**
+* Disallows inherited object properties and prevents object prototype
+* pollution by disallowing certain keys.
+*
+* @param object The object to check.
+* @param key The key to check.
+*
+* @returns Whether the key is allowed.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _isValidObjectKey(object$1, key) {
+	return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+/**
+* Joins multiple `expects` values with the given separator.
+*
+* @param values The `expects` values.
+* @param separator The separator.
+*
+* @returns The joined `expects` property.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _joinExpects(values$1, separator) {
+	const list = [...new Set(values$1)];
+	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+	return list[0] ?? "never";
+}
+/**
+* A Valibot error with useful information.
+*/
+var ValiError = class extends Error {
+	/**
+	* Creates a Valibot error with useful information.
+	*
+	* @param issues The error issues.
+	*/
+	constructor(issues) {
+		super(issues[0].message);
+		this.name = "ValiError";
+		this.issues = issues;
+	}
+};
+/* @__NO_SIDE_EFFECTS__ */
+function args(schema) {
+	return {
+		kind: "transformation",
+		type: "args",
+		reference: args,
+		async: false,
+		schema,
+		"~run"(dataset, config$1) {
+			const func = dataset.value;
+			dataset.value = (...args_) => {
+				const argsDataset = this.schema["~run"]({ value: args_ }, config$1);
+				if (argsDataset.issues) throw new ValiError(argsDataset.issues);
+				return func(...argsDataset.value);
+			};
+			return dataset;
+		}
+	};
+}
+/**
+* Creates an await transformation action.
+*
+* @returns An await action.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function awaitAsync() {
+	return {
+		kind: "transformation",
+		type: "await",
+		reference: awaitAsync,
+		async: true,
+		async "~run"(dataset) {
+			dataset.value = await dataset.value;
+			return dataset;
+		}
+	};
+}
+/**
+* Creates a description metadata action.
+*
+* @param description_ The description text.
+*
+* @returns A description action.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function description(description_) {
+	return {
+		kind: "metadata",
+		type: "description",
+		reference: description,
+		description: description_
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function returns(schema) {
+	return {
+		kind: "transformation",
+		type: "returns",
+		reference: returns,
+		async: false,
+		schema,
+		"~run"(dataset, config$1) {
+			const func = dataset.value;
+			dataset.value = (...args_) => {
+				const returnsDataset = this.schema["~run"]({ value: func(...args_) }, config$1);
+				if (returnsDataset.issues) throw new ValiError(returnsDataset.issues);
+				return returnsDataset.value;
+			};
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function returnsAsync(schema) {
+	return {
+		kind: "transformation",
+		type: "returns",
+		reference: returnsAsync,
+		async: false,
+		schema,
+		"~run"(dataset, config$1) {
+			const func = dataset.value;
+			dataset.value = async (...args_) => {
+				const returnsDataset = await this.schema["~run"]({ value: await func(...args_) }, config$1);
+				if (returnsDataset.issues) throw new ValiError(returnsDataset.issues);
+				return returnsDataset.value;
+			};
+			return dataset;
+		}
+	};
+}
+const ABORT_EARLY_CONFIG = { abortEarly: true };
+/**
+* Returns the fallback value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The output dataset if available.
+* @param config The config if available.
+*
+* @returns The fallback value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getFallback(schema, dataset, config$1) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+/**
+* Returns the default value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The input dataset if available.
+* @param config The config if available.
+*
+* @returns The default value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config$1) {
+	return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+/**
+* Checks if the input matches the schema. By using a type predicate, this
+* function can be used as a type guard.
+*
+* @param schema The schema to be used.
+* @param input The input to be tested.
+*
+* @returns Whether the input matches the schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function is(schema, input) {
+	return !schema["~run"]({ value: input }, ABORT_EARLY_CONFIG).issues;
+}
+/**
+* Creates an any schema.
+*
+* Hint: This schema function exists only for completeness and is not
+* recommended in practice. Instead, `unknown` should be used to accept
+* unknown data.
+*
+* @returns An any schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function any() {
+	return {
+		kind: "schema",
+		type: "any",
+		reference: any,
+		expects: "any",
+		async: false,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset) {
+			dataset.typed = true;
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function array(item, message$1) {
+	return {
+		kind: "schema",
+		type: "array",
+		reference: array,
+		expects: "Array",
+		async: false,
+		item,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < input.length; key++) {
+					const value$1 = input[key];
+					const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value$1
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(message$1) {
+	return {
+		kind: "schema",
+		type: "boolean",
+		reference: boolean,
+		expects: "boolean",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "boolean") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function custom(check$1, message$1) {
+	return {
+		kind: "schema",
+		type: "custom",
+		reference: custom,
+		expects: "unknown",
+		async: false,
+		check: check$1,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (this.check(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function function_(message$1) {
+	return {
+		kind: "schema",
+		type: "function",
+		reference: function_,
+		expects: "Function",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "function") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function instance(class_, message$1) {
+	return {
+		kind: "schema",
+		type: "instance",
+		reference: instance,
+		expects: class_.name,
+		async: false,
+		class: class_,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value instanceof this.class) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function literal(literal_, message$1) {
+	return {
+		kind: "schema",
+		type: "literal",
+		reference: literal,
+		expects: /* @__PURE__ */ _stringify(literal_),
+		async: false,
+		literal: literal_,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === this.literal) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function never(message$1) {
+	return {
+		kind: "schema",
+		type: "never",
+		reference: never,
+		expects: "never",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			_addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function nullish(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "nullish",
+		reference: nullish,
+		expects: `(${wrapped.expects} | null | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === null || dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+				if (dataset.value === null || dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config$1);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function number(message$1) {
+	return {
+		kind: "schema",
+		type: "number",
+		reference: number,
+		expects: "number",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function object(entries$1, message$1) {
+	return {
+		kind: "schema",
+		type: "object",
+		reference: object,
+		expects: "Object",
+		async: false,
+		entries: entries$1,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value$1
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config$1.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config$1, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config$1.abortEarly) break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function optional(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "optional",
+		reference: optional,
+		expects: `(${wrapped.expects} | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+				if (dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config$1);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function picklist(options, message$1) {
+	return {
+		kind: "schema",
+		type: "picklist",
+		reference: picklist,
+		expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+		async: false,
+		options,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (this.options.includes(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function promise(message$1) {
+	return {
+		kind: "schema",
+		type: "promise",
+		reference: promise,
+		expects: "Promise",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value instanceof Promise) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function record(key, value$1, message$1) {
+	return {
+		kind: "schema",
+		type: "record",
+		reference: record,
+		expects: "Object",
+		async: false,
+		key,
+		value: value$1,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+					const entryValue = input[entryKey];
+					const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
+					if (keyDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "key",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						for (const issue of keyDataset.issues) {
+							issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = keyDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
+					if (valueDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "value",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						for (const issue of valueDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = valueDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+					if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function strictObject(entries$1, message$1) {
+	return {
+		kind: "schema",
+		type: "strict_object",
+		reference: strictObject,
+		expects: "Object",
+		async: false,
+		entries: entries$1,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value$1
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config$1.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config$1, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config$1.abortEarly) break;
+					}
+				}
+				if (!dataset.issues || !config$1.abortEarly) {
+					for (const key in input) if (!(key in this.entries)) {
+						_addIssue(this, "key", dataset, config$1, {
+							input: key,
+							expected: "never",
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function string(message$1) {
+	return {
+		kind: "schema",
+		type: "string",
+		reference: string,
+		expects: "string",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "string") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function tuple(items, message$1) {
+	return {
+		kind: "schema",
+		type: "tuple",
+		reference: tuple,
+		expects: "Array",
+		async: false,
+		items,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < this.items.length; key++) {
+					const value$1 = input[key];
+					const itemDataset = this.items[key]["~run"]({ value: value$1 }, config$1);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value$1
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function undefined_(message$1) {
+	return {
+		kind: "schema",
+		type: "undefined",
+		reference: undefined_,
+		expects: "undefined",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === void 0) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/**
+* Returns the sub issues of the provided datasets for the union issue.
+*
+* @param datasets The datasets.
+*
+* @returns The sub issues.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _subIssues(datasets) {
+	let issues;
+	if (datasets) for (const dataset of datasets) if (issues) for (const issue of dataset.issues) issues.push(issue);
+	else issues = dataset.issues;
+	return issues;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function union(options, message$1) {
+	return {
+		kind: "schema",
+		type: "union",
+		reference: union,
+		expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+		async: false,
+		options,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			let validDataset;
+			let typedDatasets;
+			let untypedDatasets;
+			for (const schema of this.options) {
+				const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
+				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+				else typedDatasets = [optionDataset];
+				else {
+					validDataset = optionDataset;
+					break;
+				}
+				else if (untypedDatasets) untypedDatasets.push(optionDataset);
+				else untypedDatasets = [optionDataset];
+			}
+			if (validDataset) return validDataset;
+			if (typedDatasets) {
+				if (typedDatasets.length === 1) return typedDatasets[0];
+				_addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+				dataset.typed = true;
+			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+			else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function unionAsync(options, message$1) {
+	return {
+		kind: "schema",
+		type: "union",
+		reference: unionAsync,
+		expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+		async: true,
+		options,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		async "~run"(dataset, config$1) {
+			let validDataset;
+			let typedDatasets;
+			let untypedDatasets;
+			for (const schema of this.options) {
+				const optionDataset = await schema["~run"]({ value: dataset.value }, config$1);
+				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+				else typedDatasets = [optionDataset];
+				else {
+					validDataset = optionDataset;
+					break;
+				}
+				else if (untypedDatasets) untypedDatasets.push(optionDataset);
+				else untypedDatasets = [optionDataset];
+			}
+			if (validDataset) return validDataset;
+			if (typedDatasets) {
+				if (typedDatasets.length === 1) return typedDatasets[0];
+				_addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+				dataset.typed = true;
+			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+			else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function void_(message$1) {
+	return {
+		kind: "schema",
+		type: "void",
+		reference: void_,
+		expects: "void",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (dataset.value === void 0) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function keyof(schema, message$1) {
+	return /* @__PURE__ */ picklist(Object.keys(schema.entries), message$1);
+}
+/**
+* Creates a modified copy of an object schema that does not contain the
+* selected entries.
+*
+* @param schema The schema to omit from.
+* @param keys The selected entries.
+*
+* @returns An object schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function omit(schema, keys) {
+	const entries$1 = { ...schema.entries };
+	for (const key of keys) delete entries$1[key];
+	return {
+		...schema,
+		entries: entries$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function partial(schema, keys) {
+	const entries$1 = {};
+	for (const key in schema.entries) entries$1[key] = !keys || keys.includes(key) ? /* @__PURE__ */ optional(schema.entries[key]) : schema.entries[key];
+	return {
+		...schema,
+		entries: entries$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function pipe(...pipe$1) {
+	return {
+		...pipe$1[0],
+		pipe: pipe$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			for (const item of pipe$1) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+			}
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function pipeAsync(...pipe$1) {
+	return {
+		...pipe$1[0],
+		pipe: pipe$1,
+		async: true,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		async "~run"(dataset, config$1) {
+			for (const item of pipe$1) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = await item["~run"](dataset, config$1);
+			}
+			return dataset;
+		}
+	};
+}
+/**
+* Parses an unknown input based on a schema.
+*
+* @param schema The schema to be used.
+* @param input The input to be parsed.
+* @param config The parse configuration.
+*
+* @returns The parse result.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function safeParse(schema, input, config$1) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+	return {
+		typed: dataset.typed,
+		success: !dataset.issues,
+		output: dataset.value,
+		issues: dataset.issues
+	};
+}
+//#endregion
+//#region src/utils/flatten-valibot-schema.ts
+function unwrapSchema(schema) {
+	if (!schema) return schema;
+	if (schema.type === "optional" && schema.wrapped) return unwrapSchema(schema.wrapped);
+	if (schema.type === "nullable" && schema.wrapped) return unwrapSchema(schema.wrapped);
+	if (schema.type === "nullish" && schema.wrapped) return unwrapSchema(schema.wrapped);
+	return schema;
+}
+function getValibotSchemaType(schema) {
+	if (!schema) return "any";
+	if (schema.type) switch (schema.type) {
+		case "string": return "string";
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "array": return "array";
+		case "object":
+		case "strict_object":
+		case "loose_object": return "object";
+		case "union": return "union";
+		case "literal": return typeof schema.literal;
+		case "record": return "object";
+		case "optional": return getValibotSchemaType(schema.wrapped);
+		case "nullable": return getValibotSchemaType(schema.wrapped);
+		case "nullish": return getValibotSchemaType(schema.wrapped);
+		case "never": return "never";
+		case "any": return "any";
+		case "custom": return "any";
+		case "function": return "never";
+		case "instance": return "object";
+		default: return "any";
+	}
+	return "any";
+}
+function getValibotDescription(schema) {
+	if (!schema) return void 0;
+	if (schema.pipe && Array.isArray(schema.pipe)) {
+		for (const action of schema.pipe) if (action.type === "description" && action.description) return action.description;
+	}
+	if (schema.type === "optional" && schema.wrapped) return getValibotDescription(schema.wrapped);
+}
+function flattenValibotSchema(schema, result = {}, prefix = "") {
+	if (!schema || typeof schema !== "object") return result;
+	if (schema.type === "strict_object" || schema.type === "object" || schema.type === "loose_object") {
+		if (schema.entries && typeof schema.entries === "object") for (const [key, value] of Object.entries(schema.entries)) {
+			const fullKey = prefix ? `${prefix}.${key}` : key;
+			const valueSchema = value;
+			const type = getValibotSchemaType(valueSchema);
+			const description = getValibotDescription(valueSchema);
+			if (type === "object") {
+				const unwrappedSchema = unwrapSchema(valueSchema);
+				if (unwrappedSchema && unwrappedSchema.entries) flattenValibotSchema(unwrappedSchema, result, fullKey);
+				else result[fullKey] = {
+					type,
+					description
+				};
+			} else result[fullKey] = {
+				type,
+				description
+			};
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/utils/style-text.ts
+/**
+* Cross-platform styleText utility that works in both Node.js and browser environments
+* In Node.js, it uses the native `styleText` from `node:util`
+* In browser, it provides empty styling functions for compatibility
+*/
+function styleText$1(...args) {
+	return styleText(...args);
+}
+//#endregion
+//#region src/utils/validator.ts
+const StringOrRegExpSchema = /* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ instance(RegExp)]);
+function vFunction() {
+	return /* @__PURE__ */ function_();
+}
+const LogLevelSchema = /* @__PURE__ */ union([
+	/* @__PURE__ */ literal("debug"),
+	/* @__PURE__ */ literal("info"),
+	/* @__PURE__ */ literal("warn")
+]);
+const LogLevelOptionSchema = /* @__PURE__ */ union([LogLevelSchema, /* @__PURE__ */ literal("silent")]);
+const LogLevelWithErrorSchema = /* @__PURE__ */ union([LogLevelSchema, /* @__PURE__ */ literal("error")]);
+const RollupLogSchema = /* @__PURE__ */ any();
+const RollupLogWithStringSchema = /* @__PURE__ */ union([RollupLogSchema, /* @__PURE__ */ string()]);
+const InputOptionSchema = /* @__PURE__ */ union([
+	/* @__PURE__ */ string(),
+	/* @__PURE__ */ array(/* @__PURE__ */ string()),
+	/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ string())
+]);
+const ExternalOptionFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([
+	/* @__PURE__ */ string(),
+	/* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	/* @__PURE__ */ boolean()
+])), /* @__PURE__ */ returns(/* @__PURE__ */ nullish(/* @__PURE__ */ boolean())));
+const ExternalOptionSchema = /* @__PURE__ */ union([
+	StringOrRegExpSchema,
+	/* @__PURE__ */ array(StringOrRegExpSchema),
+	ExternalOptionFunctionSchema
+]);
+const ModuleTypesSchema = /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([
+	/* @__PURE__ */ literal("asset"),
+	/* @__PURE__ */ literal("base64"),
+	/* @__PURE__ */ literal("binary"),
+	/* @__PURE__ */ literal("copy"),
+	/* @__PURE__ */ literal("css"),
+	/* @__PURE__ */ literal("dataurl"),
+	/* @__PURE__ */ literal("empty"),
+	/* @__PURE__ */ literal("js"),
+	/* @__PURE__ */ literal("json"),
+	/* @__PURE__ */ literal("jsx"),
+	/* @__PURE__ */ literal("text"),
+	/* @__PURE__ */ literal("ts"),
+	/* @__PURE__ */ literal("tsx")
+]));
+const TransformOptionsSchema = /* @__PURE__ */ object({
+	assumptions: /* @__PURE__ */ optional(/* @__PURE__ */ object({
+		ignoreFunctionLength: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		noDocumentAll: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		objectRestNoSymbols: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		pureGetters: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		setPublicClassFields: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+	})),
+	typescript: /* @__PURE__ */ optional(/* @__PURE__ */ object({
+		jsxPragma: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+		jsxPragmaFrag: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+		onlyRemoveTypeImports: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		allowNamespaces: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		allowDeclareFields: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		removeClassFieldsWithoutInitializer: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		optimizeConstEnums: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		optimizeEnums: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		declaration: /* @__PURE__ */ optional(/* @__PURE__ */ object({
+			stripInternal: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+			sourcemap: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+		})),
+		rewriteImportExtensions: /* @__PURE__ */ optional(/* @__PURE__ */ union([
+			/* @__PURE__ */ literal("rewrite"),
+			/* @__PURE__ */ literal("remove"),
+			/* @__PURE__ */ boolean()
+		]))
+	})),
+	helpers: /* @__PURE__ */ optional(/* @__PURE__ */ object({ mode: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ literal("Runtime"), /* @__PURE__ */ literal("External")])) })),
+	decorator: /* @__PURE__ */ optional(/* @__PURE__ */ object({
+		legacy: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		emitDecoratorMetadata: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+	})),
+	jsx: /* @__PURE__ */ optional(/* @__PURE__ */ union([
+		/* @__PURE__ */ literal(false),
+		/* @__PURE__ */ literal("preserve"),
+		/* @__PURE__ */ literal("react"),
+		/* @__PURE__ */ literal("react-jsx"),
+		/* @__PURE__ */ strictObject({
+			runtime: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ literal("classic"), /* @__PURE__ */ literal("automatic")])), /* @__PURE__ */ description("Which runtime to use")),
+			development: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Development specific information")),
+			throwIfNamespace: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Toggles whether to throw an error when a tag name uses an XML namespace")),
+			pure: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Mark JSX elements and top-level React method calls as pure for tree shaking.")),
+			importSource: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Import the factory of element and fragment if mode is classic")),
+			pragma: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Jsx element transformation")),
+			pragmaFrag: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Jsx fragment transformation")),
+			refresh: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ any()])), /* @__PURE__ */ description("Enable react fast refresh"))
+		})
+	])),
+	target: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ array(/* @__PURE__ */ string())])), /* @__PURE__ */ description("The JavaScript target environment")),
+	define: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ string())), /* @__PURE__ */ description("Define global variables (syntax: key:value,key2:value2)")),
+	inject: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ tuple([/* @__PURE__ */ string(), /* @__PURE__ */ string()])]))), /* @__PURE__ */ description("Inject import statements on demand")),
+	dropLabels: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())), /* @__PURE__ */ description("Remove labeled statements with these label names")),
+	plugins: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ object({
+		styledComponents: /* @__PURE__ */ optional(/* @__PURE__ */ any()),
+		taggedTemplateEscape: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+	})), /* @__PURE__ */ description("Third-party plugins to use"))
+});
+const WatcherFileWatcherOptionsSchema = /* @__PURE__ */ strictObject({
+	usePolling: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Use polling-based file watching instead of native OS events")),
+	pollInterval: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ number()), /* @__PURE__ */ description("Poll interval in milliseconds (only used when usePolling is true)")),
+	compareContentsForPolling: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Compare file contents for poll-based watchers (only used when usePolling is true)")),
+	useDebounce: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Use debounced event delivery at the filesystem level")),
+	debounceDelay: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ number()), /* @__PURE__ */ description("Debounce delay in milliseconds (only used when useDebounce is true)")),
+	debounceTickRate: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ number()), /* @__PURE__ */ description("Tick rate in milliseconds for debouncer (only used when useDebounce is true)"))
+});
+const WatcherOptionsSchema = /* @__PURE__ */ strictObject({
+	chokidar: /* @__PURE__ */ optional(/* @__PURE__ */ never(`The "watch.chokidar" option is deprecated, please use "watch.watcher" instead of it`)),
+	exclude: /* @__PURE__ */ optional(/* @__PURE__ */ union([StringOrRegExpSchema, /* @__PURE__ */ array(StringOrRegExpSchema)])),
+	include: /* @__PURE__ */ optional(/* @__PURE__ */ union([StringOrRegExpSchema, /* @__PURE__ */ array(StringOrRegExpSchema)])),
+	watcher: /* @__PURE__ */ optional(WatcherFileWatcherOptionsSchema),
+	notify: /* @__PURE__ */ optional(WatcherFileWatcherOptionsSchema),
+	skipWrite: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Skip the bundle.write() step")),
+	buildDelay: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ number()), /* @__PURE__ */ description("Throttle watch rebuilds")),
+	clearScreen: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to clear the screen when a rebuild is triggered")),
+	onInvalidate: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(vFunction()), /* @__PURE__ */ description("An optional function that will be called immediately every time a module changes that is part of the build."))
+});
+const ChecksOptionsSchema = /* @__PURE__ */ strictObject({
+	circularDependency: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when detecting circular dependency")),
+	eval: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when detecting uses of direct `eval`s")),
+	missingGlobalName: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when the `output.globals` option is missing when needed")),
+	missingNameOptionForIifeExport: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when the `output.name` option is missing when needed")),
+	mixedExports: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when the way to export values is ambiguous")),
+	unresolvedEntry: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when an entrypoint cannot be resolved")),
+	unresolvedImport: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when an import cannot be resolved")),
+	filenameConflict: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when files generated have the same name with different contents")),
+	commonJsVariableInEsm: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when a CommonJS variable is used in an ES module")),
+	importIsUndefined: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when an imported variable is not exported")),
+	emptyImportMeta: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when `import.meta` is not supported with the output format and is replaced with an empty object (`{}`)")),
+	toleratedTransform: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when detecting tolerated transform")),
+	cannotCallNamespace: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when a namespace is called as a function")),
+	configurationFieldConflict: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when a config value is overridden by another config value with a higher priority")),
+	preferBuiltinFeature: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when a plugin that is covered by a built-in feature is used")),
+	couldNotCleanDirectory: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when Rolldown could not clean the output directory")),
+	pluginTimings: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when plugins take significant time during the build process")),
+	duplicateShebang: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when both the code and postBanner contain shebang")),
+	unsupportedTsconfigOption: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when a tsconfig option or combination of options is not supported")),
+	ineffectiveDynamicImport: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit warnings when a module is dynamically imported but also statically imported, making the dynamic import ineffective for code splitting")),
+	largeBarrelModules: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to emit info logs when a barrel module has a very large number of re-exports (more than 5000)"))
+});
+const MinifyOptionsSchema = /* @__PURE__ */ strictObject({
+	compress: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ strictObject({
+		target: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ array(/* @__PURE__ */ string())])),
+		dropConsole: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		dropDebugger: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		keepNames: /* @__PURE__ */ optional(/* @__PURE__ */ strictObject({
+			function: /* @__PURE__ */ boolean(),
+			class: /* @__PURE__ */ boolean()
+		})),
+		unused: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ literal("keep_assign")])),
+		joinVars: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		sequences: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		dropLabels: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
+		maxIterations: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		treeshake: /* @__PURE__ */ optional(/* @__PURE__ */ strictObject({
+			annotations: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+			manualPureFunctions: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
+			propertyReadSideEffects: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ literal("always")])),
+			propertyWriteSideEffects: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+			unknownGlobalSideEffects: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+			invalidImportSideEffects: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+		}))
+	})])),
+	mangle: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ strictObject({
+		toplevel: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		keepNames: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ strictObject({
+			function: /* @__PURE__ */ boolean(),
+			class: /* @__PURE__ */ boolean()
+		})])),
+		debug: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+	})])),
+	codegen: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ strictObject({ removeWhitespace: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()) })]))
+});
+const ResolveOptionsSchema = /* @__PURE__ */ strictObject({
+	alias: /* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([
+		/* @__PURE__ */ literal(false),
+		/* @__PURE__ */ string(),
+		/* @__PURE__ */ array(/* @__PURE__ */ string())
+	]))),
+	aliasFields: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ array(/* @__PURE__ */ string()))),
+	conditionNames: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
+	extensionAlias: /* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ array(/* @__PURE__ */ string()))),
+	exportsFields: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ array(/* @__PURE__ */ string()))),
+	extensions: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
+	mainFields: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
+	mainFiles: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
+	modules: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
+	symlinks: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	tsconfigFilename: /* @__PURE__ */ optional(/* @__PURE__ */ string())
+});
+const TreeshakingOptionsSchema = /* @__PURE__ */ strictObject({
+	moduleSideEffects: /* @__PURE__ */ optional(/* @__PURE__ */ any()),
+	annotations: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	manualPureFunctions: /* @__PURE__ */ optional(/* @__PURE__ */ custom((input) => /* @__PURE__ */ is(/* @__PURE__ */ array(/* @__PURE__ */ string()), input), "string array")),
+	unknownGlobalSideEffects: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	invalidImportSideEffects: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	commonjs: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	propertyReadSideEffects: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ literal(false), /* @__PURE__ */ literal("always")])),
+	propertyWriteSideEffects: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ literal(false), /* @__PURE__ */ literal("always")]))
+});
+const OptimizationOptionsSchema = /* @__PURE__ */ strictObject({
+	inlineConst: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ strictObject({
+		mode: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ literal("all"), /* @__PURE__ */ literal("smart")])),
+		pass: /* @__PURE__ */ optional(/* @__PURE__ */ number())
+	})])), /* @__PURE__ */ description("Enable crossmodule constant inlining")),
+	pifeForModuleWrappers: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Use PIFE pattern for module wrappers"))
+});
+const LogOrStringHandlerSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])));
+const OnLogSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([
+	LogLevelSchema,
+	RollupLogSchema,
+	LogOrStringHandlerSchema
+])));
+const OnwarnSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([RollupLogSchema, /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ union([RollupLogWithStringSchema, /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ returns(RollupLogWithStringSchema))])])))])));
+const DevModeSchema = /* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ strictObject({
+	port: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+	host: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	implement: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	lazy: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+})]);
+const InputOptionsSchema = /* @__PURE__ */ strictObject({
+	input: /* @__PURE__ */ optional(InputOptionSchema),
+	plugins: /* @__PURE__ */ optional(/* @__PURE__ */ custom(() => true)),
+	external: /* @__PURE__ */ optional(ExternalOptionSchema),
+	makeAbsoluteExternalsRelative: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ literal("ifRelativeSource")])),
+	resolve: /* @__PURE__ */ optional(ResolveOptionsSchema),
+	cwd: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Current working directory")),
+	platform: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([
+		/* @__PURE__ */ literal("browser"),
+		/* @__PURE__ */ literal("neutral"),
+		/* @__PURE__ */ literal("node")
+	])), /* @__PURE__ */ description(`Platform for which the code should be generated (node, ${styleText$1("underline", "browser")}, neutral)`)),
+	shimMissingExports: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Create shim variables for missing exports")),
+	treeshake: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), TreeshakingOptionsSchema])),
+	optimization: /* @__PURE__ */ optional(OptimizationOptionsSchema),
+	logLevel: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(LogLevelOptionSchema), /* @__PURE__ */ description(`Log level (${styleText$1("dim", "silent")}, ${styleText$1(["underline", "gray"], "info")}, debug, ${styleText$1("yellow", "warn")})`)),
+	onLog: /* @__PURE__ */ optional(OnLogSchema),
+	onwarn: /* @__PURE__ */ optional(OnwarnSchema),
+	moduleTypes: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(ModuleTypesSchema), /* @__PURE__ */ description("Module types for customized extensions")),
+	experimental: /* @__PURE__ */ optional(/* @__PURE__ */ strictObject({
+		viteMode: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		resolveNewUrlToAsset: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		devMode: /* @__PURE__ */ optional(DevModeSchema),
+		chunkModulesOrder: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ literal("module-id"), /* @__PURE__ */ literal("exec-order")])),
+		attachDebugInfo: /* @__PURE__ */ optional(/* @__PURE__ */ union([
+			/* @__PURE__ */ literal("none"),
+			/* @__PURE__ */ literal("simple"),
+			/* @__PURE__ */ literal("full")
+		])),
+		chunkImportMap: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
+			baseUrl: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+			fileName: /* @__PURE__ */ optional(/* @__PURE__ */ string())
+		})])),
+		onDemandWrapping: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		incrementalBuild: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		nativeMagicString: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		chunkOptimization: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ strictObject({
+			mergeCommonChunks: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+			avoidRedundantChunkLoads: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+		})])),
+		lazyBarrel: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+	})),
+	transform: /* @__PURE__ */ optional(TransformOptionsSchema),
+	watch: /* @__PURE__ */ optional(/* @__PURE__ */ union([WatcherOptionsSchema, /* @__PURE__ */ literal(false)])),
+	checks: /* @__PURE__ */ optional(ChecksOptionsSchema),
+	devtools: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ object({ sessionId: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Used to name the build.")) })), /* @__PURE__ */ description("Enable debug mode. Emit debug information to disk. This might slow down the build process significantly.")),
+	preserveEntrySignatures: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([
+		/* @__PURE__ */ literal("strict"),
+		/* @__PURE__ */ literal("allow-extension"),
+		/* @__PURE__ */ literal("exports-only"),
+		/* @__PURE__ */ literal(false)
+	]))),
+	context: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("The value of `this` at the top level of each module.")),
+	tsconfig: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ string()])), /* @__PURE__ */ description("Path to the tsconfig.json file."))
+});
+const InputCliOverrideSchema = /* @__PURE__ */ strictObject({
+	input: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())), /* @__PURE__ */ description("Entry file")),
+	external: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string())), /* @__PURE__ */ description("Comma-separated list of module ids to exclude from the bundle `<module-id>,...`")),
+	treeshake: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("enable treeshaking")),
+	makeAbsoluteExternalsRelative: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Prevent normalization of external imports")),
+	preserveEntrySignatures: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ literal(false)), /* @__PURE__ */ description("Avoid facade chunks for entry points")),
+	context: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("The entity top-level `this` represents."))
+});
+const InputCliOptionsSchema = /* @__PURE__ */ omit(/* @__PURE__ */ strictObject({
+	...InputOptionsSchema.entries,
+	...InputCliOverrideSchema.entries
+}), [
+	"plugins",
+	"onwarn",
+	"onLog",
+	"resolve",
+	"experimental",
+	"watch"
+]);
+const ModuleFormatSchema = /* @__PURE__ */ union([
+	/* @__PURE__ */ literal("es"),
+	/* @__PURE__ */ literal("cjs"),
+	/* @__PURE__ */ literal("esm"),
+	/* @__PURE__ */ literal("module"),
+	/* @__PURE__ */ literal("commonjs"),
+	/* @__PURE__ */ literal("iife"),
+	/* @__PURE__ */ literal("umd")
+]);
+const AddonFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ custom(() => true)])), /* @__PURE__ */ returnsAsync(/* @__PURE__ */ unionAsync([/* @__PURE__ */ string(), /* @__PURE__ */ pipeAsync(/* @__PURE__ */ promise(), /* @__PURE__ */ awaitAsync(), /* @__PURE__ */ string())])));
+const ChunkFileNamesFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ custom(() => true)])), /* @__PURE__ */ returns(/* @__PURE__ */ string()));
+const ChunkFileNamesSchema = /* @__PURE__ */ union([/* @__PURE__ */ string(), ChunkFileNamesFunctionSchema]);
+const AssetFileNamesFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ custom(() => true)])), /* @__PURE__ */ returns(/* @__PURE__ */ string()));
+const AssetFileNamesSchema = /* @__PURE__ */ union([/* @__PURE__ */ string(), AssetFileNamesFunctionSchema]);
+const SanitizeFileNameFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ string()])), /* @__PURE__ */ returns(/* @__PURE__ */ string()));
+const SanitizeFileNameSchema = /* @__PURE__ */ union([/* @__PURE__ */ boolean(), SanitizeFileNameFunctionSchema]);
+const GlobalsFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ string()])), /* @__PURE__ */ returns(/* @__PURE__ */ string()));
+const PathsFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ string()])), /* @__PURE__ */ returns(/* @__PURE__ */ string()));
+const ManualChunksFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ string(), /* @__PURE__ */ object({})])), /* @__PURE__ */ returns(/* @__PURE__ */ nullish(/* @__PURE__ */ string())));
+const AdvancedChunksNameFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ string(), /* @__PURE__ */ object({})])), /* @__PURE__ */ returns(/* @__PURE__ */ nullish(/* @__PURE__ */ string())));
+const AdvancedChunksTestFunctionSchema = /* @__PURE__ */ pipe(vFunction(), /* @__PURE__ */ args(/* @__PURE__ */ tuple([/* @__PURE__ */ string()])), /* @__PURE__ */ returns(/* @__PURE__ */ union([
+	/* @__PURE__ */ boolean(),
+	/* @__PURE__ */ void_(),
+	/* @__PURE__ */ undefined_()
+])));
+const AdvancedChunksSchema = /* @__PURE__ */ strictObject({
+	includeDependenciesRecursively: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+	minSize: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+	maxSize: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+	minModuleSize: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+	maxModuleSize: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+	minShareCount: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+	groups: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ strictObject({
+		name: /* @__PURE__ */ union([/* @__PURE__ */ string(), AdvancedChunksNameFunctionSchema]),
+		test: /* @__PURE__ */ optional(/* @__PURE__ */ union([StringOrRegExpSchema, AdvancedChunksTestFunctionSchema])),
+		priority: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		minSize: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		minShareCount: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		maxSize: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		minModuleSize: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		maxModuleSize: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		entriesAware: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		entriesAwareMergeThreshold: /* @__PURE__ */ optional(/* @__PURE__ */ number()),
+		tags: /* @__PURE__ */ optional(/* @__PURE__ */ array(/* @__PURE__ */ string()))
+	})))
+});
+const GeneratedCodeOptionsSchema = /* @__PURE__ */ strictObject({
+	symbols: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to use Symbol.toStringTag for namespace objects")),
+	preset: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ literal("es5"), /* @__PURE__ */ literal("es2015")])),
+	profilerNames: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Whether to add readable names to internal variables for profiling purposes"))
+});
+const OutputOptionsSchema = /* @__PURE__ */ strictObject({
+	dir: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Output directory, defaults to `dist` if `file` is not set")),
+	file: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Single output file")),
+	exports: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([
+		/* @__PURE__ */ literal("auto"),
+		/* @__PURE__ */ literal("named"),
+		/* @__PURE__ */ literal("default"),
+		/* @__PURE__ */ literal("none")
+	])), /* @__PURE__ */ description(`Specify a export mode (${styleText$1("underline", "auto")}, named, default, none)`)),
+	hashCharacters: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([
+		/* @__PURE__ */ literal("base64"),
+		/* @__PURE__ */ literal("base36"),
+		/* @__PURE__ */ literal("hex")
+	])), /* @__PURE__ */ description("Use the specified character set for file hashes")),
+	format: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(ModuleFormatSchema), /* @__PURE__ */ description(`Output format of the generated bundle (supports ${styleText$1("underline", "esm")}, cjs, and iife)`)),
+	sourcemap: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([
+		/* @__PURE__ */ boolean(),
+		/* @__PURE__ */ literal("inline"),
+		/* @__PURE__ */ literal("hidden")
+	])), /* @__PURE__ */ description(`Generate sourcemap (\`-s inline\` for inline, or \`-s\` for \`.map\` file)`)),
+	sourcemapBaseUrl: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Base URL used to prefix sourcemap paths")),
+	sourcemapDebugIds: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Inject sourcemap debug IDs")),
+	sourcemapExcludeSources: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Exclude source content from sourcemaps")),
+	sourcemapIgnoreList: /* @__PURE__ */ optional(/* @__PURE__ */ union([
+		/* @__PURE__ */ boolean(),
+		/* @__PURE__ */ custom(() => true),
+		StringOrRegExpSchema
+	])),
+	sourcemapPathTransform: /* @__PURE__ */ optional(/* @__PURE__ */ custom(() => true)),
+	banner: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), AddonFunctionSchema])),
+	footer: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), AddonFunctionSchema])),
+	postBanner: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), AddonFunctionSchema])),
+	postFooter: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), AddonFunctionSchema])),
+	intro: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), AddonFunctionSchema])),
+	outro: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), AddonFunctionSchema])),
+	extend: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Extend global variable defined by name in IIFE / UMD formats")),
+	esModule: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ literal("if-default-prop")])),
+	assetFileNames: /* @__PURE__ */ optional(AssetFileNamesSchema),
+	entryFileNames: /* @__PURE__ */ optional(ChunkFileNamesSchema),
+	chunkFileNames: /* @__PURE__ */ optional(ChunkFileNamesSchema),
+	sanitizeFileName: /* @__PURE__ */ optional(SanitizeFileNameSchema),
+	minify: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([
+		/* @__PURE__ */ boolean(),
+		/* @__PURE__ */ literal("dce-only"),
+		MinifyOptionsSchema
+	])), /* @__PURE__ */ description("Minify the bundled file")),
+	name: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Name for UMD / IIFE format outputs")),
+	globals: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ string()), GlobalsFunctionSchema])), /* @__PURE__ */ description("Global variable of UMD / IIFE dependencies (syntax: `key:value`)")),
+	paths: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ string()), PathsFunctionSchema])), /* @__PURE__ */ description("Maps external module IDs to paths")),
+	generatedCode: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ partial(GeneratedCodeOptionsSchema)), /* @__PURE__ */ description("Generated code options")),
+	externalLiveBindings: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("external live bindings")),
+	inlineDynamicImports: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Inline dynamic imports")),
+	dynamicImportInCjs: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Dynamic import in CJS output")),
+	manualChunks: /* @__PURE__ */ optional(ManualChunksFunctionSchema),
+	codeSplitting: /* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), AdvancedChunksSchema])),
+	advancedChunks: /* @__PURE__ */ optional(AdvancedChunksSchema),
+	legalComments: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ literal("none"), /* @__PURE__ */ literal("inline")])), /* @__PURE__ */ description("Control legal comments in the output")),
+	comments: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ strictObject({
+		legal: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		annotation: /* @__PURE__ */ optional(/* @__PURE__ */ boolean()),
+		jsdoc: /* @__PURE__ */ optional(/* @__PURE__ */ boolean())
+	})])), /* @__PURE__ */ description("Control comments in the output")),
+	plugins: /* @__PURE__ */ optional(/* @__PURE__ */ custom(() => true)),
+	polyfillRequire: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Disable require polyfill injection")),
+	hoistTransitiveImports: /* @__PURE__ */ optional(/* @__PURE__ */ literal(false)),
+	preserveModules: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Preserve module structure")),
+	preserveModulesRoot: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Put preserved modules under this path at root level")),
+	virtualDirname: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	minifyInternalExports: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Minify internal exports")),
+	topLevelVar: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Rewrite top-level declarations to use `var`.")),
+	cleanDir: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Clean output directory before emitting output")),
+	keepNames: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Keep function and class names after bundling")),
+	strictExecutionOrder: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Lets modules be executed in the order they are declared.")),
+	strict: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ literal("auto")])), /* @__PURE__ */ description("Whether to always output `\"use strict\"` directive in non-ES module outputs."))
+});
+const getAddonDescription = (placement, wrapper) => {
+	return `Code to insert the ${styleText$1("bold", placement)} of the bundled file (${styleText$1("bold", wrapper)} the wrapper function)`;
+};
+const OutputCliOverrideSchema = /* @__PURE__ */ strictObject({
+	assetFileNames: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Name pattern for asset files")),
+	entryFileNames: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Name pattern for emitted entry chunks")),
+	chunkFileNames: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("Name pattern for emitted secondary chunks")),
+	sanitizeFileName: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Sanitize file name")),
+	banner: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description(getAddonDescription("top", "outside"))),
+	footer: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description(getAddonDescription("bottom", "outside"))),
+	postBanner: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("A string to prepend to the top of each chunk. Applied after the `renderChunk` hook and minification")),
+	postFooter: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description("A string to append to the bottom of each chunk. Applied after the `renderChunk` hook and minification")),
+	intro: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description(getAddonDescription("top", "inside"))),
+	outro: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ string()), /* @__PURE__ */ description(getAddonDescription("bottom", "inside"))),
+	esModule: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Always generate `__esModule` marks in non-ESM formats, defaults to `if-default-prop` (use `--no-esModule` to always disable)")),
+	globals: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ string())), /* @__PURE__ */ description("Global variable of UMD / IIFE dependencies (syntax: `key:value`)")),
+	codeSplitting: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ strictObject({
+		minSize: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ number()), /* @__PURE__ */ description("Minimum size of the chunk")),
+		minShareCount: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ number()), /* @__PURE__ */ description("Minimum share count of the chunk"))
+	})])), /* @__PURE__ */ description("Code splitting options (true, false, or object)")),
+	advancedChunks: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ strictObject({
+		minSize: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ number()), /* @__PURE__ */ description("Minimum size of the chunk")),
+		minShareCount: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ number()), /* @__PURE__ */ description("Minimum share count of the chunk"))
+	})), /* @__PURE__ */ description("Deprecated: use codeSplitting instead")),
+	minify: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Minify the bundled file"))
+});
+const OutputCliOptionsSchema = /* @__PURE__ */ omit(/* @__PURE__ */ strictObject({
+	...OutputOptionsSchema.entries,
+	...OutputCliOverrideSchema.entries
+}), [
+	"sourcemapIgnoreList",
+	"sourcemapPathTransform",
+	"plugins",
+	"hoistTransitiveImports"
+]);
+const CliOptionsSchema = /* @__PURE__ */ strictObject({
+	config: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ boolean()])), /* @__PURE__ */ description("Path to the config file (default: `rolldown.config.js`)")),
+	help: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Show help")),
+	environment: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ array(/* @__PURE__ */ string())])), /* @__PURE__ */ description("Pass additional settings to the config file via process.ENV.")),
+	version: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Show version number")),
+	watch: /* @__PURE__ */ pipe(/* @__PURE__ */ optional(/* @__PURE__ */ boolean()), /* @__PURE__ */ description("Watch files in bundle and rebuild on changes")),
+	...InputCliOptionsSchema.entries,
+	...OutputCliOptionsSchema.entries
+});
+function validateCliOptions(options) {
+	let parsed = /* @__PURE__ */ safeParse(CliOptionsSchema, options);
+	return [parsed.output, parsed.issues?.map((issue) => {
+		return `Invalid value for option ${issue.path?.map((pathItem) => pathItem.key).join(" ")}: ${issue.message}`;
+	})];
+}
+const inputHelperMsgRecord = {
+	output: { ignored: true },
+	"resolve.tsconfigFilename": { issueMsg: "It is deprecated. Please use the top-level `tsconfig` option instead." }
+};
+const outputHelperMsgRecord = {};
+function validateOption(key, options) {
+	if (typeof options !== "object") throw new Error(`Invalid ${key} options. Expected an Object but received ${JSON.stringify(options)}.`);
+	if (globalThis.process?.env?.ROLLUP_TEST) return;
+	let parsed = /* @__PURE__ */ safeParse(key === "input" ? InputOptionsSchema : OutputOptionsSchema, options);
+	if (!parsed.success) {
+		const errors = parsed.issues.map((issue) => {
+			let issueMsg = issue.message;
+			const issuePaths = issue.path.map((path) => path.key);
+			if (issue.type === "union") {
+				const subIssue = issue.issues?.find((i) => !(i.type !== issue.received && i.input === issue.input));
+				if (subIssue) {
+					if (subIssue.path) issuePaths.push(subIssue.path.map((path) => path.key));
+					issueMsg = subIssue.message;
+				}
+			}
+			const stringPath = issuePaths.join(".");
+			const helper = key === "input" ? inputHelperMsgRecord[stringPath] : outputHelperMsgRecord[stringPath];
+			if (helper && helper.ignored) return "";
+			return `- For the "${stringPath}". ${helper?.issueMsg || issueMsg + "."} ${helper?.help ? `\n  Help: ${helper.help}` : ""}`;
+		}).filter(Boolean);
+		if (errors.length) console.warn(`\x1b[33mWarning: Invalid ${key} options (${errors.length} issue${errors.length === 1 ? "" : "s"} found)\n${errors.join("\n")}\x1b[0m`);
+	}
+}
+function getInputCliKeys() {
+	return (/* @__PURE__ */ keyof(InputCliOptionsSchema)).options;
+}
+function getOutputCliKeys() {
+	return (/* @__PURE__ */ keyof(OutputCliOptionsSchema)).options;
+}
+function getCliSchemaInfo() {
+	return flattenValibotSchema(CliOptionsSchema);
+}
+//#endregion
+//#region src/types/rolldown-output-impl.ts
+var RolldownOutputImpl = class extends PlainObjectLike {
+	bindingOutputs;
+	constructor(bindingOutputs) {
+		super();
+		this.bindingOutputs = bindingOutputs;
+	}
+	get output() {
+		return transformToRollupOutput(this.bindingOutputs).output;
+	}
+	__rolldown_external_memory_handle__(keepDataAlive) {
+		const results = this.output.map((item) => item.__rolldown_external_memory_handle__(keepDataAlive));
+		if (!results.every((r) => r.freed)) {
+			const reasons = results.filter((r) => !r.freed).map((r) => r.reason).filter(Boolean);
+			return {
+				freed: false,
+				reason: `Failed to free ${reasons.length} item(s): ${reasons.join("; ")}`
+			};
+		}
+		return { freed: true };
+	}
+};
+__decorate([lazyProp], RolldownOutputImpl.prototype, "output", null);
+//#endregion
+//#region src/types/chunking-context.ts
+var ChunkingContextImpl = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	getModuleInfo(moduleId) {
+		const bindingInfo = this.context.getModuleInfo(moduleId);
+		if (bindingInfo) return transformModuleInfo(bindingInfo, {
+			moduleSideEffects: null,
+			meta: {}
+		});
+		return null;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/core.mjs
+const LogLevels = {
+	silent: Number.NEGATIVE_INFINITY,
+	fatal: 0,
+	error: 0,
+	warn: 1,
+	log: 2,
+	info: 3,
+	success: 3,
+	fail: 3,
+	ready: 3,
+	start: 3,
+	box: 3,
+	debug: 4,
+	trace: 5,
+	verbose: Number.POSITIVE_INFINITY
+};
+const LogTypes = {
+	silent: { level: -1 },
+	fatal: { level: LogLevels.fatal },
+	error: { level: LogLevels.error },
+	warn: { level: LogLevels.warn },
+	log: { level: LogLevels.log },
+	info: { level: LogLevels.info },
+	success: { level: LogLevels.success },
+	fail: { level: LogLevels.fail },
+	ready: { level: LogLevels.info },
+	start: { level: LogLevels.info },
+	box: { level: LogLevels.info },
+	debug: { level: LogLevels.debug },
+	trace: { level: LogLevels.trace },
+	verbose: { level: LogLevels.verbose }
+};
+function isPlainObject$1(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+	if (!isPlainObject$1(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = Object.assign({}, defaults);
+	for (const key in baseObject) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger && merger(object, key, value, namespace)) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject$1(value) && isPlainObject$1(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+}
+function createDefu(merger) {
+	return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+}
+const defu = createDefu();
+function isPlainObject(obj) {
+	return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function isLogObj(arg) {
+	if (!isPlainObject(arg)) return false;
+	if (!arg.message && !arg.args) return false;
+	if (arg.stack) return false;
+	return true;
+}
+let paused = false;
+const queue = [];
+var Consola = class Consola {
+	options;
+	_lastLog;
+	_mockFn;
+	/**
+	* Creates an instance of Consola with specified options or defaults.
+	*
+	* @param {Partial<ConsolaOptions>} [options={}] - Configuration options for the Consola instance.
+	*/
+	constructor(options = {}) {
+		const types = options.types || LogTypes;
+		this.options = defu({
+			...options,
+			defaults: { ...options.defaults },
+			level: _normalizeLogLevel(options.level, types),
+			reporters: [...options.reporters || []]
+		}, {
+			types: LogTypes,
+			throttle: 1e3,
+			throttleMin: 5,
+			formatOptions: {
+				date: true,
+				colors: false,
+				compact: true
+			}
+		});
+		for (const type in types) {
+			const defaults = {
+				type,
+				...this.options.defaults,
+				...types[type]
+			};
+			this[type] = this._wrapLogFn(defaults);
+			this[type].raw = this._wrapLogFn(defaults, true);
+		}
+		if (this.options.mockFn) this.mockTypes();
+		this._lastLog = {};
+	}
+	/**
+	* Gets the current log level of the Consola instance.
+	*
+	* @returns {number} The current log level.
+	*/
+	get level() {
+		return this.options.level;
+	}
+	/**
+	* Sets the minimum log level that will be output by the instance.
+	*
+	* @param {number} level - The new log level to set.
+	*/
+	set level(level) {
+		this.options.level = _normalizeLogLevel(level, this.options.types, this.options.level);
+	}
+	/**
+	* Displays a prompt to the user and returns the response.
+	* Throw an error if `prompt` is not supported by the current configuration.
+	*
+	* @template T
+	* @param {string} message - The message to display in the prompt.
+	* @param {T} [opts] - Optional options for the prompt. See {@link PromptOptions}.
+	* @returns {promise<T>} A promise that infer with the prompt options. See {@link PromptOptions}.
+	*/
+	prompt(message, opts) {
+		if (!this.options.prompt) throw new Error("prompt is not supported!");
+		return this.options.prompt(message, opts);
+	}
+	/**
+	* Creates a new instance of Consola, inheriting options from the current instance, with possible overrides.
+	*
+	* @param {Partial<ConsolaOptions>} options - Optional overrides for the new instance. See {@link ConsolaOptions}.
+	* @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+	*/
+	create(options) {
+		const instance = new Consola({
+			...this.options,
+			...options
+		});
+		if (this._mockFn) instance.mockTypes(this._mockFn);
+		return instance;
+	}
+	/**
+	* Creates a new Consola instance with the specified default log object properties.
+	*
+	* @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
+	* @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+	*/
+	withDefaults(defaults) {
+		return this.create({
+			...this.options,
+			defaults: {
+				...this.options.defaults,
+				...defaults
+			}
+		});
+	}
+	/**
+	* Creates a new Consola instance with a specified tag, which will be included in every log.
+	*
+	* @param {string} tag - The tag to include in each log of the new instance.
+	* @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+	*/
+	withTag(tag) {
+		return this.withDefaults({ tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag });
+	}
+	/**
+	* Adds a custom reporter to the Consola instance.
+	* Reporters will be called for each log message, depending on their implementation and log level.
+	*
+	* @param {ConsolaReporter} reporter - The reporter to add. See {@link ConsolaReporter}.
+	* @returns {Consola} The current Consola instance.
+	*/
+	addReporter(reporter) {
+		this.options.reporters.push(reporter);
+		return this;
+	}
+	/**
+	* Removes a custom reporter from the Consola instance.
+	* If no reporter is specified, all reporters will be removed.
+	*
+	* @param {ConsolaReporter} reporter - The reporter to remove. See {@link ConsolaReporter}.
+	* @returns {Consola} The current Consola instance.
+	*/
+	removeReporter(reporter) {
+		if (reporter) {
+			const i = this.options.reporters.indexOf(reporter);
+			if (i !== -1) return this.options.reporters.splice(i, 1);
+		} else this.options.reporters.splice(0);
+		return this;
+	}
+	/**
+	* Replaces all reporters of the Consola instance with the specified array of reporters.
+	*
+	* @param {ConsolaReporter[]} reporters - The new reporters to set. See {@link ConsolaReporter}.
+	* @returns {Consola} The current Consola instance.
+	*/
+	setReporters(reporters) {
+		this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];
+		return this;
+	}
+	wrapAll() {
+		this.wrapConsole();
+		this.wrapStd();
+	}
+	restoreAll() {
+		this.restoreConsole();
+		this.restoreStd();
+	}
+	/**
+	* Overrides console methods with Consola logging methods for consistent logging.
+	*/
+	wrapConsole() {
+		for (const type in this.options.types) {
+			if (!console["__" + type]) console["__" + type] = console[type];
+			console[type] = this[type].raw;
+		}
+	}
+	/**
+	* Restores the original console methods, removing Consola overrides.
+	*/
+	restoreConsole() {
+		for (const type in this.options.types) if (console["__" + type]) {
+			console[type] = console["__" + type];
+			delete console["__" + type];
+		}
+	}
+	/**
+	* Overrides standard output and error streams to redirect them through Consola.
+	*/
+	wrapStd() {
+		this._wrapStream(this.options.stdout, "log");
+		this._wrapStream(this.options.stderr, "log");
+	}
+	_wrapStream(stream, type) {
+		if (!stream) return;
+		if (!stream.__write) stream.__write = stream.write;
+		stream.write = (data) => {
+			this[type].raw(String(data).trim());
+		};
+	}
+	/**
+	* Restores the original standard output and error streams, removing the Consola redirection.
+	*/
+	restoreStd() {
+		this._restoreStream(this.options.stdout);
+		this._restoreStream(this.options.stderr);
+	}
+	_restoreStream(stream) {
+		if (!stream) return;
+		if (stream.__write) {
+			stream.write = stream.__write;
+			delete stream.__write;
+		}
+	}
+	/**
+	* Pauses logging, queues incoming logs until resumed.
+	*/
+	pauseLogs() {
+		paused = true;
+	}
+	/**
+	* Resumes logging, processing any queued logs.
+	*/
+	resumeLogs() {
+		paused = false;
+		const _queue = queue.splice(0);
+		for (const item of _queue) item[0]._logFn(item[1], item[2]);
+	}
+	/**
+	* Replaces logging methods with mocks if a mock function is provided.
+	*
+	* @param {ConsolaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link ConsolaOptions["mockFn"]}.
+	*/
+	mockTypes(mockFn) {
+		const _mockFn = mockFn || this.options.mockFn;
+		this._mockFn = _mockFn;
+		if (typeof _mockFn !== "function") return;
+		for (const type in this.options.types) {
+			this[type] = _mockFn(type, this.options.types[type]) || this[type];
+			this[type].raw = this[type];
+		}
+	}
+	_wrapLogFn(defaults, isRaw) {
+		return (...args) => {
+			if (paused) {
+				queue.push([
+					this,
+					defaults,
+					args,
+					isRaw
+				]);
+				return;
+			}
+			return this._logFn(defaults, args, isRaw);
+		};
+	}
+	_logFn(defaults, args, isRaw) {
+		if ((defaults.level || 0) > this.level) return false;
+		const logObj = {
+			date: /* @__PURE__ */ new Date(),
+			args: [],
+			...defaults,
+			level: _normalizeLogLevel(defaults.level, this.options.types)
+		};
+		if (!isRaw && args.length === 1 && isLogObj(args[0])) Object.assign(logObj, args[0]);
+		else logObj.args = [...args];
+		if (logObj.message) {
+			logObj.args.unshift(logObj.message);
+			delete logObj.message;
+		}
+		if (logObj.additional) {
+			if (!Array.isArray(logObj.additional)) logObj.additional = logObj.additional.split("\n");
+			logObj.args.push("\n" + logObj.additional.join("\n"));
+			delete logObj.additional;
+		}
+		logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
+		logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";
+		const resolveLog = (newLog = false) => {
+			const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
+			if (this._lastLog.object && repeated > 0) {
+				const args2 = [...this._lastLog.object.args];
+				if (repeated > 1) args2.push(`(repeated ${repeated} times)`);
+				this._log({
+					...this._lastLog.object,
+					args: args2
+				});
+				this._lastLog.count = 1;
+			}
+			if (newLog) {
+				this._lastLog.object = logObj;
+				this._log(logObj);
+			}
+		};
+		clearTimeout(this._lastLog.timeout);
+		const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
+		this._lastLog.time = logObj.date;
+		if (diffTime < this.options.throttle) try {
+			const serializedLog = JSON.stringify([
+				logObj.type,
+				logObj.tag,
+				logObj.args
+			]);
+			const isSameLog = this._lastLog.serialized === serializedLog;
+			this._lastLog.serialized = serializedLog;
+			if (isSameLog) {
+				this._lastLog.count = (this._lastLog.count || 0) + 1;
+				if (this._lastLog.count > this.options.throttleMin) {
+					this._lastLog.timeout = setTimeout(resolveLog, this.options.throttle);
+					return;
+				}
+			}
+		} catch {}
+		resolveLog(true);
+	}
+	_log(logObj) {
+		for (const reporter of this.options.reporters) reporter.log(logObj, { options: this.options });
+	}
+};
+function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
+	if (input === void 0) return defaultLevel;
+	if (typeof input === "number") return input;
+	if (types[input] && types[input].level !== void 0) return types[input].level;
+	return defaultLevel;
+}
+Consola.prototype.add = Consola.prototype.addReporter;
+Consola.prototype.remove = Consola.prototype.removeReporter;
+Consola.prototype.clear = Consola.prototype.removeReporter;
+Consola.prototype.withScope = Consola.prototype.withTag;
+Consola.prototype.mock = Consola.prototype.mockTypes;
+Consola.prototype.pause = Consola.prototype.pauseLogs;
+Consola.prototype.resume = Consola.prototype.resumeLogs;
+function createConsola$1(options = {}) {
+	return new Consola(options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/shared/consola.DRwqZj3T.mjs
+function parseStack(stack, message) {
+	const cwd = process.cwd() + sep;
+	return stack.split("\n").splice(message.split("\n").length).map((l) => l.trim().replace("file://", "").replace(cwd, ""));
+}
+function writeStream(data, stream) {
+	return (stream.__write || stream.write).call(stream, data);
+}
+const bracket = (x) => x ? `[${x}]` : "";
+var BasicReporter = class {
+	formatStack(stack, message, opts) {
+		const indent = "  ".repeat((opts?.errorLevel || 0) + 1);
+		return indent + parseStack(stack, message).join(`
+${indent}`);
+	}
+	formatError(err, opts) {
+		const message = err.message ?? formatWithOptions(opts, err);
+		const stack = err.stack ? this.formatStack(err.stack, message, opts) : "";
+		const level = opts?.errorLevel || 0;
+		const causedPrefix = level > 0 ? `${"  ".repeat(level)}[cause]: ` : "";
+		const causedError = err.cause ? "\n\n" + this.formatError(err.cause, {
+			...opts,
+			errorLevel: level + 1
+		}) : "";
+		return causedPrefix + message + "\n" + stack + causedError;
+	}
+	formatArgs(args, opts) {
+		return formatWithOptions(opts, ...args.map((arg) => {
+			if (arg && typeof arg.stack === "string") return this.formatError(arg, opts);
+			return arg;
+		}));
+	}
+	formatDate(date, opts) {
+		return opts.date ? date.toLocaleTimeString() : "";
+	}
+	filterAndJoin(arr) {
+		return arr.filter(Boolean).join(" ");
+	}
+	formatLogObj(logObj, opts) {
+		const message = this.formatArgs(logObj.args, opts);
+		if (logObj.type === "box") return "\n" + [
+			bracket(logObj.tag),
+			logObj.title && logObj.title,
+			...message.split("\n")
+		].filter(Boolean).map((l) => " > " + l).join("\n") + "\n";
+		return this.filterAndJoin([
+			bracket(logObj.type),
+			bracket(logObj.tag),
+			message
+		]);
+	}
+	log(logObj, ctx) {
+		return writeStream(this.formatLogObj(logObj, {
+			columns: ctx.options.stdout.columns || 0,
+			...ctx.options.formatOptions
+		}) + "\n", logObj.level < 2 ? ctx.options.stderr || process.stderr : ctx.options.stdout || process.stdout);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/shared/consola.DXBYu-KD.mjs
+const { env = {}, argv = [], platform = "" } = typeof process === "undefined" ? {} : process;
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isWindows = platform === "win32";
+const isDumbTerminal = env.TERM === "dumb";
+const isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+const isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+const isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+function replaceClose(index, string, close, replace, head = string.slice(0, Math.max(0, index)) + replace, tail = string.slice(Math.max(0, index + close.length)), next = tail.indexOf(close)) {
+	return head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+}
+function clearBleed(index, string, open, close, replace) {
+	return index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
+}
+function filterEmpty(open, close, replace = open, at = open.length + 1) {
+	return (string) => string || !(string === "" || string === void 0) ? clearBleed(("" + string).indexOf(close, at), string, open, close, replace) : "";
+}
+function init(open, close, replace) {
+	return filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
+}
+const colorDefs = {
+	reset: init(0, 0),
+	bold: init(1, 22, "\x1B[22m\x1B[1m"),
+	dim: init(2, 22, "\x1B[22m\x1B[2m"),
+	italic: init(3, 23),
+	underline: init(4, 24),
+	inverse: init(7, 27),
+	hidden: init(8, 28),
+	strikethrough: init(9, 29),
+	black: init(30, 39),
+	red: init(31, 39),
+	green: init(32, 39),
+	yellow: init(33, 39),
+	blue: init(34, 39),
+	magenta: init(35, 39),
+	cyan: init(36, 39),
+	white: init(37, 39),
+	gray: init(90, 39),
+	bgBlack: init(40, 49),
+	bgRed: init(41, 49),
+	bgGreen: init(42, 49),
+	bgYellow: init(43, 49),
+	bgBlue: init(44, 49),
+	bgMagenta: init(45, 49),
+	bgCyan: init(46, 49),
+	bgWhite: init(47, 49),
+	blackBright: init(90, 39),
+	redBright: init(91, 39),
+	greenBright: init(92, 39),
+	yellowBright: init(93, 39),
+	blueBright: init(94, 39),
+	magentaBright: init(95, 39),
+	cyanBright: init(96, 39),
+	whiteBright: init(97, 39),
+	bgBlackBright: init(100, 49),
+	bgRedBright: init(101, 49),
+	bgGreenBright: init(102, 49),
+	bgYellowBright: init(103, 49),
+	bgBlueBright: init(104, 49),
+	bgMagentaBright: init(105, 49),
+	bgCyanBright: init(106, 49),
+	bgWhiteBright: init(107, 49)
+};
+function createColors(useColor = isColorSupported) {
+	return useColor ? colorDefs : Object.fromEntries(Object.keys(colorDefs).map((key) => [key, String]));
+}
+const colors = createColors();
+function getColor$1(color, fallback = "reset") {
+	return colors[color] || colors[fallback];
+}
+const ansiRegex$1 = [String.raw`[\u001B\u009B][[\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*|[a-zA-Z\d]+(?:;[-a-zA-Z\d\/#&.:=?%@~_]*)*)?\u0007)`, String.raw`(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))`].join("|");
+function stripAnsi$1(text) {
+	return text.replace(new RegExp(ansiRegex$1, "g"), "");
+}
+const boxStylePresets = {
+	solid: {
+		tl: "┌",
+		tr: "┐",
+		bl: "└",
+		br: "┘",
+		h: "─",
+		v: "│"
+	},
+	double: {
+		tl: "╔",
+		tr: "╗",
+		bl: "╚",
+		br: "╝",
+		h: "═",
+		v: "║"
+	},
+	doubleSingle: {
+		tl: "╓",
+		tr: "╖",
+		bl: "╙",
+		br: "╜",
+		h: "─",
+		v: "║"
+	},
+	doubleSingleRounded: {
+		tl: "╭",
+		tr: "╮",
+		bl: "╰",
+		br: "╯",
+		h: "─",
+		v: "║"
+	},
+	singleThick: {
+		tl: "┏",
+		tr: "┓",
+		bl: "┗",
+		br: "┛",
+		h: "━",
+		v: "┃"
+	},
+	singleDouble: {
+		tl: "╒",
+		tr: "╕",
+		bl: "╘",
+		br: "╛",
+		h: "═",
+		v: "│"
+	},
+	singleDoubleRounded: {
+		tl: "╭",
+		tr: "╮",
+		bl: "╰",
+		br: "╯",
+		h: "═",
+		v: "│"
+	},
+	rounded: {
+		tl: "╭",
+		tr: "╮",
+		bl: "╰",
+		br: "╯",
+		h: "─",
+		v: "│"
+	}
+};
+const defaultStyle = {
+	borderColor: "white",
+	borderStyle: "rounded",
+	valign: "center",
+	padding: 2,
+	marginLeft: 1,
+	marginTop: 1,
+	marginBottom: 1
+};
+function box(text, _opts = {}) {
+	const opts = {
+		..._opts,
+		style: {
+			...defaultStyle,
+			..._opts.style
+		}
+	};
+	const textLines = text.split("\n");
+	const boxLines = [];
+	const _color = getColor$1(opts.style.borderColor);
+	const borderStyle = { ...typeof opts.style.borderStyle === "string" ? boxStylePresets[opts.style.borderStyle] || boxStylePresets.solid : opts.style.borderStyle };
+	if (_color) for (const key in borderStyle) borderStyle[key] = _color(borderStyle[key]);
+	const paddingOffset = opts.style.padding % 2 === 0 ? opts.style.padding : opts.style.padding + 1;
+	const height = textLines.length + paddingOffset;
+	const width = Math.max(...textLines.map((line) => stripAnsi$1(line).length), opts.title ? stripAnsi$1(opts.title).length : 0) + paddingOffset;
+	const widthOffset = width + paddingOffset;
+	const leftSpace = opts.style.marginLeft > 0 ? " ".repeat(opts.style.marginLeft) : "";
+	if (opts.style.marginTop > 0) boxLines.push("".repeat(opts.style.marginTop));
+	if (opts.title) {
+		const title = _color ? _color(opts.title) : opts.title;
+		const left = borderStyle.h.repeat(Math.floor((width - stripAnsi$1(opts.title).length) / 2));
+		const right = borderStyle.h.repeat(width - stripAnsi$1(opts.title).length - stripAnsi$1(left).length + paddingOffset);
+		boxLines.push(`${leftSpace}${borderStyle.tl}${left}${title}${right}${borderStyle.tr}`);
+	} else boxLines.push(`${leftSpace}${borderStyle.tl}${borderStyle.h.repeat(widthOffset)}${borderStyle.tr}`);
+	const valignOffset = opts.style.valign === "center" ? Math.floor((height - textLines.length) / 2) : opts.style.valign === "top" ? height - textLines.length - paddingOffset : height - textLines.length;
+	for (let i = 0; i < height; i++) if (i < valignOffset || i >= valignOffset + textLines.length) boxLines.push(`${leftSpace}${borderStyle.v}${" ".repeat(widthOffset)}${borderStyle.v}`);
+	else {
+		const line = textLines[i - valignOffset];
+		const left = " ".repeat(paddingOffset);
+		const right = " ".repeat(width - stripAnsi$1(line).length);
+		boxLines.push(`${leftSpace}${borderStyle.v}${left}${line}${right}${borderStyle.v}`);
+	}
+	boxLines.push(`${leftSpace}${borderStyle.bl}${borderStyle.h.repeat(widthOffset)}${borderStyle.br}`);
+	if (opts.style.marginBottom > 0) boxLines.push("".repeat(opts.style.marginBottom));
+	return boxLines.join("\n");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/index.mjs
+const r = Object.create(null), i = (e) => globalThis.process?.env || import.meta.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (e ? r : globalThis), o = new Proxy(r, {
+	get(e, s) {
+		return i()[s] ?? r[s];
+	},
+	has(e, s) {
+		return s in i() || s in r;
+	},
+	set(e, s, E) {
+		const B = i(true);
+		return B[s] = E, true;
+	},
+	deleteProperty(e, s) {
+		if (!s) return false;
+		const E = i(true);
+		return delete E[s], true;
+	},
+	ownKeys() {
+		const e = i(true);
+		return Object.keys(e);
+	}
+}), t = typeof process < "u" && process.env && process.env.NODE_ENV || "", f = [
+	["APPVEYOR"],
+	[
+		"AWS_AMPLIFY",
+		"AWS_APP_ID",
+		{ ci: true }
+	],
+	["AZURE_PIPELINES", "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI"],
+	["AZURE_STATIC", "INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN"],
+	["APPCIRCLE", "AC_APPCIRCLE"],
+	["BAMBOO", "bamboo_planKey"],
+	["BITBUCKET", "BITBUCKET_COMMIT"],
+	["BITRISE", "BITRISE_IO"],
+	["BUDDY", "BUDDY_WORKSPACE_ID"],
+	["BUILDKITE"],
+	["CIRCLE", "CIRCLECI"],
+	["CIRRUS", "CIRRUS_CI"],
+	[
+		"CLOUDFLARE_PAGES",
+		"CF_PAGES",
+		{ ci: true }
+	],
+	["CODEBUILD", "CODEBUILD_BUILD_ARN"],
+	["CODEFRESH", "CF_BUILD_ID"],
+	["DRONE"],
+	["DRONE", "DRONE_BUILD_EVENT"],
+	["DSARI"],
+	["GITHUB_ACTIONS"],
+	["GITLAB", "GITLAB_CI"],
+	["GITLAB", "CI_MERGE_REQUEST_ID"],
+	["GOCD", "GO_PIPELINE_LABEL"],
+	["LAYERCI"],
+	["HUDSON", "HUDSON_URL"],
+	["JENKINS", "JENKINS_URL"],
+	["MAGNUM"],
+	["NETLIFY"],
+	[
+		"NETLIFY",
+		"NETLIFY_LOCAL",
+		{ ci: false }
+	],
+	["NEVERCODE"],
+	["RENDER"],
+	["SAIL", "SAILCI"],
+	["SEMAPHORE"],
+	["SCREWDRIVER"],
+	["SHIPPABLE"],
+	["SOLANO", "TDDIUM"],
+	["STRIDER"],
+	["TEAMCITY", "TEAMCITY_VERSION"],
+	["TRAVIS"],
+	["VERCEL", "NOW_BUILDER"],
+	[
+		"VERCEL",
+		"VERCEL",
+		{ ci: false }
+	],
+	[
+		"VERCEL",
+		"VERCEL_ENV",
+		{ ci: false }
+	],
+	["APPCENTER", "APPCENTER_BUILD_ID"],
+	[
+		"CODESANDBOX",
+		"CODESANDBOX_SSE",
+		{ ci: false }
+	],
+	[
+		"CODESANDBOX",
+		"CODESANDBOX_HOST",
+		{ ci: false }
+	],
+	["STACKBLITZ"],
+	["STORMKIT"],
+	["CLEAVR"],
+	["ZEABUR"],
+	[
+		"CODESPHERE",
+		"CODESPHERE_APP_ID",
+		{ ci: true }
+	],
+	["RAILWAY", "RAILWAY_PROJECT_ID"],
+	["RAILWAY", "RAILWAY_SERVICE_ID"],
+	["DENO-DEPLOY", "DENO_DEPLOYMENT_ID"],
+	[
+		"FIREBASE_APP_HOSTING",
+		"FIREBASE_APP_HOSTING",
+		{ ci: true }
+	]
+];
+function b() {
+	if (globalThis.process?.env) for (const e of f) {
+		const s = e[1] || e[0];
+		if (globalThis.process?.env[s]) return {
+			name: e[0].toLowerCase(),
+			...e[2]
+		};
+	}
+	return globalThis.process?.env?.SHELL === "/bin/jsh" && globalThis.process?.versions?.webcontainer ? {
+		name: "stackblitz",
+		ci: false
+	} : {
+		name: "",
+		ci: false
+	};
+}
+const l = b();
+l.name;
+function n(e) {
+	return e ? e !== "false" : false;
+}
+const I = globalThis.process?.platform || "", T = n(o.CI) || l.ci !== false, a = n(globalThis.process?.stdout && globalThis.process?.stdout.isTTY), g = n(o.DEBUG), R = t === "test" || n(o.TEST);
+o.MINIMAL;
+const A = /^win/i.test(I);
+!n(o.NO_COLOR) && (n(o.FORCE_COLOR) || (a || A) && o.TERM);
+const C = (globalThis.process?.versions?.node || "").replace(/^v/, "") || null;
+Number(C?.split(".")[0]);
+const y = globalThis.process || Object.create(null), _ = { versions: {} };
+new Proxy(y, { get(e, s) {
+	if (s === "env") return o;
+	if (s in e) return e[s];
+	if (s in _) return _[s];
+} });
+const c = globalThis.process?.release?.name === "node", O = !!globalThis.Bun || !!globalThis.process?.versions?.bun, D = !!globalThis.Deno, L = !!globalThis.fastly, S = !!globalThis.Netlify, u = !!globalThis.EdgeRuntime, N = globalThis.navigator?.userAgent === "Cloudflare-Workers", F = [
+	[S, "netlify"],
+	[u, "edge-light"],
+	[N, "workerd"],
+	[L, "fastly"],
+	[D, "deno"],
+	[O, "bun"],
+	[c, "node"]
+];
+function G() {
+	const e = F.find((s) => s[0]);
+	if (e) return { name: e[1] };
+}
+G()?.name;
+function ansiRegex({ onlyFirst = false } = {}) {
+	const pattern = [`[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))`, "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");
+	return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+const regex = ansiRegex();
+function stripAnsi(string) {
+	if (typeof string !== "string") throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+	return string.replace(regex, "");
+}
+function isAmbiguous(x) {
+	return x === 161 || x === 164 || x === 167 || x === 168 || x === 170 || x === 173 || x === 174 || x >= 176 && x <= 180 || x >= 182 && x <= 186 || x >= 188 && x <= 191 || x === 198 || x === 208 || x === 215 || x === 216 || x >= 222 && x <= 225 || x === 230 || x >= 232 && x <= 234 || x === 236 || x === 237 || x === 240 || x === 242 || x === 243 || x >= 247 && x <= 250 || x === 252 || x === 254 || x === 257 || x === 273 || x === 275 || x === 283 || x === 294 || x === 295 || x === 299 || x >= 305 && x <= 307 || x === 312 || x >= 319 && x <= 322 || x === 324 || x >= 328 && x <= 331 || x === 333 || x === 338 || x === 339 || x === 358 || x === 359 || x === 363 || x === 462 || x === 464 || x === 466 || x === 468 || x === 470 || x === 472 || x === 474 || x === 476 || x === 593 || x === 609 || x === 708 || x === 711 || x >= 713 && x <= 715 || x === 717 || x === 720 || x >= 728 && x <= 731 || x === 733 || x === 735 || x >= 768 && x <= 879 || x >= 913 && x <= 929 || x >= 931 && x <= 937 || x >= 945 && x <= 961 || x >= 963 && x <= 969 || x === 1025 || x >= 1040 && x <= 1103 || x === 1105 || x === 8208 || x >= 8211 && x <= 8214 || x === 8216 || x === 8217 || x === 8220 || x === 8221 || x >= 8224 && x <= 8226 || x >= 8228 && x <= 8231 || x === 8240 || x === 8242 || x === 8243 || x === 8245 || x === 8251 || x === 8254 || x === 8308 || x === 8319 || x >= 8321 && x <= 8324 || x === 8364 || x === 8451 || x === 8453 || x === 8457 || x === 8467 || x === 8470 || x === 8481 || x === 8482 || x === 8486 || x === 8491 || x === 8531 || x === 8532 || x >= 8539 && x <= 8542 || x >= 8544 && x <= 8555 || x >= 8560 && x <= 8569 || x === 8585 || x >= 8592 && x <= 8601 || x === 8632 || x === 8633 || x === 8658 || x === 8660 || x === 8679 || x === 8704 || x === 8706 || x === 8707 || x === 8711 || x === 8712 || x === 8715 || x === 8719 || x === 8721 || x === 8725 || x === 8730 || x >= 8733 && x <= 8736 || x === 8739 || x === 8741 || x >= 8743 && x <= 8748 || x === 8750 || x >= 8756 && x <= 8759 || x === 8764 || x === 8765 || x === 8776 || x === 8780 || x === 8786 || x === 8800 || x === 8801 || x >= 8804 && x <= 8807 || x === 8810 || x === 8811 || x === 8814 || x === 8815 || x === 8834 || x === 8835 || x === 8838 || x === 8839 || x === 8853 || x === 8857 || x === 8869 || x === 8895 || x === 8978 || x >= 9312 && x <= 9449 || x >= 9451 && x <= 9547 || x >= 9552 && x <= 9587 || x >= 9600 && x <= 9615 || x >= 9618 && x <= 9621 || x === 9632 || x === 9633 || x >= 9635 && x <= 9641 || x === 9650 || x === 9651 || x === 9654 || x === 9655 || x === 9660 || x === 9661 || x === 9664 || x === 9665 || x >= 9670 && x <= 9672 || x === 9675 || x >= 9678 && x <= 9681 || x >= 9698 && x <= 9701 || x === 9711 || x === 9733 || x === 9734 || x === 9737 || x === 9742 || x === 9743 || x === 9756 || x === 9758 || x === 9792 || x === 9794 || x === 9824 || x === 9825 || x >= 9827 && x <= 9829 || x >= 9831 && x <= 9834 || x === 9836 || x === 9837 || x === 9839 || x === 9886 || x === 9887 || x === 9919 || x >= 9926 && x <= 9933 || x >= 9935 && x <= 9939 || x >= 9941 && x <= 9953 || x === 9955 || x === 9960 || x === 9961 || x >= 9963 && x <= 9969 || x === 9972 || x >= 9974 && x <= 9977 || x === 9979 || x === 9980 || x === 9982 || x === 9983 || x === 10045 || x >= 10102 && x <= 10111 || x >= 11094 && x <= 11097 || x >= 12872 && x <= 12879 || x >= 57344 && x <= 63743 || x >= 65024 && x <= 65039 || x === 65533 || x >= 127232 && x <= 127242 || x >= 127248 && x <= 127277 || x >= 127280 && x <= 127337 || x >= 127344 && x <= 127373 || x === 127375 || x === 127376 || x >= 127387 && x <= 127404 || x >= 917760 && x <= 917999 || x >= 983040 && x <= 1048573 || x >= 1048576 && x <= 1114109;
+}
+function isFullWidth(x) {
+	return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+}
+function isWide(x) {
+	return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9776 && x <= 9783 || x >= 9800 && x <= 9811 || x === 9855 || x >= 9866 && x <= 9871 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12773 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x === 94192 || x === 94193 || x >= 94208 && x <= 100343 || x >= 100352 && x <= 101589 || x >= 101631 && x <= 101640 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x >= 119552 && x <= 119638 || x >= 119648 && x <= 119670 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128727 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129673 || x >= 129679 && x <= 129734 || x >= 129742 && x <= 129756 || x >= 129759 && x <= 129769 || x >= 129776 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+}
+function validate(codePoint) {
+	if (!Number.isSafeInteger(codePoint)) throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+	validate(codePoint);
+	if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) return 2;
+	return 1;
+}
+const emojiRegex = () => {
+	return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g;
+};
+const segmenter = globalThis.Intl?.Segmenter ? new Intl.Segmenter() : { segment: (str) => str.split("") };
+const defaultIgnorableCodePointRegex = /^\p{Default_Ignorable_Code_Point}$/u;
+function stringWidth$1(string, options = {}) {
+	if (typeof string !== "string" || string.length === 0) return 0;
+	const { ambiguousIsNarrow = true, countAnsiEscapeCodes = false } = options;
+	if (!countAnsiEscapeCodes) string = stripAnsi(string);
+	if (string.length === 0) return 0;
+	let width = 0;
+	const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+	for (const { segment: character } of segmenter.segment(string)) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) continue;
+		if (codePoint >= 8203 && codePoint <= 8207 || codePoint === 65279) continue;
+		if (codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071) continue;
+		if (codePoint >= 55296 && codePoint <= 57343) continue;
+		if (codePoint >= 65024 && codePoint <= 65039) continue;
+		if (defaultIgnorableCodePointRegex.test(character)) continue;
+		if (emojiRegex().test(character)) {
+			width += 2;
+			continue;
+		}
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+	}
+	return width;
+}
+function isUnicodeSupported() {
+	const { env } = process$1;
+	const { TERM, TERM_PROGRAM } = env;
+	if (process$1.platform !== "win32") return TERM !== "linux";
+	return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+const TYPE_COLOR_MAP = {
+	info: "cyan",
+	fail: "red",
+	success: "green",
+	ready: "green",
+	start: "magenta"
+};
+const LEVEL_COLOR_MAP = {
+	0: "red",
+	1: "yellow"
+};
+const unicode = isUnicodeSupported();
+const s = (c, fallback) => unicode ? c : fallback;
+const TYPE_ICONS = {
+	error: s("✖", "×"),
+	fatal: s("✖", "×"),
+	ready: s("✔", "√"),
+	warn: s("⚠", "‼"),
+	info: s("ℹ", "i"),
+	success: s("✔", "√"),
+	debug: s("⚙", "D"),
+	trace: s("→", "→"),
+	fail: s("✖", "×"),
+	start: s("◐", "o"),
+	log: ""
+};
+function stringWidth(str) {
+	if (!(typeof Intl === "object") || !Intl.Segmenter) return stripAnsi$1(str).length;
+	return stringWidth$1(str);
+}
+var FancyReporter = class extends BasicReporter {
+	formatStack(stack, message, opts) {
+		const indent = "  ".repeat((opts?.errorLevel || 0) + 1);
+		return `
+${indent}` + parseStack(stack, message).map((line) => "  " + line.replace(/^at +/, (m) => colors.gray(m)).replace(/\((.+)\)/, (_, m) => `(${colors.cyan(m)})`)).join(`
+${indent}`);
+	}
+	formatType(logObj, isBadge, opts) {
+		const typeColor = TYPE_COLOR_MAP[logObj.type] || LEVEL_COLOR_MAP[logObj.level] || "gray";
+		if (isBadge) return getBgColor(typeColor)(colors.black(` ${logObj.type.toUpperCase()} `));
+		const _type = typeof TYPE_ICONS[logObj.type] === "string" ? TYPE_ICONS[logObj.type] : logObj.icon || logObj.type;
+		return _type ? getColor(typeColor)(_type) : "";
+	}
+	formatLogObj(logObj, opts) {
+		const [message, ...additional] = this.formatArgs(logObj.args, opts).split("\n");
+		if (logObj.type === "box") return box(characterFormat(message + (additional.length > 0 ? "\n" + additional.join("\n") : "")), {
+			title: logObj.title ? characterFormat(logObj.title) : void 0,
+			style: logObj.style
+		});
+		const date = this.formatDate(logObj.date, opts);
+		const coloredDate = date && colors.gray(date);
+		const isBadge = logObj.badge ?? logObj.level < 2;
+		const type = this.formatType(logObj, isBadge, opts);
+		const tag = logObj.tag ? colors.gray(logObj.tag) : "";
+		let line;
+		const left = this.filterAndJoin([type, characterFormat(message)]);
+		const right = this.filterAndJoin(opts.columns ? [tag, coloredDate] : [tag]);
+		const space = (opts.columns || 0) - stringWidth(left) - stringWidth(right) - 2;
+		line = space > 0 && (opts.columns || 0) >= 80 ? left + " ".repeat(space) + right : (right ? `${colors.gray(`[${right}]`)} ` : "") + left;
+		line += characterFormat(additional.length > 0 ? "\n" + additional.join("\n") : "");
+		if (logObj.type === "trace") {
+			const _err = /* @__PURE__ */ new Error("Trace: " + logObj.message);
+			line += this.formatStack(_err.stack || "", _err.message);
+		}
+		return isBadge ? "\n" + line + "\n" : line;
+	}
+};
+function characterFormat(str) {
+	return str.replace(/`([^`]+)`/gm, (_, m) => colors.cyan(m)).replace(/\s+_([^_]+)_\s+/gm, (_, m) => ` ${colors.underline(m)} `);
+}
+function getColor(color = "white") {
+	return colors[color] || colors.white;
+}
+function getBgColor(color = "bgWhite") {
+	return colors[`bg${color[0].toUpperCase()}${color.slice(1)}`] || colors.bgWhite;
+}
+function createConsola(options = {}) {
+	let level = _getDefaultLogLevel();
+	if (process.env.CONSOLA_LEVEL) level = Number.parseInt(process.env.CONSOLA_LEVEL) ?? level;
+	return createConsola$1({
+		level,
+		defaults: { level },
+		stdout: process.stdout,
+		stderr: process.stderr,
+		prompt: (...args) => import("./prompt-U5ajztzG.mjs").then((m) => m.prompt(...args)),
+		reporters: options.reporters || [options.fancy ?? !(T || R) ? new FancyReporter() : new BasicReporter()],
+		...options
+	});
+}
+function _getDefaultLogLevel() {
+	if (g) return LogLevels.debug;
+	if (R) return LogLevels.warn;
+	return LogLevels.info;
+}
+createConsola();
+//#endregion
+//#region src/cli/logger.ts
+/**
+* Console logger
+*/
+const logger = process.env.ROLLDOWN_TEST ? createTestingLogger() : createConsola({ formatOptions: { date: false } });
+function createTestingLogger() {
+	const types = [
+		"silent",
+		"fatal",
+		"error",
+		"warn",
+		"log",
+		"info",
+		"success",
+		"fail",
+		"ready",
+		"start",
+		"box",
+		"debug",
+		"trace",
+		"verbose"
+	];
+	const ret = Object.create(null);
+	for (const type of types) ret[type] = (...args) => console.log(...args);
+	return ret;
+}
+//#endregion
+//#region src/utils/bindingify-output-options.ts
+function bindingifyOutputOptions(outputOptions) {
+	const { dir, format, exports, hashCharacters, sourcemap, sourcemapBaseUrl, sourcemapDebugIds, sourcemapExcludeSources, sourcemapIgnoreList, sourcemapPathTransform, name, assetFileNames, entryFileNames, chunkFileNames, banner, footer, postBanner, postFooter, intro, outro, esModule, globals, paths, generatedCode, file, sanitizeFileName, preserveModules, virtualDirname, legalComments, comments, preserveModulesRoot, manualChunks, topLevelVar, cleanDir, strictExecutionOrder } = outputOptions;
+	if (legalComments != null) logger.warn("`legalComments` option is deprecated, please use `comments.legal` instead.");
+	const { inlineDynamicImports, advancedChunks } = bindingifyCodeSplitting(outputOptions.codeSplitting, outputOptions.inlineDynamicImports, outputOptions.advancedChunks, manualChunks);
+	return {
+		dir,
+		file: file == null ? void 0 : file,
+		format: bindingifyFormat(format),
+		exports,
+		hashCharacters,
+		sourcemap: bindingifySourcemap(sourcemap),
+		sourcemapBaseUrl,
+		sourcemapDebugIds,
+		sourcemapExcludeSources,
+		sourcemapIgnoreList: sourcemapIgnoreList ?? /node_modules/,
+		sourcemapPathTransform,
+		banner: bindingifyAddon(banner),
+		footer: bindingifyAddon(footer),
+		postBanner: bindingifyAddon(postBanner),
+		postFooter: bindingifyAddon(postFooter),
+		intro: bindingifyAddon(intro),
+		outro: bindingifyAddon(outro),
+		extend: outputOptions.extend,
+		globals,
+		paths,
+		generatedCode,
+		esModule,
+		name,
+		assetFileNames: bindingifyAssetFilenames(assetFileNames),
+		entryFileNames,
+		chunkFileNames,
+		plugins: [],
+		minify: outputOptions.minify,
+		externalLiveBindings: outputOptions.externalLiveBindings,
+		inlineDynamicImports,
+		dynamicImportInCjs: outputOptions.dynamicImportInCjs,
+		manualCodeSplitting: advancedChunks,
+		polyfillRequire: outputOptions.polyfillRequire,
+		sanitizeFileName,
+		preserveModules,
+		virtualDirname,
+		legalComments,
+		comments: bindingifyComments(comments),
+		preserveModulesRoot,
+		topLevelVar,
+		minifyInternalExports: outputOptions.minifyInternalExports,
+		cleanDir,
+		strictExecutionOrder,
+		strict: outputOptions.strict
+	};
+}
+function bindingifyAddon(configAddon) {
+	if (configAddon == null || configAddon === "") return;
+	if (typeof configAddon === "function") return async (chunk) => configAddon(transformRenderedChunk(chunk));
+	return configAddon;
+}
+function bindingifyFormat(format) {
+	switch (format) {
+		case void 0:
+		case "es":
+		case "esm":
+		case "module": return "es";
+		case "cjs":
+		case "commonjs": return "cjs";
+		case "iife": return "iife";
+		case "umd": return "umd";
+		default: unimplemented(`output.format: ${format}`);
+	}
+}
+function bindingifySourcemap(sourcemap) {
+	switch (sourcemap) {
+		case true: return "file";
+		case "inline": return "inline";
+		case false:
+		case void 0: return;
+		case "hidden": return "hidden";
+		default: throw new Error(`unknown sourcemap: ${sourcemap}`);
+	}
+}
+function bindingifyAssetFilenames(assetFileNames) {
+	if (typeof assetFileNames === "function") return (asset) => {
+		return assetFileNames({
+			name: asset.name,
+			names: asset.names,
+			originalFileName: asset.originalFileName,
+			originalFileNames: asset.originalFileNames,
+			source: transformAssetSource(asset.source),
+			type: "asset"
+		});
+	};
+	return assetFileNames;
+}
+function bindingifyComments(comments) {
+	if (comments == null) return;
+	if (typeof comments === "boolean") return comments;
+	return comments;
+}
+function bindingifyCodeSplitting(codeSplitting, inlineDynamicImportsOption, advancedChunks, manualChunks) {
+	let inlineDynamicImports;
+	let effectiveChunksOption;
+	if (codeSplitting === false) {
+		if (inlineDynamicImportsOption != null) logger.warn("`inlineDynamicImports` option is ignored because `codeSplitting: false` is set.");
+		if (manualChunks != null) throw new Error("Invalid configuration: \"output.manualChunks\" cannot be used when \"output.codeSplitting\" is set to false.");
+		if (advancedChunks != null) logger.warn("`advancedChunks` option is ignored because `codeSplitting` is set to `false`.");
+		return {
+			inlineDynamicImports: true,
+			advancedChunks: void 0
+		};
+	} else if (codeSplitting === true) {
+		if (inlineDynamicImportsOption != null) logger.warn("`inlineDynamicImports` option is ignored because `codeSplitting: true` is set.");
+	} else if (codeSplitting == null) {
+		if (inlineDynamicImportsOption != null) {
+			logger.warn("`inlineDynamicImports` option is deprecated, please use `codeSplitting: false` instead.");
+			inlineDynamicImports = inlineDynamicImportsOption;
+		}
+	} else {
+		effectiveChunksOption = codeSplitting;
+		if (inlineDynamicImportsOption != null) logger.warn("`inlineDynamicImports` option is ignored because the `codeSplitting` option is specified.");
+	}
+	if (inlineDynamicImports === true && manualChunks != null) throw new Error("Invalid value \"true\" for option \"output.inlineDynamicImports\" - this option is not supported for \"output.manualChunks\".");
+	if (effectiveChunksOption == null) {
+		if (advancedChunks != null) {
+			logger.warn("`advancedChunks` option is deprecated, please use `codeSplitting` instead.");
+			effectiveChunksOption = advancedChunks;
+		}
+	} else if (advancedChunks != null) logger.warn("`advancedChunks` option is ignored because the `codeSplitting` option is specified.");
+	if (manualChunks != null && effectiveChunksOption != null) logger.warn("`manualChunks` option is ignored because the `codeSplitting` option is specified.");
+	else if (manualChunks != null) effectiveChunksOption = { groups: [{ name(moduleId, ctx) {
+		return manualChunks(moduleId, { getModuleInfo: (id) => ctx.getModuleInfo(id) });
+	} }] };
+	let advancedChunksResult;
+	if (effectiveChunksOption != null) {
+		const { groups, ...restOptions } = effectiveChunksOption;
+		advancedChunksResult = {
+			...restOptions,
+			groups: groups?.map((group) => {
+				const { name, ...restGroup } = group;
+				return {
+					...restGroup,
+					name: typeof name === "function" ? (id, ctx) => name(id, new ChunkingContextImpl(ctx)) : name
+				};
+			})
+		};
+	}
+	return {
+		inlineDynamicImports,
+		advancedChunks: advancedChunksResult
+	};
+}
+//#endregion
+//#region src/utils/initialize-parallel-plugins.ts
+async function initializeParallelPlugins(plugins) {
+	const pluginInfos = [];
+	for (const [index, plugin] of plugins.entries()) if ("_parallel" in plugin) {
+		const { fileUrl, options } = plugin._parallel;
+		pluginInfos.push({
+			index,
+			fileUrl,
+			options
+		});
+	}
+	if (pluginInfos.length <= 0) return;
+	const count = availableParallelism();
+	const parallelJsPluginRegistry = new import_binding.ParallelJsPluginRegistry(count);
+	const registryId = parallelJsPluginRegistry.id;
+	const workers = await initializeWorkers(registryId, count, pluginInfos);
+	const stopWorkers = async () => {
+		await Promise.all(workers.map((worker) => worker.terminate()));
+	};
+	return {
+		registry: parallelJsPluginRegistry,
+		stopWorkers
+	};
+}
+function initializeWorkers(registryId, count, pluginInfos) {
+	return Promise.all(Array.from({ length: count }, (_, i) => initializeWorker(registryId, pluginInfos, i)));
+}
+async function initializeWorker(registryId, pluginInfos, threadNumber) {
+	const urlString = import.meta.resolve("#parallel-plugin-worker");
+	const workerData = {
+		registryId,
+		pluginInfos,
+		threadNumber
+	};
+	let worker;
+	try {
+		worker = new Worker(new URL(urlString), { workerData });
+		worker.unref();
+		await new Promise((resolve, reject) => {
+			worker.once("message", async (message) => {
+				if (message.type === "error") reject(message.error);
+				else resolve();
+			});
+		});
+		return worker;
+	} catch (e) {
+		worker?.terminate();
+		throw e;
+	}
+}
+const availableParallelism = () => {
+	let availableParallelism = 1;
+	try {
+		availableParallelism = os.availableParallelism();
+	} catch {
+		const cpus = os.cpus();
+		if (Array.isArray(cpus) && cpus.length > 0) availableParallelism = cpus.length;
+	}
+	return Math.min(availableParallelism, 8);
+};
+//#endregion
+//#region src/utils/create-bundler-option.ts
+async function createBundlerOptions(inputOptions, outputOptions, watchMode) {
+	const inputPlugins = await normalizePluginOption(inputOptions.plugins);
+	const outputPlugins = await normalizePluginOption(outputOptions.plugins);
+	const logLevel = inputOptions.logLevel || "info";
+	const onLog = getLogger(getObjectPlugins(inputPlugins), getOnLog(inputOptions, logLevel), logLevel, watchMode);
+	outputOptions = PluginDriver.callOutputOptionsHook([...inputPlugins, ...outputPlugins], outputOptions, onLog, logLevel, watchMode);
+	const hookOutputPlugins = await normalizePluginOption(outputOptions.plugins);
+	const normalizedInputPlugins = normalizePlugins(inputPlugins, ANONYMOUS_PLUGIN_PREFIX);
+	const normalizedOutputPlugins = normalizePlugins(hookOutputPlugins, ANONYMOUS_OUTPUT_PLUGIN_PREFIX);
+	let plugins = [...normalizedInputPlugins, ...checkOutputPluginOption(normalizedOutputPlugins, onLog)];
+	const parallelPluginInitResult = await initializeParallelPlugins(plugins);
+	if (inputOptions.experimental?.strictExecutionOrder !== void 0) console.warn("`experimental.strictExecutionOrder` has been stabilized and moved to `output.strictExecutionOrder`. Please update your configuration.");
+	try {
+		return {
+			bundlerOptions: {
+				inputOptions: bindingifyInputOptions(plugins, inputOptions, outputOptions, normalizedInputPlugins, normalizedOutputPlugins, onLog, logLevel, watchMode),
+				outputOptions: bindingifyOutputOptions(outputOptions),
+				parallelPluginsRegistry: parallelPluginInitResult?.registry
+			},
+			inputOptions,
+			onLog,
+			stopWorkers: parallelPluginInitResult?.stopWorkers
+		};
+	} catch (e) {
+		await parallelPluginInitResult?.stopWorkers();
+		throw e;
+	}
+}
+//#endregion
+//#region src/api/rolldown/rolldown-build.ts
+Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
+/**
+* The bundle object returned by {@linkcode rolldown} function.
+*
+* @category Programmatic APIs
+*/
+var RolldownBuild = class RolldownBuild {
+	#inputOptions;
+	#bundler;
+	#stopWorkers;
+	/** @internal */
+	static asyncRuntimeShutdown = false;
+	/** @hidden should not be used directly */
+	constructor(inputOptions) {
+		this.#inputOptions = inputOptions;
+		this.#bundler = new import_binding.BindingBundler();
+	}
+	/**
+	* Whether the bundle has been closed.
+	*
+	* If the bundle is closed, calling other methods will throw an error.
+	*/
+	get closed() {
+		return this.#bundler.closed;
+	}
+	/**
+	* Generate bundles in-memory.
+	*
+	* If you directly want to write bundles to disk, use the {@linkcode write} method instead.
+	*
+	* @param outputOptions The output options.
+	* @returns The generated bundle.
+	* @throws {@linkcode BundleError} When an error occurs during the build.
+	*/
+	async generate(outputOptions = {}) {
+		return this.#build(false, outputOptions);
+	}
+	/**
+	* Generate and write bundles to disk.
+	*
+	* If you want to generate bundles in-memory, use the {@linkcode generate} method instead.
+	*
+	* @param outputOptions The output options.
+	* @returns The generated bundle.
+	* @throws {@linkcode BundleError} When an error occurs during the build.
+	*/
+	async write(outputOptions = {}) {
+		return this.#build(true, outputOptions);
+	}
+	/**
+	* Close the bundle and free resources.
+	*
+	* This method is called automatically when using `using` syntax.
+	*
+	* @example
+	* ```js
+	* import { rolldown } from 'rolldown';
+	*
+	* {
+	*   using bundle = await rolldown({ input: 'src/main.js' });
+	*   const output = await bundle.generate({ format: 'esm' });
+	*   console.log(output);
+	*   // bundle.close() is called automatically here
+	* }
+	* ```
+	*/
+	async close() {
+		await this.#stopWorkers?.();
+		await this.#bundler.close();
+		(0, import_binding.shutdownAsyncRuntime)();
+		RolldownBuild.asyncRuntimeShutdown = true;
+		this.#stopWorkers = void 0;
+	}
+	/** @hidden documented in close method */
+	async [Symbol.asyncDispose]() {
+		await this.close();
+	}
+	/**
+	* @experimental
+	* @hidden not ready for public usage yet
+	*/
+	get watchFiles() {
+		return Promise.resolve(this.#bundler.getWatchFiles());
+	}
+	async #build(isWrite, outputOptions) {
+		validateOption("output", outputOptions);
+		await this.#stopWorkers?.();
+		const option = await createBundlerOptions(this.#inputOptions, outputOptions, false);
+		if (RolldownBuild.asyncRuntimeShutdown) (0, import_binding.startAsyncRuntime)();
+		try {
+			this.#stopWorkers = option.stopWorkers;
+			let output;
+			if (isWrite) output = await this.#bundler.write(option.bundlerOptions);
+			else output = await this.#bundler.generate(option.bundlerOptions);
+			return new RolldownOutputImpl(unwrapBindingResult(output));
+		} catch (e) {
+			await option.stopWorkers?.();
+			throw e;
+		}
+	}
+};
+//#endregion
+export { getInputCliKeys as a, validateOption as c, getCliSchemaInfo as i, styleText$1 as l, createBundlerOptions as n, getOutputCliKeys as o, logger as r, validateCliOptions as s, RolldownBuild as t, PluginDriver as u };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/transform-DgZ3paSD.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/transform-DgZ3paSD.d.mts
new file mode 100644
index 0000000..f3c5a33
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/transform-DgZ3paSD.d.mts
@@ -0,0 +1,149 @@
+import { a as RolldownLog } from "./logging-C6h4g8dA.mjs";
+import { F as MinifyResult$1, H as SourceMap, L as ParseResult$1, P as MinifyOptions$1, R as ParserOptions$1, W as TsconfigCache$1, a as BindingEnhancedTransformOptions, o as BindingEnhancedTransformResult, v as BindingTsconfigResult } from "./binding-zH1vcmbM.mjs";
+
+//#region src/utils/resolve-tsconfig.d.ts
+/**
+* Cache for tsconfig resolution to avoid redundant file system operations.
+*
+* The cache stores resolved tsconfig configurations keyed by their file paths.
+* When transforming multiple files in the same project, tsconfig lookups are
+* deduplicated, improving performance.
+*
+* @category Utilities
+* @experimental
+*/
+declare class TsconfigCache extends TsconfigCache$1 {
+  constructor();
+}
+/** @hidden This is only expected to be used by Vite */
+declare function resolveTsconfig(filename: string, cache?: TsconfigCache | null): BindingTsconfigResult | null;
+//#endregion
+//#region src/utils/parse.d.ts
+/**
+* Result of parsing a code
+*
+* @category Utilities
+*/
+interface ParseResult extends ParseResult$1 {}
+/**
+* Options for parsing a code
+*
+* @category Utilities
+*/
+interface ParserOptions extends ParserOptions$1 {}
+/**
+* Parse JS/TS source asynchronously on a separate thread.
+*
+* Note that not all of the workload can happen on a separate thread.
+* Parsing on Rust side does happen in a separate thread, but deserialization of the AST to JS objects
+* has to happen on current thread. This synchronous deserialization work typically outweighs
+* the asynchronous parsing by a factor of between 3 and 20.
+*
+* i.e. the majority of the workload cannot be parallelized by using this method.
+*
+* Generally {@linkcode parseSync} is preferable to use as it does not have the overhead of spawning a thread.
+* If you need to parallelize parsing multiple files, it is recommended to use worker threads.
+*
+* @category Utilities
+*/
+declare function parse(filename: string, sourceText: string, options?: ParserOptions | null): Promise<ParseResult>;
+/**
+* Parse JS/TS source synchronously on current thread.
+*
+* This is generally preferable over {@linkcode parse} (async) as it does not have the overhead
+* of spawning a thread, and the majority of the workload cannot be parallelized anyway
+* (see {@linkcode parse} documentation for details).
+*
+* If you need to parallelize parsing multiple files, it is recommended to use worker threads
+* with {@linkcode parseSync} rather than using {@linkcode parse}.
+*
+* @category Utilities
+*/
+declare function parseSync(filename: string, sourceText: string, options?: ParserOptions | null): ParseResult;
+//#endregion
+//#region src/utils/minify.d.ts
+/**
+* Options for minification.
+*
+* @category Utilities
+*/
+interface MinifyOptions extends MinifyOptions$1 {
+  inputMap?: SourceMap;
+}
+/**
+* The result of minification.
+*
+* @category Utilities
+*/
+interface MinifyResult extends MinifyResult$1 {}
+/**
+* Minify asynchronously.
+*
+* Note: This function can be slower than {@linkcode minifySync} due to the overhead of spawning a thread.
+*
+* @category Utilities
+* @experimental
+*/
+declare function minify(filename: string, sourceText: string, options?: MinifyOptions | null): Promise<MinifyResult>;
+/**
+* Minify synchronously.
+*
+* @category Utilities
+* @experimental
+*/
+declare function minifySync(filename: string, sourceText: string, options?: MinifyOptions | null): MinifyResult;
+//#endregion
+//#region src/utils/transform.d.ts
+/**
+* Options for transforming a code.
+*
+* @category Utilities
+*/
+interface TransformOptions extends BindingEnhancedTransformOptions {}
+/**
+* Result of transforming a code.
+*
+* @category Utilities
+*/
+type TransformResult = Omit<BindingEnhancedTransformResult, "errors" | "warnings"> & {
+  errors: Error[];
+  warnings: RolldownLog[];
+};
+/**
+* Transpile a JavaScript or TypeScript into a target ECMAScript version, asynchronously.
+*
+* Note: This function can be slower than `transformSync` due to the overhead of spawning a thread.
+*
+* @param filename The name of the file being transformed. If this is a
+* relative path, consider setting the {@linkcode TransformOptions#cwd} option.
+* @param sourceText The source code to transform.
+* @param options The transform options including tsconfig and inputMap. See {@linkcode TransformOptions} for more information.
+* @param cache Optional tsconfig cache for reusing resolved tsconfig across multiple transforms.
+* Only used when `options.tsconfig` is `true`.
+*
+* @returns a promise that resolves to an object containing the transformed code,
+* source maps, and any errors that occurred during parsing or transformation.
+*
+* @category Utilities
+* @experimental
+*/
+declare function transform(filename: string, sourceText: string, options?: TransformOptions | null, cache?: TsconfigCache | null): Promise<TransformResult>;
+/**
+* Transpile a JavaScript or TypeScript into a target ECMAScript version.
+*
+* @param filename The name of the file being transformed. If this is a
+* relative path, consider setting the {@linkcode TransformOptions#cwd} option.
+* @param sourceText The source code to transform.
+* @param options The transform options including tsconfig and inputMap. See {@linkcode TransformOptions} for more information.
+* @param cache Optional tsconfig cache for reusing resolved tsconfig across multiple transforms.
+* Only used when `options.tsconfig` is `true`.
+*
+* @returns an object containing the transformed code, source maps, and any errors
+* that occurred during parsing or transformation.
+*
+* @category Utilities
+* @experimental
+*/
+declare function transformSync(filename: string, sourceText: string, options?: TransformOptions | null, cache?: TsconfigCache | null): TransformResult;
+//#endregion
+export { MinifyOptions as a, minifySync as c, parse as d, parseSync as f, transformSync as i, ParseResult as l, resolveTsconfig as m, TransformResult as n, MinifyResult as o, TsconfigCache as p, transform as r, minify as s, TransformOptions as t, ParserOptions as u };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/watch-RBs0UNYA.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/watch-RBs0UNYA.mjs
new file mode 100644
index 0000000..a90db91
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/shared/watch-RBs0UNYA.mjs
@@ -0,0 +1,374 @@
+import { n as __toESM, t as require_binding } from "./binding-C9S351wt.mjs";
+import { o as logMultipleWatcherOption } from "./logs-D80CXhvg.mjs";
+import { v as LOG_LEVEL_WARN } from "./bindingify-input-options-BnfFBV6b.mjs";
+import { t as arraify } from "./misc-DJYbNKZX.mjs";
+import { n as createBundlerOptions, u as PluginDriver } from "./rolldown-build-BVD3dIdE.mjs";
+import { t as aggregateBindingErrorsIntoJsError } from "./error-CkdMJ9ps.mjs";
+//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+/**
+* This is not the set of all possible signals.
+*
+* It IS, however, the set of all signals that trigger
+* an exit on either Linux or BSD systems.  Linux is a
+* superset of the signal names supported on BSD, and
+* the unknown signals just fail to register, so we can
+* catch that easily enough.
+*
+* Windows signals are a different set, since there are
+* signals that terminate Windows processes, but don't
+* terminate (or don't even exist) on Posix systems.
+*
+* Don't bother with SIGKILL.  It's uncatchable, which
+* means that we can't fire any callbacks anyway.
+*
+* If a user does happen to register a handler on a non-
+* fatal signal like SIGWINCH or something, and then
+* exit, it'll end up firing `process.emit('exit')`, so
+* the handler will be fired anyway.
+*
+* SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+* artificially, inherently leave the process in a
+* state from which it is not safe to try and enter JS
+* listeners.
+*/
+const signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+if (process.platform === "linux") signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+//#endregion
+//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+const processOk = (process) => !!process && typeof process === "object" && typeof process.removeListener === "function" && typeof process.emit === "function" && typeof process.reallyExit === "function" && typeof process.listeners === "function" && typeof process.kill === "function" && typeof process.pid === "number" && typeof process.on === "function";
+const kExitEmitter = Symbol.for("signal-exit emitter");
+const global = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+	emitted = {
+		afterExit: false,
+		exit: false
+	};
+	listeners = {
+		afterExit: [],
+		exit: []
+	};
+	count = 0;
+	id = Math.random();
+	constructor() {
+		if (global[kExitEmitter]) return global[kExitEmitter];
+		ObjectDefineProperty(global, kExitEmitter, {
+			value: this,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+	on(ev, fn) {
+		this.listeners[ev].push(fn);
+	}
+	removeListener(ev, fn) {
+		const list = this.listeners[ev];
+		const i = list.indexOf(fn);
+		/* c8 ignore start */
+		if (i === -1) return;
+		/* c8 ignore stop */
+		if (i === 0 && list.length === 1) list.length = 0;
+		else list.splice(i, 1);
+	}
+	emit(ev, code, signal) {
+		if (this.emitted[ev]) return false;
+		this.emitted[ev] = true;
+		let ret = false;
+		for (const fn of this.listeners[ev]) ret = fn(code, signal) === true || ret;
+		if (ev === "exit") ret = this.emit("afterExit", code, signal) || ret;
+		return ret;
+	}
+};
+var SignalExitBase = class {};
+const signalExitWrap = (handler) => {
+	return {
+		onExit(cb, opts) {
+			return handler.onExit(cb, opts);
+		},
+		load() {
+			return handler.load();
+		},
+		unload() {
+			return handler.unload();
+		}
+	};
+};
+var SignalExitFallback = class extends SignalExitBase {
+	onExit() {
+		return () => {};
+	}
+	load() {}
+	unload() {}
+};
+var SignalExit = class extends SignalExitBase {
+	/* c8 ignore start */
+	#hupSig = process$1.platform === "win32" ? "SIGINT" : "SIGHUP";
+	/* c8 ignore stop */
+	#emitter = new Emitter();
+	#process;
+	#originalProcessEmit;
+	#originalProcessReallyExit;
+	#sigListeners = {};
+	#loaded = false;
+	constructor(process) {
+		super();
+		this.#process = process;
+		this.#sigListeners = {};
+		for (const sig of signals) this.#sigListeners[sig] = () => {
+			const listeners = this.#process.listeners(sig);
+			let { count } = this.#emitter;
+			/* c8 ignore start */
+			const p = process;
+			if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") count += p.__signal_exit_emitter__.count;
+			/* c8 ignore stop */
+			if (listeners.length === count) {
+				this.unload();
+				const ret = this.#emitter.emit("exit", null, sig);
+				/* c8 ignore start */
+				const s = sig === "SIGHUP" ? this.#hupSig : sig;
+				if (!ret) process.kill(process.pid, s);
+			}
+		};
+		this.#originalProcessReallyExit = process.reallyExit;
+		this.#originalProcessEmit = process.emit;
+	}
+	onExit(cb, opts) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return () => {};
+		/* c8 ignore stop */
+		if (this.#loaded === false) this.load();
+		const ev = opts?.alwaysLast ? "afterExit" : "exit";
+		this.#emitter.on(ev, cb);
+		return () => {
+			this.#emitter.removeListener(ev, cb);
+			if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) this.unload();
+		};
+	}
+	load() {
+		if (this.#loaded) return;
+		this.#loaded = true;
+		this.#emitter.count += 1;
+		for (const sig of signals) try {
+			const fn = this.#sigListeners[sig];
+			if (fn) this.#process.on(sig, fn);
+		} catch (_) {}
+		this.#process.emit = (ev, ...a) => {
+			return this.#processEmit(ev, ...a);
+		};
+		this.#process.reallyExit = (code) => {
+			return this.#processReallyExit(code);
+		};
+	}
+	unload() {
+		if (!this.#loaded) return;
+		this.#loaded = false;
+		signals.forEach((sig) => {
+			const listener = this.#sigListeners[sig];
+			/* c8 ignore start */
+			if (!listener) throw new Error("Listener not defined for signal: " + sig);
+			/* c8 ignore stop */
+			try {
+				this.#process.removeListener(sig, listener);
+			} catch (_) {}
+			/* c8 ignore stop */
+		});
+		this.#process.emit = this.#originalProcessEmit;
+		this.#process.reallyExit = this.#originalProcessReallyExit;
+		this.#emitter.count -= 1;
+	}
+	#processReallyExit(code) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return 0;
+		this.#process.exitCode = code || 0;
+		/* c8 ignore stop */
+		this.#emitter.emit("exit", this.#process.exitCode, null);
+		return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+	}
+	#processEmit(ev, ...args) {
+		const og = this.#originalProcessEmit;
+		if (ev === "exit" && processOk(this.#process)) {
+			if (typeof args[0] === "number") this.#process.exitCode = args[0];
+			/* c8 ignore start */
+			const ret = og.call(this.#process, ev, ...args);
+			/* c8 ignore start */
+			this.#emitter.emit("exit", this.#process.exitCode, null);
+			/* c8 ignore stop */
+			return ret;
+		} else return og.call(this.#process, ev, ...args);
+	}
+};
+const process$1 = globalThis.process;
+const { onExit: onExit$1, load, unload } = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
+//#endregion
+//#region src/utils/signal-exit.ts
+function onExit(...args) {
+	if (typeof process === "object" && process.versions.webcontainer) {
+		process.on("exit", (code) => {
+			args[0](code, null);
+		});
+		return;
+	}
+	onExit$1(...args);
+}
+//#endregion
+//#region src/api/watch/watch-emitter.ts
+var WatcherEmitter = class {
+	listeners = /* @__PURE__ */ new Map();
+	on(event, listener) {
+		const listeners = this.listeners.get(event);
+		if (listeners) listeners.push(listener);
+		else this.listeners.set(event, [listener]);
+		return this;
+	}
+	off(event, listener) {
+		const listeners = this.listeners.get(event);
+		if (listeners) {
+			const index = listeners.indexOf(listener);
+			if (index !== -1) listeners.splice(index, 1);
+		}
+		return this;
+	}
+	clear(event) {
+		this.listeners.delete(event);
+	}
+	/** Async emit — sequential dispatch so side effects from earlier handlers
+	*  (e.g. `event.result.close()` triggering `closeBundle`) are visible to later handlers. */
+	async emit(event, ...args) {
+		const handlers = this.listeners.get(event);
+		if (handlers?.length) for (const h of handlers) await h(...args);
+	}
+	async close() {}
+};
+//#endregion
+//#region src/api/watch/watcher.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+function createEventCallback(emitter) {
+	return async (event) => {
+		switch (event.eventKind()) {
+			case "event": {
+				const code = event.bundleEventKind();
+				if (code === "BUNDLE_END") {
+					const { duration, output, result } = event.bundleEndData();
+					await emitter.emit("event", {
+						code: "BUNDLE_END",
+						duration,
+						output: [output],
+						result
+					});
+				} else if (code === "ERROR") {
+					const data = event.bundleErrorData();
+					await emitter.emit("event", {
+						code: "ERROR",
+						error: aggregateBindingErrorsIntoJsError(data.error),
+						result: data.result
+					});
+				} else await emitter.emit("event", { code });
+				break;
+			}
+			case "change": {
+				const { path, kind } = event.watchChangeData();
+				await emitter.emit("change", path, { event: kind });
+				break;
+			}
+			case "restart":
+				await emitter.emit("restart");
+				break;
+			case "close":
+				await emitter.emit("close");
+				break;
+		}
+	};
+}
+var Watcher = class {
+	closed;
+	inner;
+	emitter;
+	stopWorkers;
+	constructor(emitter, inner, stopWorkers) {
+		this.closed = false;
+		this.inner = inner;
+		this.emitter = emitter;
+		const originClose = emitter.close.bind(emitter);
+		emitter.close = async () => {
+			await this.close();
+			originClose();
+		};
+		this.stopWorkers = stopWorkers;
+		process.nextTick(() => this.run());
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const stop of this.stopWorkers) await stop?.();
+		await this.inner.close();
+		(0, import_binding.shutdownAsyncRuntime)();
+	}
+	async run() {
+		await this.inner.run();
+		this.inner.waitForClose();
+	}
+};
+async function createWatcher(emitter, input) {
+	const options = arraify(input);
+	const bundlerOptions = await Promise.all(options.map((option) => arraify(option.output || {}).map(async (output) => {
+		return createBundlerOptions(await PluginDriver.callOptionsHook(option, true), output, true);
+	})).flat());
+	warnMultiplePollingOptions(bundlerOptions);
+	const callback = createEventCallback(emitter);
+	new Watcher(emitter, new import_binding.BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), callback), bundlerOptions.map((option) => option.stopWorkers));
+}
+function warnMultiplePollingOptions(bundlerOptions) {
+	let found = false;
+	for (const option of bundlerOptions) {
+		const watch = option.inputOptions.watch;
+		const watcher = watch && typeof watch === "object" ? watch.watcher ?? watch.notify : void 0;
+		if (watcher && (watcher.usePolling != null || watcher.pollInterval != null)) {
+			if (found) {
+				option.onLog(LOG_LEVEL_WARN, logMultipleWatcherOption());
+				return;
+			}
+			found = true;
+		}
+	}
+}
+//#endregion
+//#region src/api/watch/index.ts
+/**
+* The API compatible with Rollup's `watch` function.
+*
+* This function will rebuild the bundle when it detects that the individual modules have changed on disk.
+*
+* Note that when using this function, it is your responsibility to call `event.result.close()` in response to the `BUNDLE_END` event to avoid resource leaks.
+*
+* @param input The watch options object or the list of them.
+* @returns A watcher object.
+*
+* @example
+* ```js
+* import { watch } from 'rolldown';
+*
+* const watcher = watch({ /* ... *\/ });
+* watcher.on('event', (event) => {
+*   if (event.code === 'BUNDLE_END') {
+*     console.log(event.duration);
+*     event.result.close();
+*   }
+* });
+*
+* // Stop watching
+* watcher.close();
+* ```
+*
+* @experimental
+* @category Programmatic APIs
+*/
+function watch(input) {
+	const emitter = new WatcherEmitter();
+	createWatcher(emitter, input);
+	return emitter;
+}
+//#endregion
+export { onExit as n, watch as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/utils-index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/utils-index.d.mts
new file mode 100644
index 0000000..444dcb1
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/utils-index.d.mts
@@ -0,0 +1,376 @@
+import { _ as BindingTsconfigRawOptions, g as BindingTsconfigCompilerOptions } from "./shared/binding-zH1vcmbM.mjs";
+import { a as MinifyOptions, c as minifySync, d as parse, f as parseSync, i as transformSync, l as ParseResult, n as TransformResult, o as MinifyResult, p as TsconfigCache, r as transform, s as minify, t as TransformOptions, u as ParserOptions } from "./shared/transform-DgZ3paSD.mjs";
+import * as ESTree from "@oxc-project/types";
+import { Program } from "@oxc-project/types";
+
+//#region ../../node_modules/.pnpm/oxc-parser@0.130.0/node_modules/oxc-parser/src-js/generated/visit/visitor.d.ts
+interface VisitorObject$1 {
+  DebuggerStatement?: (node: ESTree.DebuggerStatement) => void;
+  "DebuggerStatement:exit"?: (node: ESTree.DebuggerStatement) => void;
+  EmptyStatement?: (node: ESTree.EmptyStatement) => void;
+  "EmptyStatement:exit"?: (node: ESTree.EmptyStatement) => void;
+  Literal?: (node: ESTree.BooleanLiteral | ESTree.NullLiteral | ESTree.NumericLiteral | ESTree.StringLiteral | ESTree.BigIntLiteral | ESTree.RegExpLiteral) => void;
+  "Literal:exit"?: (node: ESTree.BooleanLiteral | ESTree.NullLiteral | ESTree.NumericLiteral | ESTree.StringLiteral | ESTree.BigIntLiteral | ESTree.RegExpLiteral) => void;
+  PrivateIdentifier?: (node: ESTree.PrivateIdentifier) => void;
+  "PrivateIdentifier:exit"?: (node: ESTree.PrivateIdentifier) => void;
+  Super?: (node: ESTree.Super) => void;
+  "Super:exit"?: (node: ESTree.Super) => void;
+  TemplateElement?: (node: ESTree.TemplateElement) => void;
+  "TemplateElement:exit"?: (node: ESTree.TemplateElement) => void;
+  ThisExpression?: (node: ESTree.ThisExpression) => void;
+  "ThisExpression:exit"?: (node: ESTree.ThisExpression) => void;
+  JSXClosingFragment?: (node: ESTree.JSXClosingFragment) => void;
+  "JSXClosingFragment:exit"?: (node: ESTree.JSXClosingFragment) => void;
+  JSXEmptyExpression?: (node: ESTree.JSXEmptyExpression) => void;
+  "JSXEmptyExpression:exit"?: (node: ESTree.JSXEmptyExpression) => void;
+  JSXIdentifier?: (node: ESTree.JSXIdentifier) => void;
+  "JSXIdentifier:exit"?: (node: ESTree.JSXIdentifier) => void;
+  JSXOpeningFragment?: (node: ESTree.JSXOpeningFragment) => void;
+  "JSXOpeningFragment:exit"?: (node: ESTree.JSXOpeningFragment) => void;
+  JSXText?: (node: ESTree.JSXText) => void;
+  "JSXText:exit"?: (node: ESTree.JSXText) => void;
+  TSAnyKeyword?: (node: ESTree.TSAnyKeyword) => void;
+  "TSAnyKeyword:exit"?: (node: ESTree.TSAnyKeyword) => void;
+  TSBigIntKeyword?: (node: ESTree.TSBigIntKeyword) => void;
+  "TSBigIntKeyword:exit"?: (node: ESTree.TSBigIntKeyword) => void;
+  TSBooleanKeyword?: (node: ESTree.TSBooleanKeyword) => void;
+  "TSBooleanKeyword:exit"?: (node: ESTree.TSBooleanKeyword) => void;
+  TSIntrinsicKeyword?: (node: ESTree.TSIntrinsicKeyword) => void;
+  "TSIntrinsicKeyword:exit"?: (node: ESTree.TSIntrinsicKeyword) => void;
+  TSJSDocUnknownType?: (node: ESTree.JSDocUnknownType) => void;
+  "TSJSDocUnknownType:exit"?: (node: ESTree.JSDocUnknownType) => void;
+  TSNeverKeyword?: (node: ESTree.TSNeverKeyword) => void;
+  "TSNeverKeyword:exit"?: (node: ESTree.TSNeverKeyword) => void;
+  TSNullKeyword?: (node: ESTree.TSNullKeyword) => void;
+  "TSNullKeyword:exit"?: (node: ESTree.TSNullKeyword) => void;
+  TSNumberKeyword?: (node: ESTree.TSNumberKeyword) => void;
+  "TSNumberKeyword:exit"?: (node: ESTree.TSNumberKeyword) => void;
+  TSObjectKeyword?: (node: ESTree.TSObjectKeyword) => void;
+  "TSObjectKeyword:exit"?: (node: ESTree.TSObjectKeyword) => void;
+  TSStringKeyword?: (node: ESTree.TSStringKeyword) => void;
+  "TSStringKeyword:exit"?: (node: ESTree.TSStringKeyword) => void;
+  TSSymbolKeyword?: (node: ESTree.TSSymbolKeyword) => void;
+  "TSSymbolKeyword:exit"?: (node: ESTree.TSSymbolKeyword) => void;
+  TSThisType?: (node: ESTree.TSThisType) => void;
+  "TSThisType:exit"?: (node: ESTree.TSThisType) => void;
+  TSUndefinedKeyword?: (node: ESTree.TSUndefinedKeyword) => void;
+  "TSUndefinedKeyword:exit"?: (node: ESTree.TSUndefinedKeyword) => void;
+  TSUnknownKeyword?: (node: ESTree.TSUnknownKeyword) => void;
+  "TSUnknownKeyword:exit"?: (node: ESTree.TSUnknownKeyword) => void;
+  TSVoidKeyword?: (node: ESTree.TSVoidKeyword) => void;
+  "TSVoidKeyword:exit"?: (node: ESTree.TSVoidKeyword) => void;
+  AccessorProperty?: (node: ESTree.AccessorProperty) => void;
+  "AccessorProperty:exit"?: (node: ESTree.AccessorProperty) => void;
+  ArrayExpression?: (node: ESTree.ArrayExpression) => void;
+  "ArrayExpression:exit"?: (node: ESTree.ArrayExpression) => void;
+  ArrayPattern?: (node: ESTree.ArrayPattern) => void;
+  "ArrayPattern:exit"?: (node: ESTree.ArrayPattern) => void;
+  ArrowFunctionExpression?: (node: ESTree.ArrowFunctionExpression) => void;
+  "ArrowFunctionExpression:exit"?: (node: ESTree.ArrowFunctionExpression) => void;
+  AssignmentExpression?: (node: ESTree.AssignmentExpression) => void;
+  "AssignmentExpression:exit"?: (node: ESTree.AssignmentExpression) => void;
+  AssignmentPattern?: (node: ESTree.AssignmentPattern) => void;
+  "AssignmentPattern:exit"?: (node: ESTree.AssignmentPattern) => void;
+  AwaitExpression?: (node: ESTree.AwaitExpression) => void;
+  "AwaitExpression:exit"?: (node: ESTree.AwaitExpression) => void;
+  BinaryExpression?: (node: ESTree.BinaryExpression) => void;
+  "BinaryExpression:exit"?: (node: ESTree.BinaryExpression) => void;
+  BlockStatement?: (node: ESTree.BlockStatement) => void;
+  "BlockStatement:exit"?: (node: ESTree.BlockStatement) => void;
+  BreakStatement?: (node: ESTree.BreakStatement) => void;
+  "BreakStatement:exit"?: (node: ESTree.BreakStatement) => void;
+  CallExpression?: (node: ESTree.CallExpression) => void;
+  "CallExpression:exit"?: (node: ESTree.CallExpression) => void;
+  CatchClause?: (node: ESTree.CatchClause) => void;
+  "CatchClause:exit"?: (node: ESTree.CatchClause) => void;
+  ChainExpression?: (node: ESTree.ChainExpression) => void;
+  "ChainExpression:exit"?: (node: ESTree.ChainExpression) => void;
+  ClassBody?: (node: ESTree.ClassBody) => void;
+  "ClassBody:exit"?: (node: ESTree.ClassBody) => void;
+  ClassDeclaration?: (node: ESTree.Class) => void;
+  "ClassDeclaration:exit"?: (node: ESTree.Class) => void;
+  ClassExpression?: (node: ESTree.Class) => void;
+  "ClassExpression:exit"?: (node: ESTree.Class) => void;
+  ConditionalExpression?: (node: ESTree.ConditionalExpression) => void;
+  "ConditionalExpression:exit"?: (node: ESTree.ConditionalExpression) => void;
+  ContinueStatement?: (node: ESTree.ContinueStatement) => void;
+  "ContinueStatement:exit"?: (node: ESTree.ContinueStatement) => void;
+  Decorator?: (node: ESTree.Decorator) => void;
+  "Decorator:exit"?: (node: ESTree.Decorator) => void;
+  DoWhileStatement?: (node: ESTree.DoWhileStatement) => void;
+  "DoWhileStatement:exit"?: (node: ESTree.DoWhileStatement) => void;
+  ExportAllDeclaration?: (node: ESTree.ExportAllDeclaration) => void;
+  "ExportAllDeclaration:exit"?: (node: ESTree.ExportAllDeclaration) => void;
+  ExportDefaultDeclaration?: (node: ESTree.ExportDefaultDeclaration) => void;
+  "ExportDefaultDeclaration:exit"?: (node: ESTree.ExportDefaultDeclaration) => void;
+  ExportNamedDeclaration?: (node: ESTree.ExportNamedDeclaration) => void;
+  "ExportNamedDeclaration:exit"?: (node: ESTree.ExportNamedDeclaration) => void;
+  ExportSpecifier?: (node: ESTree.ExportSpecifier) => void;
+  "ExportSpecifier:exit"?: (node: ESTree.ExportSpecifier) => void;
+  ExpressionStatement?: (node: ESTree.ExpressionStatement) => void;
+  "ExpressionStatement:exit"?: (node: ESTree.ExpressionStatement) => void;
+  ForInStatement?: (node: ESTree.ForInStatement) => void;
+  "ForInStatement:exit"?: (node: ESTree.ForInStatement) => void;
+  ForOfStatement?: (node: ESTree.ForOfStatement) => void;
+  "ForOfStatement:exit"?: (node: ESTree.ForOfStatement) => void;
+  ForStatement?: (node: ESTree.ForStatement) => void;
+  "ForStatement:exit"?: (node: ESTree.ForStatement) => void;
+  FunctionDeclaration?: (node: ESTree.Function) => void;
+  "FunctionDeclaration:exit"?: (node: ESTree.Function) => void;
+  FunctionExpression?: (node: ESTree.Function) => void;
+  "FunctionExpression:exit"?: (node: ESTree.Function) => void;
+  Identifier?: (node: ESTree.IdentifierName | ESTree.IdentifierReference | ESTree.BindingIdentifier | ESTree.LabelIdentifier | ESTree.TSThisParameter | ESTree.TSIndexSignatureName) => void;
+  "Identifier:exit"?: (node: ESTree.IdentifierName | ESTree.IdentifierReference | ESTree.BindingIdentifier | ESTree.LabelIdentifier | ESTree.TSThisParameter | ESTree.TSIndexSignatureName) => void;
+  IfStatement?: (node: ESTree.IfStatement) => void;
+  "IfStatement:exit"?: (node: ESTree.IfStatement) => void;
+  ImportAttribute?: (node: ESTree.ImportAttribute) => void;
+  "ImportAttribute:exit"?: (node: ESTree.ImportAttribute) => void;
+  ImportDeclaration?: (node: ESTree.ImportDeclaration) => void;
+  "ImportDeclaration:exit"?: (node: ESTree.ImportDeclaration) => void;
+  ImportDefaultSpecifier?: (node: ESTree.ImportDefaultSpecifier) => void;
+  "ImportDefaultSpecifier:exit"?: (node: ESTree.ImportDefaultSpecifier) => void;
+  ImportExpression?: (node: ESTree.ImportExpression) => void;
+  "ImportExpression:exit"?: (node: ESTree.ImportExpression) => void;
+  ImportNamespaceSpecifier?: (node: ESTree.ImportNamespaceSpecifier) => void;
+  "ImportNamespaceSpecifier:exit"?: (node: ESTree.ImportNamespaceSpecifier) => void;
+  ImportSpecifier?: (node: ESTree.ImportSpecifier) => void;
+  "ImportSpecifier:exit"?: (node: ESTree.ImportSpecifier) => void;
+  LabeledStatement?: (node: ESTree.LabeledStatement) => void;
+  "LabeledStatement:exit"?: (node: ESTree.LabeledStatement) => void;
+  LogicalExpression?: (node: ESTree.LogicalExpression) => void;
+  "LogicalExpression:exit"?: (node: ESTree.LogicalExpression) => void;
+  MemberExpression?: (node: ESTree.MemberExpression) => void;
+  "MemberExpression:exit"?: (node: ESTree.MemberExpression) => void;
+  MetaProperty?: (node: ESTree.MetaProperty) => void;
+  "MetaProperty:exit"?: (node: ESTree.MetaProperty) => void;
+  MethodDefinition?: (node: ESTree.MethodDefinition) => void;
+  "MethodDefinition:exit"?: (node: ESTree.MethodDefinition) => void;
+  NewExpression?: (node: ESTree.NewExpression) => void;
+  "NewExpression:exit"?: (node: ESTree.NewExpression) => void;
+  ObjectExpression?: (node: ESTree.ObjectExpression) => void;
+  "ObjectExpression:exit"?: (node: ESTree.ObjectExpression) => void;
+  ObjectPattern?: (node: ESTree.ObjectPattern) => void;
+  "ObjectPattern:exit"?: (node: ESTree.ObjectPattern) => void;
+  ParenthesizedExpression?: (node: ESTree.ParenthesizedExpression) => void;
+  "ParenthesizedExpression:exit"?: (node: ESTree.ParenthesizedExpression) => void;
+  Program?: (node: ESTree.Program) => void;
+  "Program:exit"?: (node: ESTree.Program) => void;
+  Property?: (node: ESTree.ObjectProperty | ESTree.AssignmentTargetProperty | ESTree.AssignmentTargetPropertyProperty | ESTree.BindingProperty) => void;
+  "Property:exit"?: (node: ESTree.ObjectProperty | ESTree.AssignmentTargetProperty | ESTree.AssignmentTargetPropertyProperty | ESTree.BindingProperty) => void;
+  PropertyDefinition?: (node: ESTree.PropertyDefinition) => void;
+  "PropertyDefinition:exit"?: (node: ESTree.PropertyDefinition) => void;
+  RestElement?: (node: ESTree.AssignmentTargetRest | ESTree.BindingRestElement | ESTree.FormalParameterRest) => void;
+  "RestElement:exit"?: (node: ESTree.AssignmentTargetRest | ESTree.BindingRestElement | ESTree.FormalParameterRest) => void;
+  ReturnStatement?: (node: ESTree.ReturnStatement) => void;
+  "ReturnStatement:exit"?: (node: ESTree.ReturnStatement) => void;
+  SequenceExpression?: (node: ESTree.SequenceExpression) => void;
+  "SequenceExpression:exit"?: (node: ESTree.SequenceExpression) => void;
+  SpreadElement?: (node: ESTree.SpreadElement) => void;
+  "SpreadElement:exit"?: (node: ESTree.SpreadElement) => void;
+  StaticBlock?: (node: ESTree.StaticBlock) => void;
+  "StaticBlock:exit"?: (node: ESTree.StaticBlock) => void;
+  SwitchCase?: (node: ESTree.SwitchCase) => void;
+  "SwitchCase:exit"?: (node: ESTree.SwitchCase) => void;
+  SwitchStatement?: (node: ESTree.SwitchStatement) => void;
+  "SwitchStatement:exit"?: (node: ESTree.SwitchStatement) => void;
+  TaggedTemplateExpression?: (node: ESTree.TaggedTemplateExpression) => void;
+  "TaggedTemplateExpression:exit"?: (node: ESTree.TaggedTemplateExpression) => void;
+  TemplateLiteral?: (node: ESTree.TemplateLiteral) => void;
+  "TemplateLiteral:exit"?: (node: ESTree.TemplateLiteral) => void;
+  ThrowStatement?: (node: ESTree.ThrowStatement) => void;
+  "ThrowStatement:exit"?: (node: ESTree.ThrowStatement) => void;
+  TryStatement?: (node: ESTree.TryStatement) => void;
+  "TryStatement:exit"?: (node: ESTree.TryStatement) => void;
+  UnaryExpression?: (node: ESTree.UnaryExpression) => void;
+  "UnaryExpression:exit"?: (node: ESTree.UnaryExpression) => void;
+  UpdateExpression?: (node: ESTree.UpdateExpression) => void;
+  "UpdateExpression:exit"?: (node: ESTree.UpdateExpression) => void;
+  V8IntrinsicExpression?: (node: ESTree.V8IntrinsicExpression) => void;
+  "V8IntrinsicExpression:exit"?: (node: ESTree.V8IntrinsicExpression) => void;
+  VariableDeclaration?: (node: ESTree.VariableDeclaration) => void;
+  "VariableDeclaration:exit"?: (node: ESTree.VariableDeclaration) => void;
+  VariableDeclarator?: (node: ESTree.VariableDeclarator) => void;
+  "VariableDeclarator:exit"?: (node: ESTree.VariableDeclarator) => void;
+  WhileStatement?: (node: ESTree.WhileStatement) => void;
+  "WhileStatement:exit"?: (node: ESTree.WhileStatement) => void;
+  WithStatement?: (node: ESTree.WithStatement) => void;
+  "WithStatement:exit"?: (node: ESTree.WithStatement) => void;
+  YieldExpression?: (node: ESTree.YieldExpression) => void;
+  "YieldExpression:exit"?: (node: ESTree.YieldExpression) => void;
+  JSXAttribute?: (node: ESTree.JSXAttribute) => void;
+  "JSXAttribute:exit"?: (node: ESTree.JSXAttribute) => void;
+  JSXClosingElement?: (node: ESTree.JSXClosingElement) => void;
+  "JSXClosingElement:exit"?: (node: ESTree.JSXClosingElement) => void;
+  JSXElement?: (node: ESTree.JSXElement) => void;
+  "JSXElement:exit"?: (node: ESTree.JSXElement) => void;
+  JSXExpressionContainer?: (node: ESTree.JSXExpressionContainer) => void;
+  "JSXExpressionContainer:exit"?: (node: ESTree.JSXExpressionContainer) => void;
+  JSXFragment?: (node: ESTree.JSXFragment) => void;
+  "JSXFragment:exit"?: (node: ESTree.JSXFragment) => void;
+  JSXMemberExpression?: (node: ESTree.JSXMemberExpression) => void;
+  "JSXMemberExpression:exit"?: (node: ESTree.JSXMemberExpression) => void;
+  JSXNamespacedName?: (node: ESTree.JSXNamespacedName) => void;
+  "JSXNamespacedName:exit"?: (node: ESTree.JSXNamespacedName) => void;
+  JSXOpeningElement?: (node: ESTree.JSXOpeningElement) => void;
+  "JSXOpeningElement:exit"?: (node: ESTree.JSXOpeningElement) => void;
+  JSXSpreadAttribute?: (node: ESTree.JSXSpreadAttribute) => void;
+  "JSXSpreadAttribute:exit"?: (node: ESTree.JSXSpreadAttribute) => void;
+  JSXSpreadChild?: (node: ESTree.JSXSpreadChild) => void;
+  "JSXSpreadChild:exit"?: (node: ESTree.JSXSpreadChild) => void;
+  TSAbstractAccessorProperty?: (node: ESTree.AccessorProperty) => void;
+  "TSAbstractAccessorProperty:exit"?: (node: ESTree.AccessorProperty) => void;
+  TSAbstractMethodDefinition?: (node: ESTree.MethodDefinition) => void;
+  "TSAbstractMethodDefinition:exit"?: (node: ESTree.MethodDefinition) => void;
+  TSAbstractPropertyDefinition?: (node: ESTree.PropertyDefinition) => void;
+  "TSAbstractPropertyDefinition:exit"?: (node: ESTree.PropertyDefinition) => void;
+  TSArrayType?: (node: ESTree.TSArrayType) => void;
+  "TSArrayType:exit"?: (node: ESTree.TSArrayType) => void;
+  TSAsExpression?: (node: ESTree.TSAsExpression) => void;
+  "TSAsExpression:exit"?: (node: ESTree.TSAsExpression) => void;
+  TSCallSignatureDeclaration?: (node: ESTree.TSCallSignatureDeclaration) => void;
+  "TSCallSignatureDeclaration:exit"?: (node: ESTree.TSCallSignatureDeclaration) => void;
+  TSClassImplements?: (node: ESTree.TSClassImplements) => void;
+  "TSClassImplements:exit"?: (node: ESTree.TSClassImplements) => void;
+  TSConditionalType?: (node: ESTree.TSConditionalType) => void;
+  "TSConditionalType:exit"?: (node: ESTree.TSConditionalType) => void;
+  TSConstructSignatureDeclaration?: (node: ESTree.TSConstructSignatureDeclaration) => void;
+  "TSConstructSignatureDeclaration:exit"?: (node: ESTree.TSConstructSignatureDeclaration) => void;
+  TSConstructorType?: (node: ESTree.TSConstructorType) => void;
+  "TSConstructorType:exit"?: (node: ESTree.TSConstructorType) => void;
+  TSDeclareFunction?: (node: ESTree.Function) => void;
+  "TSDeclareFunction:exit"?: (node: ESTree.Function) => void;
+  TSEmptyBodyFunctionExpression?: (node: ESTree.Function) => void;
+  "TSEmptyBodyFunctionExpression:exit"?: (node: ESTree.Function) => void;
+  TSEnumBody?: (node: ESTree.TSEnumBody) => void;
+  "TSEnumBody:exit"?: (node: ESTree.TSEnumBody) => void;
+  TSEnumDeclaration?: (node: ESTree.TSEnumDeclaration) => void;
+  "TSEnumDeclaration:exit"?: (node: ESTree.TSEnumDeclaration) => void;
+  TSEnumMember?: (node: ESTree.TSEnumMember) => void;
+  "TSEnumMember:exit"?: (node: ESTree.TSEnumMember) => void;
+  TSExportAssignment?: (node: ESTree.TSExportAssignment) => void;
+  "TSExportAssignment:exit"?: (node: ESTree.TSExportAssignment) => void;
+  TSExternalModuleReference?: (node: ESTree.TSExternalModuleReference) => void;
+  "TSExternalModuleReference:exit"?: (node: ESTree.TSExternalModuleReference) => void;
+  TSFunctionType?: (node: ESTree.TSFunctionType) => void;
+  "TSFunctionType:exit"?: (node: ESTree.TSFunctionType) => void;
+  TSImportEqualsDeclaration?: (node: ESTree.TSImportEqualsDeclaration) => void;
+  "TSImportEqualsDeclaration:exit"?: (node: ESTree.TSImportEqualsDeclaration) => void;
+  TSImportType?: (node: ESTree.TSImportType) => void;
+  "TSImportType:exit"?: (node: ESTree.TSImportType) => void;
+  TSIndexSignature?: (node: ESTree.TSIndexSignature) => void;
+  "TSIndexSignature:exit"?: (node: ESTree.TSIndexSignature) => void;
+  TSIndexedAccessType?: (node: ESTree.TSIndexedAccessType) => void;
+  "TSIndexedAccessType:exit"?: (node: ESTree.TSIndexedAccessType) => void;
+  TSInferType?: (node: ESTree.TSInferType) => void;
+  "TSInferType:exit"?: (node: ESTree.TSInferType) => void;
+  TSInstantiationExpression?: (node: ESTree.TSInstantiationExpression) => void;
+  "TSInstantiationExpression:exit"?: (node: ESTree.TSInstantiationExpression) => void;
+  TSInterfaceBody?: (node: ESTree.TSInterfaceBody) => void;
+  "TSInterfaceBody:exit"?: (node: ESTree.TSInterfaceBody) => void;
+  TSInterfaceDeclaration?: (node: ESTree.TSInterfaceDeclaration) => void;
+  "TSInterfaceDeclaration:exit"?: (node: ESTree.TSInterfaceDeclaration) => void;
+  TSInterfaceHeritage?: (node: ESTree.TSInterfaceHeritage) => void;
+  "TSInterfaceHeritage:exit"?: (node: ESTree.TSInterfaceHeritage) => void;
+  TSIntersectionType?: (node: ESTree.TSIntersectionType) => void;
+  "TSIntersectionType:exit"?: (node: ESTree.TSIntersectionType) => void;
+  TSJSDocNonNullableType?: (node: ESTree.JSDocNonNullableType) => void;
+  "TSJSDocNonNullableType:exit"?: (node: ESTree.JSDocNonNullableType) => void;
+  TSJSDocNullableType?: (node: ESTree.JSDocNullableType) => void;
+  "TSJSDocNullableType:exit"?: (node: ESTree.JSDocNullableType) => void;
+  TSLiteralType?: (node: ESTree.TSLiteralType) => void;
+  "TSLiteralType:exit"?: (node: ESTree.TSLiteralType) => void;
+  TSMappedType?: (node: ESTree.TSMappedType) => void;
+  "TSMappedType:exit"?: (node: ESTree.TSMappedType) => void;
+  TSMethodSignature?: (node: ESTree.TSMethodSignature) => void;
+  "TSMethodSignature:exit"?: (node: ESTree.TSMethodSignature) => void;
+  TSModuleBlock?: (node: ESTree.TSModuleBlock) => void;
+  "TSModuleBlock:exit"?: (node: ESTree.TSModuleBlock) => void;
+  TSModuleDeclaration?: (node: ESTree.TSModuleDeclaration | ESTree.TSGlobalDeclaration) => void;
+  "TSModuleDeclaration:exit"?: (node: ESTree.TSModuleDeclaration | ESTree.TSGlobalDeclaration) => void;
+  TSNamedTupleMember?: (node: ESTree.TSNamedTupleMember) => void;
+  "TSNamedTupleMember:exit"?: (node: ESTree.TSNamedTupleMember) => void;
+  TSNamespaceExportDeclaration?: (node: ESTree.TSNamespaceExportDeclaration) => void;
+  "TSNamespaceExportDeclaration:exit"?: (node: ESTree.TSNamespaceExportDeclaration) => void;
+  TSNonNullExpression?: (node: ESTree.TSNonNullExpression) => void;
+  "TSNonNullExpression:exit"?: (node: ESTree.TSNonNullExpression) => void;
+  TSOptionalType?: (node: ESTree.TSOptionalType) => void;
+  "TSOptionalType:exit"?: (node: ESTree.TSOptionalType) => void;
+  TSParameterProperty?: (node: ESTree.TSParameterProperty) => void;
+  "TSParameterProperty:exit"?: (node: ESTree.TSParameterProperty) => void;
+  TSParenthesizedType?: (node: ESTree.TSParenthesizedType) => void;
+  "TSParenthesizedType:exit"?: (node: ESTree.TSParenthesizedType) => void;
+  TSPropertySignature?: (node: ESTree.TSPropertySignature) => void;
+  "TSPropertySignature:exit"?: (node: ESTree.TSPropertySignature) => void;
+  TSQualifiedName?: (node: ESTree.TSQualifiedName) => void;
+  "TSQualifiedName:exit"?: (node: ESTree.TSQualifiedName) => void;
+  TSRestType?: (node: ESTree.TSRestType) => void;
+  "TSRestType:exit"?: (node: ESTree.TSRestType) => void;
+  TSSatisfiesExpression?: (node: ESTree.TSSatisfiesExpression) => void;
+  "TSSatisfiesExpression:exit"?: (node: ESTree.TSSatisfiesExpression) => void;
+  TSTemplateLiteralType?: (node: ESTree.TSTemplateLiteralType) => void;
+  "TSTemplateLiteralType:exit"?: (node: ESTree.TSTemplateLiteralType) => void;
+  TSTupleType?: (node: ESTree.TSTupleType) => void;
+  "TSTupleType:exit"?: (node: ESTree.TSTupleType) => void;
+  TSTypeAliasDeclaration?: (node: ESTree.TSTypeAliasDeclaration) => void;
+  "TSTypeAliasDeclaration:exit"?: (node: ESTree.TSTypeAliasDeclaration) => void;
+  TSTypeAnnotation?: (node: ESTree.TSTypeAnnotation) => void;
+  "TSTypeAnnotation:exit"?: (node: ESTree.TSTypeAnnotation) => void;
+  TSTypeAssertion?: (node: ESTree.TSTypeAssertion) => void;
+  "TSTypeAssertion:exit"?: (node: ESTree.TSTypeAssertion) => void;
+  TSTypeLiteral?: (node: ESTree.TSTypeLiteral) => void;
+  "TSTypeLiteral:exit"?: (node: ESTree.TSTypeLiteral) => void;
+  TSTypeOperator?: (node: ESTree.TSTypeOperator) => void;
+  "TSTypeOperator:exit"?: (node: ESTree.TSTypeOperator) => void;
+  TSTypeParameter?: (node: ESTree.TSTypeParameter) => void;
+  "TSTypeParameter:exit"?: (node: ESTree.TSTypeParameter) => void;
+  TSTypeParameterDeclaration?: (node: ESTree.TSTypeParameterDeclaration) => void;
+  "TSTypeParameterDeclaration:exit"?: (node: ESTree.TSTypeParameterDeclaration) => void;
+  TSTypeParameterInstantiation?: (node: ESTree.TSTypeParameterInstantiation) => void;
+  "TSTypeParameterInstantiation:exit"?: (node: ESTree.TSTypeParameterInstantiation) => void;
+  TSTypePredicate?: (node: ESTree.TSTypePredicate) => void;
+  "TSTypePredicate:exit"?: (node: ESTree.TSTypePredicate) => void;
+  TSTypeQuery?: (node: ESTree.TSTypeQuery) => void;
+  "TSTypeQuery:exit"?: (node: ESTree.TSTypeQuery) => void;
+  TSTypeReference?: (node: ESTree.TSTypeReference) => void;
+  "TSTypeReference:exit"?: (node: ESTree.TSTypeReference) => void;
+  TSUnionType?: (node: ESTree.TSUnionType) => void;
+  "TSUnionType:exit"?: (node: ESTree.TSUnionType) => void;
+}
+//#endregion
+//#region src/utils/visitor.d.ts
+/**
+* Visitor object for traversing AST.
+*
+* @category Utilities
+*/
+type VisitorObject = VisitorObject$1;
+/**
+* Visitor class for traversing AST.
+*
+* @example
+* ```ts
+* import { Visitor } from 'rolldown/utils';
+* import { parseSync } from 'rolldown/utils';
+*
+* const result = parseSync(...);
+* const visitor = new Visitor({
+*   VariableDeclaration(path) {
+*     // Do something with the variable declaration
+*   },
+*   "VariableDeclaration:exit"(path) {
+*     // Do something after visiting the variable declaration
+*   }
+* });
+* visitor.visit(result.program);
+* ```
+*
+* @category Utilities
+* @experimental
+*/
+declare class Visitor {
+  #private;
+  constructor(visitor: VisitorObject);
+  visit(program: Program): void;
+}
+//#endregion
+export { type ESTree, type MinifyOptions, type MinifyResult, type ParseResult, type ParserOptions, type TransformOptions, type TransformResult, TsconfigCache, type BindingTsconfigCompilerOptions as TsconfigCompilerOptions, type BindingTsconfigRawOptions as TsconfigRawOptions, Visitor, type VisitorObject, minify, minifySync, parse, parseSync, transform, transformSync };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/utils-index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/utils-index.mjs
new file mode 100644
index 0000000..6386628
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/dist/utils-index.mjs
@@ -0,0 +1,2414 @@
+import { n as parseSync, t as parse } from "./shared/parse-Ch28GO2f.mjs";
+import { a as minify, i as transformSync, o as minifySync, r as transform, t as TsconfigCache } from "./shared/resolve-tsconfig-DkVV0OYf.mjs";
+//#region ../../node_modules/.pnpm/oxc-parser@0.130.0/node_modules/oxc-parser/src-js/generated/visit/walk.js
+function walkNode(node, visitors) {
+	if (node == null) return;
+	if (Array.isArray(node)) {
+		let len = node.length;
+		for (let i = 0; i < len; i++) walkNode(node[i], visitors);
+	} else switch (node.type) {
+		case "DebuggerStatement":
+			walkDebuggerStatement(node, visitors);
+			break;
+		case "EmptyStatement":
+			walkEmptyStatement(node, visitors);
+			break;
+		case "Literal":
+			walkLiteral(node, visitors);
+			break;
+		case "PrivateIdentifier":
+			walkPrivateIdentifier(node, visitors);
+			break;
+		case "Super":
+			walkSuper(node, visitors);
+			break;
+		case "TemplateElement":
+			walkTemplateElement(node, visitors);
+			break;
+		case "ThisExpression":
+			walkThisExpression(node, visitors);
+			break;
+		case "JSXClosingFragment":
+			walkJSXClosingFragment(node, visitors);
+			break;
+		case "JSXEmptyExpression":
+			walkJSXEmptyExpression(node, visitors);
+			break;
+		case "JSXIdentifier":
+			walkJSXIdentifier(node, visitors);
+			break;
+		case "JSXOpeningFragment":
+			walkJSXOpeningFragment(node, visitors);
+			break;
+		case "JSXText":
+			walkJSXText(node, visitors);
+			break;
+		case "TSAnyKeyword":
+			walkTSAnyKeyword(node, visitors);
+			break;
+		case "TSBigIntKeyword":
+			walkTSBigIntKeyword(node, visitors);
+			break;
+		case "TSBooleanKeyword":
+			walkTSBooleanKeyword(node, visitors);
+			break;
+		case "TSIntrinsicKeyword":
+			walkTSIntrinsicKeyword(node, visitors);
+			break;
+		case "TSJSDocUnknownType":
+			walkTSJSDocUnknownType(node, visitors);
+			break;
+		case "TSNeverKeyword":
+			walkTSNeverKeyword(node, visitors);
+			break;
+		case "TSNullKeyword":
+			walkTSNullKeyword(node, visitors);
+			break;
+		case "TSNumberKeyword":
+			walkTSNumberKeyword(node, visitors);
+			break;
+		case "TSObjectKeyword":
+			walkTSObjectKeyword(node, visitors);
+			break;
+		case "TSStringKeyword":
+			walkTSStringKeyword(node, visitors);
+			break;
+		case "TSSymbolKeyword":
+			walkTSSymbolKeyword(node, visitors);
+			break;
+		case "TSThisType":
+			walkTSThisType(node, visitors);
+			break;
+		case "TSUndefinedKeyword":
+			walkTSUndefinedKeyword(node, visitors);
+			break;
+		case "TSUnknownKeyword":
+			walkTSUnknownKeyword(node, visitors);
+			break;
+		case "TSVoidKeyword":
+			walkTSVoidKeyword(node, visitors);
+			break;
+		case "AccessorProperty":
+			walkAccessorProperty(node, visitors);
+			break;
+		case "ArrayExpression":
+			walkArrayExpression(node, visitors);
+			break;
+		case "ArrayPattern":
+			walkArrayPattern(node, visitors);
+			break;
+		case "ArrowFunctionExpression":
+			walkArrowFunctionExpression(node, visitors);
+			break;
+		case "AssignmentExpression":
+			walkAssignmentExpression(node, visitors);
+			break;
+		case "AssignmentPattern":
+			walkAssignmentPattern(node, visitors);
+			break;
+		case "AwaitExpression":
+			walkAwaitExpression(node, visitors);
+			break;
+		case "BinaryExpression":
+			walkBinaryExpression(node, visitors);
+			break;
+		case "BlockStatement":
+			walkBlockStatement(node, visitors);
+			break;
+		case "BreakStatement":
+			walkBreakStatement(node, visitors);
+			break;
+		case "CallExpression":
+			walkCallExpression(node, visitors);
+			break;
+		case "CatchClause":
+			walkCatchClause(node, visitors);
+			break;
+		case "ChainExpression":
+			walkChainExpression(node, visitors);
+			break;
+		case "ClassBody":
+			walkClassBody(node, visitors);
+			break;
+		case "ClassDeclaration":
+			walkClassDeclaration(node, visitors);
+			break;
+		case "ClassExpression":
+			walkClassExpression(node, visitors);
+			break;
+		case "ConditionalExpression":
+			walkConditionalExpression(node, visitors);
+			break;
+		case "ContinueStatement":
+			walkContinueStatement(node, visitors);
+			break;
+		case "Decorator":
+			walkDecorator(node, visitors);
+			break;
+		case "DoWhileStatement":
+			walkDoWhileStatement(node, visitors);
+			break;
+		case "ExportAllDeclaration":
+			walkExportAllDeclaration(node, visitors);
+			break;
+		case "ExportDefaultDeclaration":
+			walkExportDefaultDeclaration(node, visitors);
+			break;
+		case "ExportNamedDeclaration":
+			walkExportNamedDeclaration(node, visitors);
+			break;
+		case "ExportSpecifier":
+			walkExportSpecifier(node, visitors);
+			break;
+		case "ExpressionStatement":
+			walkExpressionStatement(node, visitors);
+			break;
+		case "ForInStatement":
+			walkForInStatement(node, visitors);
+			break;
+		case "ForOfStatement":
+			walkForOfStatement(node, visitors);
+			break;
+		case "ForStatement":
+			walkForStatement(node, visitors);
+			break;
+		case "FunctionDeclaration":
+			walkFunctionDeclaration(node, visitors);
+			break;
+		case "FunctionExpression":
+			walkFunctionExpression(node, visitors);
+			break;
+		case "Identifier":
+			walkIdentifier(node, visitors);
+			break;
+		case "IfStatement":
+			walkIfStatement(node, visitors);
+			break;
+		case "ImportAttribute":
+			walkImportAttribute(node, visitors);
+			break;
+		case "ImportDeclaration":
+			walkImportDeclaration(node, visitors);
+			break;
+		case "ImportDefaultSpecifier":
+			walkImportDefaultSpecifier(node, visitors);
+			break;
+		case "ImportExpression":
+			walkImportExpression(node, visitors);
+			break;
+		case "ImportNamespaceSpecifier":
+			walkImportNamespaceSpecifier(node, visitors);
+			break;
+		case "ImportSpecifier":
+			walkImportSpecifier(node, visitors);
+			break;
+		case "LabeledStatement":
+			walkLabeledStatement(node, visitors);
+			break;
+		case "LogicalExpression":
+			walkLogicalExpression(node, visitors);
+			break;
+		case "MemberExpression":
+			walkMemberExpression(node, visitors);
+			break;
+		case "MetaProperty":
+			walkMetaProperty(node, visitors);
+			break;
+		case "MethodDefinition":
+			walkMethodDefinition(node, visitors);
+			break;
+		case "NewExpression":
+			walkNewExpression(node, visitors);
+			break;
+		case "ObjectExpression":
+			walkObjectExpression(node, visitors);
+			break;
+		case "ObjectPattern":
+			walkObjectPattern(node, visitors);
+			break;
+		case "ParenthesizedExpression":
+			walkParenthesizedExpression(node, visitors);
+			break;
+		case "Program":
+			walkProgram(node, visitors);
+			break;
+		case "Property":
+			walkProperty(node, visitors);
+			break;
+		case "PropertyDefinition":
+			walkPropertyDefinition(node, visitors);
+			break;
+		case "RestElement":
+			walkRestElement(node, visitors);
+			break;
+		case "ReturnStatement":
+			walkReturnStatement(node, visitors);
+			break;
+		case "SequenceExpression":
+			walkSequenceExpression(node, visitors);
+			break;
+		case "SpreadElement":
+			walkSpreadElement(node, visitors);
+			break;
+		case "StaticBlock":
+			walkStaticBlock(node, visitors);
+			break;
+		case "SwitchCase":
+			walkSwitchCase(node, visitors);
+			break;
+		case "SwitchStatement":
+			walkSwitchStatement(node, visitors);
+			break;
+		case "TaggedTemplateExpression":
+			walkTaggedTemplateExpression(node, visitors);
+			break;
+		case "TemplateLiteral":
+			walkTemplateLiteral(node, visitors);
+			break;
+		case "ThrowStatement":
+			walkThrowStatement(node, visitors);
+			break;
+		case "TryStatement":
+			walkTryStatement(node, visitors);
+			break;
+		case "UnaryExpression":
+			walkUnaryExpression(node, visitors);
+			break;
+		case "UpdateExpression":
+			walkUpdateExpression(node, visitors);
+			break;
+		case "V8IntrinsicExpression":
+			walkV8IntrinsicExpression(node, visitors);
+			break;
+		case "VariableDeclaration":
+			walkVariableDeclaration(node, visitors);
+			break;
+		case "VariableDeclarator":
+			walkVariableDeclarator(node, visitors);
+			break;
+		case "WhileStatement":
+			walkWhileStatement(node, visitors);
+			break;
+		case "WithStatement":
+			walkWithStatement(node, visitors);
+			break;
+		case "YieldExpression":
+			walkYieldExpression(node, visitors);
+			break;
+		case "JSXAttribute":
+			walkJSXAttribute(node, visitors);
+			break;
+		case "JSXClosingElement":
+			walkJSXClosingElement(node, visitors);
+			break;
+		case "JSXElement":
+			walkJSXElement(node, visitors);
+			break;
+		case "JSXExpressionContainer":
+			walkJSXExpressionContainer(node, visitors);
+			break;
+		case "JSXFragment":
+			walkJSXFragment(node, visitors);
+			break;
+		case "JSXMemberExpression":
+			walkJSXMemberExpression(node, visitors);
+			break;
+		case "JSXNamespacedName":
+			walkJSXNamespacedName(node, visitors);
+			break;
+		case "JSXOpeningElement":
+			walkJSXOpeningElement(node, visitors);
+			break;
+		case "JSXSpreadAttribute":
+			walkJSXSpreadAttribute(node, visitors);
+			break;
+		case "JSXSpreadChild":
+			walkJSXSpreadChild(node, visitors);
+			break;
+		case "TSAbstractAccessorProperty":
+			walkTSAbstractAccessorProperty(node, visitors);
+			break;
+		case "TSAbstractMethodDefinition":
+			walkTSAbstractMethodDefinition(node, visitors);
+			break;
+		case "TSAbstractPropertyDefinition":
+			walkTSAbstractPropertyDefinition(node, visitors);
+			break;
+		case "TSArrayType":
+			walkTSArrayType(node, visitors);
+			break;
+		case "TSAsExpression":
+			walkTSAsExpression(node, visitors);
+			break;
+		case "TSCallSignatureDeclaration":
+			walkTSCallSignatureDeclaration(node, visitors);
+			break;
+		case "TSClassImplements":
+			walkTSClassImplements(node, visitors);
+			break;
+		case "TSConditionalType":
+			walkTSConditionalType(node, visitors);
+			break;
+		case "TSConstructSignatureDeclaration":
+			walkTSConstructSignatureDeclaration(node, visitors);
+			break;
+		case "TSConstructorType":
+			walkTSConstructorType(node, visitors);
+			break;
+		case "TSDeclareFunction":
+			walkTSDeclareFunction(node, visitors);
+			break;
+		case "TSEmptyBodyFunctionExpression":
+			walkTSEmptyBodyFunctionExpression(node, visitors);
+			break;
+		case "TSEnumBody":
+			walkTSEnumBody(node, visitors);
+			break;
+		case "TSEnumDeclaration":
+			walkTSEnumDeclaration(node, visitors);
+			break;
+		case "TSEnumMember":
+			walkTSEnumMember(node, visitors);
+			break;
+		case "TSExportAssignment":
+			walkTSExportAssignment(node, visitors);
+			break;
+		case "TSExternalModuleReference":
+			walkTSExternalModuleReference(node, visitors);
+			break;
+		case "TSFunctionType":
+			walkTSFunctionType(node, visitors);
+			break;
+		case "TSImportEqualsDeclaration":
+			walkTSImportEqualsDeclaration(node, visitors);
+			break;
+		case "TSImportType":
+			walkTSImportType(node, visitors);
+			break;
+		case "TSIndexSignature":
+			walkTSIndexSignature(node, visitors);
+			break;
+		case "TSIndexedAccessType":
+			walkTSIndexedAccessType(node, visitors);
+			break;
+		case "TSInferType":
+			walkTSInferType(node, visitors);
+			break;
+		case "TSInstantiationExpression":
+			walkTSInstantiationExpression(node, visitors);
+			break;
+		case "TSInterfaceBody":
+			walkTSInterfaceBody(node, visitors);
+			break;
+		case "TSInterfaceDeclaration":
+			walkTSInterfaceDeclaration(node, visitors);
+			break;
+		case "TSInterfaceHeritage":
+			walkTSInterfaceHeritage(node, visitors);
+			break;
+		case "TSIntersectionType":
+			walkTSIntersectionType(node, visitors);
+			break;
+		case "TSJSDocNonNullableType":
+			walkTSJSDocNonNullableType(node, visitors);
+			break;
+		case "TSJSDocNullableType":
+			walkTSJSDocNullableType(node, visitors);
+			break;
+		case "TSLiteralType":
+			walkTSLiteralType(node, visitors);
+			break;
+		case "TSMappedType":
+			walkTSMappedType(node, visitors);
+			break;
+		case "TSMethodSignature":
+			walkTSMethodSignature(node, visitors);
+			break;
+		case "TSModuleBlock":
+			walkTSModuleBlock(node, visitors);
+			break;
+		case "TSModuleDeclaration":
+			walkTSModuleDeclaration(node, visitors);
+			break;
+		case "TSNamedTupleMember":
+			walkTSNamedTupleMember(node, visitors);
+			break;
+		case "TSNamespaceExportDeclaration":
+			walkTSNamespaceExportDeclaration(node, visitors);
+			break;
+		case "TSNonNullExpression":
+			walkTSNonNullExpression(node, visitors);
+			break;
+		case "TSOptionalType":
+			walkTSOptionalType(node, visitors);
+			break;
+		case "TSParameterProperty":
+			walkTSParameterProperty(node, visitors);
+			break;
+		case "TSParenthesizedType":
+			walkTSParenthesizedType(node, visitors);
+			break;
+		case "TSPropertySignature":
+			walkTSPropertySignature(node, visitors);
+			break;
+		case "TSQualifiedName":
+			walkTSQualifiedName(node, visitors);
+			break;
+		case "TSRestType":
+			walkTSRestType(node, visitors);
+			break;
+		case "TSSatisfiesExpression":
+			walkTSSatisfiesExpression(node, visitors);
+			break;
+		case "TSTemplateLiteralType":
+			walkTSTemplateLiteralType(node, visitors);
+			break;
+		case "TSTupleType":
+			walkTSTupleType(node, visitors);
+			break;
+		case "TSTypeAliasDeclaration":
+			walkTSTypeAliasDeclaration(node, visitors);
+			break;
+		case "TSTypeAnnotation":
+			walkTSTypeAnnotation(node, visitors);
+			break;
+		case "TSTypeAssertion":
+			walkTSTypeAssertion(node, visitors);
+			break;
+		case "TSTypeLiteral":
+			walkTSTypeLiteral(node, visitors);
+			break;
+		case "TSTypeOperator":
+			walkTSTypeOperator(node, visitors);
+			break;
+		case "TSTypeParameter":
+			walkTSTypeParameter(node, visitors);
+			break;
+		case "TSTypeParameterDeclaration":
+			walkTSTypeParameterDeclaration(node, visitors);
+			break;
+		case "TSTypeParameterInstantiation":
+			walkTSTypeParameterInstantiation(node, visitors);
+			break;
+		case "TSTypePredicate":
+			walkTSTypePredicate(node, visitors);
+			break;
+		case "TSTypeQuery":
+			walkTSTypeQuery(node, visitors);
+			break;
+		case "TSTypeReference":
+			walkTSTypeReference(node, visitors);
+			break;
+		case "TSUnionType":
+			walkTSUnionType(node, visitors);
+			break;
+	}
+}
+function walkDebuggerStatement(node, visitors) {
+	let visit = visitors[0];
+	visit !== null && visit(node);
+}
+function walkEmptyStatement(node, visitors) {
+	let visit = visitors[1];
+	visit !== null && visit(node);
+}
+function walkLiteral(node, visitors) {
+	let visit = visitors[2];
+	visit !== null && visit(node);
+}
+function walkPrivateIdentifier(node, visitors) {
+	let visit = visitors[3];
+	visit !== null && visit(node);
+}
+function walkSuper(node, visitors) {
+	let visit = visitors[4];
+	visit !== null && visit(node);
+}
+function walkTemplateElement(node, visitors) {
+	let visit = visitors[5];
+	visit !== null && visit(node);
+}
+function walkThisExpression(node, visitors) {
+	let visit = visitors[6];
+	visit !== null && visit(node);
+}
+function walkJSXClosingFragment(node, visitors) {
+	let visit = visitors[7];
+	visit !== null && visit(node);
+}
+function walkJSXEmptyExpression(node, visitors) {
+	let visit = visitors[8];
+	visit !== null && visit(node);
+}
+function walkJSXIdentifier(node, visitors) {
+	let visit = visitors[9];
+	visit !== null && visit(node);
+}
+function walkJSXOpeningFragment(node, visitors) {
+	let visit = visitors[10];
+	visit !== null && visit(node);
+}
+function walkJSXText(node, visitors) {
+	let visit = visitors[11];
+	visit !== null && visit(node);
+}
+function walkTSAnyKeyword(node, visitors) {
+	let visit = visitors[12];
+	visit !== null && visit(node);
+}
+function walkTSBigIntKeyword(node, visitors) {
+	let visit = visitors[13];
+	visit !== null && visit(node);
+}
+function walkTSBooleanKeyword(node, visitors) {
+	let visit = visitors[14];
+	visit !== null && visit(node);
+}
+function walkTSIntrinsicKeyword(node, visitors) {
+	let visit = visitors[15];
+	visit !== null && visit(node);
+}
+function walkTSJSDocUnknownType(node, visitors) {
+	let visit = visitors[16];
+	visit !== null && visit(node);
+}
+function walkTSNeverKeyword(node, visitors) {
+	let visit = visitors[17];
+	visit !== null && visit(node);
+}
+function walkTSNullKeyword(node, visitors) {
+	let visit = visitors[18];
+	visit !== null && visit(node);
+}
+function walkTSNumberKeyword(node, visitors) {
+	let visit = visitors[19];
+	visit !== null && visit(node);
+}
+function walkTSObjectKeyword(node, visitors) {
+	let visit = visitors[20];
+	visit !== null && visit(node);
+}
+function walkTSStringKeyword(node, visitors) {
+	let visit = visitors[21];
+	visit !== null && visit(node);
+}
+function walkTSSymbolKeyword(node, visitors) {
+	let visit = visitors[22];
+	visit !== null && visit(node);
+}
+function walkTSThisType(node, visitors) {
+	let visit = visitors[23];
+	visit !== null && visit(node);
+}
+function walkTSUndefinedKeyword(node, visitors) {
+	let visit = visitors[24];
+	visit !== null && visit(node);
+}
+function walkTSUnknownKeyword(node, visitors) {
+	let visit = visitors[25];
+	visit !== null && visit(node);
+}
+function walkTSVoidKeyword(node, visitors) {
+	let visit = visitors[26];
+	visit !== null && visit(node);
+}
+function walkAccessorProperty(node, visitors) {
+	let enterExit = visitors[27], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.key, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	walkNode(node.value, visitors);
+	exit !== null && exit(node);
+}
+function walkArrayExpression(node, visitors) {
+	let enterExit = visitors[28], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.elements, visitors);
+	exit !== null && exit(node);
+}
+function walkArrayPattern(node, visitors) {
+	let enterExit = visitors[29], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.elements, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkArrowFunctionExpression(node, visitors) {
+	let enterExit = visitors[30], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkAssignmentExpression(node, visitors) {
+	let enterExit = visitors[31], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.left, visitors);
+	walkNode(node.right, visitors);
+	exit !== null && exit(node);
+}
+function walkAssignmentPattern(node, visitors) {
+	let enterExit = visitors[32], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.left, visitors);
+	walkNode(node.right, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkAwaitExpression(node, visitors) {
+	let enterExit = visitors[33], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.argument, visitors);
+	exit !== null && exit(node);
+}
+function walkBinaryExpression(node, visitors) {
+	let enterExit = visitors[34], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.left, visitors);
+	walkNode(node.right, visitors);
+	exit !== null && exit(node);
+}
+function walkBlockStatement(node, visitors) {
+	let enterExit = visitors[35], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkBreakStatement(node, visitors) {
+	let enterExit = visitors[36], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.label, visitors);
+	exit !== null && exit(node);
+}
+function walkCallExpression(node, visitors) {
+	let enterExit = visitors[37], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.callee, visitors);
+	walkNode(node.typeArguments, visitors);
+	walkNode(node.arguments, visitors);
+	exit !== null && exit(node);
+}
+function walkCatchClause(node, visitors) {
+	let enterExit = visitors[38], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.param, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkChainExpression(node, visitors) {
+	let enterExit = visitors[39], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkClassBody(node, visitors) {
+	let enterExit = visitors[40], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkClassDeclaration(node, visitors) {
+	let enterExit = visitors[41], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.id, visitors);
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.superClass, visitors);
+	walkNode(node.superTypeArguments, visitors);
+	walkNode(node.implements, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkClassExpression(node, visitors) {
+	let enterExit = visitors[42], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.id, visitors);
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.superClass, visitors);
+	walkNode(node.superTypeArguments, visitors);
+	walkNode(node.implements, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkConditionalExpression(node, visitors) {
+	let enterExit = visitors[43], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.test, visitors);
+	walkNode(node.consequent, visitors);
+	walkNode(node.alternate, visitors);
+	exit !== null && exit(node);
+}
+function walkContinueStatement(node, visitors) {
+	let enterExit = visitors[44], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.label, visitors);
+	exit !== null && exit(node);
+}
+function walkDecorator(node, visitors) {
+	let enterExit = visitors[45], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkDoWhileStatement(node, visitors) {
+	let enterExit = visitors[46], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.body, visitors);
+	walkNode(node.test, visitors);
+	exit !== null && exit(node);
+}
+function walkExportAllDeclaration(node, visitors) {
+	let enterExit = visitors[47], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.exported, visitors);
+	walkNode(node.source, visitors);
+	walkNode(node.attributes, visitors);
+	exit !== null && exit(node);
+}
+function walkExportDefaultDeclaration(node, visitors) {
+	let enterExit = visitors[48], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.declaration, visitors);
+	exit !== null && exit(node);
+}
+function walkExportNamedDeclaration(node, visitors) {
+	let enterExit = visitors[49], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.declaration, visitors);
+	walkNode(node.specifiers, visitors);
+	walkNode(node.source, visitors);
+	walkNode(node.attributes, visitors);
+	exit !== null && exit(node);
+}
+function walkExportSpecifier(node, visitors) {
+	let enterExit = visitors[50], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.local, visitors);
+	walkNode(node.exported, visitors);
+	exit !== null && exit(node);
+}
+function walkExpressionStatement(node, visitors) {
+	let enterExit = visitors[51], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkForInStatement(node, visitors) {
+	let enterExit = visitors[52], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.left, visitors);
+	walkNode(node.right, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkForOfStatement(node, visitors) {
+	let enterExit = visitors[53], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.left, visitors);
+	walkNode(node.right, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkForStatement(node, visitors) {
+	let enterExit = visitors[54], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.init, visitors);
+	walkNode(node.test, visitors);
+	walkNode(node.update, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkFunctionDeclaration(node, visitors) {
+	let enterExit = visitors[55], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkFunctionExpression(node, visitors) {
+	let enterExit = visitors[56], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkIdentifier(node, visitors) {
+	let enterExit = visitors[57], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkIfStatement(node, visitors) {
+	let enterExit = visitors[58], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.test, visitors);
+	walkNode(node.consequent, visitors);
+	walkNode(node.alternate, visitors);
+	exit !== null && exit(node);
+}
+function walkImportAttribute(node, visitors) {
+	let enterExit = visitors[59], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.key, visitors);
+	walkNode(node.value, visitors);
+	exit !== null && exit(node);
+}
+function walkImportDeclaration(node, visitors) {
+	let enterExit = visitors[60], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.specifiers, visitors);
+	walkNode(node.source, visitors);
+	walkNode(node.attributes, visitors);
+	exit !== null && exit(node);
+}
+function walkImportDefaultSpecifier(node, visitors) {
+	let enterExit = visitors[61], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.local, visitors);
+	exit !== null && exit(node);
+}
+function walkImportExpression(node, visitors) {
+	let enterExit = visitors[62], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.source, visitors);
+	walkNode(node.options, visitors);
+	exit !== null && exit(node);
+}
+function walkImportNamespaceSpecifier(node, visitors) {
+	let enterExit = visitors[63], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.local, visitors);
+	exit !== null && exit(node);
+}
+function walkImportSpecifier(node, visitors) {
+	let enterExit = visitors[64], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.imported, visitors);
+	walkNode(node.local, visitors);
+	exit !== null && exit(node);
+}
+function walkLabeledStatement(node, visitors) {
+	let enterExit = visitors[65], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.label, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkLogicalExpression(node, visitors) {
+	let enterExit = visitors[66], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.left, visitors);
+	walkNode(node.right, visitors);
+	exit !== null && exit(node);
+}
+function walkMemberExpression(node, visitors) {
+	let enterExit = visitors[67], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.object, visitors);
+	walkNode(node.property, visitors);
+	exit !== null && exit(node);
+}
+function walkMetaProperty(node, visitors) {
+	let enterExit = visitors[68], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.meta, visitors);
+	walkNode(node.property, visitors);
+	exit !== null && exit(node);
+}
+function walkMethodDefinition(node, visitors) {
+	let enterExit = visitors[69], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.key, visitors);
+	walkNode(node.value, visitors);
+	exit !== null && exit(node);
+}
+function walkNewExpression(node, visitors) {
+	let enterExit = visitors[70], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.callee, visitors);
+	walkNode(node.typeArguments, visitors);
+	walkNode(node.arguments, visitors);
+	exit !== null && exit(node);
+}
+function walkObjectExpression(node, visitors) {
+	let enterExit = visitors[71], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.properties, visitors);
+	exit !== null && exit(node);
+}
+function walkObjectPattern(node, visitors) {
+	let enterExit = visitors[72], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.properties, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkParenthesizedExpression(node, visitors) {
+	let enterExit = visitors[73], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkProgram(node, visitors) {
+	let enterExit = visitors[74], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkProperty(node, visitors) {
+	let enterExit = visitors[75], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.key, visitors);
+	walkNode(node.value, visitors);
+	exit !== null && exit(node);
+}
+function walkPropertyDefinition(node, visitors) {
+	let enterExit = visitors[76], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.key, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	walkNode(node.value, visitors);
+	exit !== null && exit(node);
+}
+function walkRestElement(node, visitors) {
+	let enterExit = visitors[77], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.argument, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkReturnStatement(node, visitors) {
+	let enterExit = visitors[78], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.argument, visitors);
+	exit !== null && exit(node);
+}
+function walkSequenceExpression(node, visitors) {
+	let enterExit = visitors[79], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expressions, visitors);
+	exit !== null && exit(node);
+}
+function walkSpreadElement(node, visitors) {
+	let enterExit = visitors[80], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.argument, visitors);
+	exit !== null && exit(node);
+}
+function walkStaticBlock(node, visitors) {
+	let enterExit = visitors[81], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkSwitchCase(node, visitors) {
+	let enterExit = visitors[82], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.test, visitors);
+	walkNode(node.consequent, visitors);
+	exit !== null && exit(node);
+}
+function walkSwitchStatement(node, visitors) {
+	let enterExit = visitors[83], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.discriminant, visitors);
+	walkNode(node.cases, visitors);
+	exit !== null && exit(node);
+}
+function walkTaggedTemplateExpression(node, visitors) {
+	let enterExit = visitors[84], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.tag, visitors);
+	walkNode(node.typeArguments, visitors);
+	walkNode(node.quasi, visitors);
+	exit !== null && exit(node);
+}
+function walkTemplateLiteral(node, visitors) {
+	let enterExit = visitors[85], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.quasis, visitors);
+	walkNode(node.expressions, visitors);
+	exit !== null && exit(node);
+}
+function walkThrowStatement(node, visitors) {
+	let enterExit = visitors[86], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.argument, visitors);
+	exit !== null && exit(node);
+}
+function walkTryStatement(node, visitors) {
+	let enterExit = visitors[87], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.block, visitors);
+	walkNode(node.handler, visitors);
+	walkNode(node.finalizer, visitors);
+	exit !== null && exit(node);
+}
+function walkUnaryExpression(node, visitors) {
+	let enterExit = visitors[88], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.argument, visitors);
+	exit !== null && exit(node);
+}
+function walkUpdateExpression(node, visitors) {
+	let enterExit = visitors[89], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.argument, visitors);
+	exit !== null && exit(node);
+}
+function walkV8IntrinsicExpression(node, visitors) {
+	let enterExit = visitors[90], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.name, visitors);
+	walkNode(node.arguments, visitors);
+	exit !== null && exit(node);
+}
+function walkVariableDeclaration(node, visitors) {
+	let enterExit = visitors[91], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.declarations, visitors);
+	exit !== null && exit(node);
+}
+function walkVariableDeclarator(node, visitors) {
+	let enterExit = visitors[92], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.init, visitors);
+	exit !== null && exit(node);
+}
+function walkWhileStatement(node, visitors) {
+	let enterExit = visitors[93], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.test, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkWithStatement(node, visitors) {
+	let enterExit = visitors[94], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.object, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkYieldExpression(node, visitors) {
+	let enterExit = visitors[95], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.argument, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXAttribute(node, visitors) {
+	let enterExit = visitors[96], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.name, visitors);
+	walkNode(node.value, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXClosingElement(node, visitors) {
+	let enterExit = visitors[97], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.name, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXElement(node, visitors) {
+	let enterExit = visitors[98], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.openingElement, visitors);
+	walkNode(node.children, visitors);
+	walkNode(node.closingElement, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXExpressionContainer(node, visitors) {
+	let enterExit = visitors[99], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXFragment(node, visitors) {
+	let enterExit = visitors[100], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.openingFragment, visitors);
+	walkNode(node.children, visitors);
+	walkNode(node.closingFragment, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXMemberExpression(node, visitors) {
+	let enterExit = visitors[101], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.object, visitors);
+	walkNode(node.property, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXNamespacedName(node, visitors) {
+	let enterExit = visitors[102], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.namespace, visitors);
+	walkNode(node.name, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXOpeningElement(node, visitors) {
+	let enterExit = visitors[103], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.name, visitors);
+	walkNode(node.typeArguments, visitors);
+	walkNode(node.attributes, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXSpreadAttribute(node, visitors) {
+	let enterExit = visitors[104], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.argument, visitors);
+	exit !== null && exit(node);
+}
+function walkJSXSpreadChild(node, visitors) {
+	let enterExit = visitors[105], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkTSAbstractAccessorProperty(node, visitors) {
+	let enterExit = visitors[106], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.key, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSAbstractMethodDefinition(node, visitors) {
+	let enterExit = visitors[107], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.key, visitors);
+	walkNode(node.value, visitors);
+	exit !== null && exit(node);
+}
+function walkTSAbstractPropertyDefinition(node, visitors) {
+	let enterExit = visitors[108], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.key, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSArrayType(node, visitors) {
+	let enterExit = visitors[109], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.elementType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSAsExpression(node, visitors) {
+	let enterExit = visitors[110], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSCallSignatureDeclaration(node, visitors) {
+	let enterExit = visitors[111], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSClassImplements(node, visitors) {
+	let enterExit = visitors[112], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	walkNode(node.typeArguments, visitors);
+	exit !== null && exit(node);
+}
+function walkTSConditionalType(node, visitors) {
+	let enterExit = visitors[113], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.checkType, visitors);
+	walkNode(node.extendsType, visitors);
+	walkNode(node.trueType, visitors);
+	walkNode(node.falseType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSConstructSignatureDeclaration(node, visitors) {
+	let enterExit = visitors[114], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSConstructorType(node, visitors) {
+	let enterExit = visitors[115], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSDeclareFunction(node, visitors) {
+	let enterExit = visitors[116], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkTSEmptyBodyFunctionExpression(node, visitors) {
+	let enterExit = visitors[117], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSEnumBody(node, visitors) {
+	let enterExit = visitors[118], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.members, visitors);
+	exit !== null && exit(node);
+}
+function walkTSEnumDeclaration(node, visitors) {
+	let enterExit = visitors[119], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkTSEnumMember(node, visitors) {
+	let enterExit = visitors[120], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.initializer, visitors);
+	exit !== null && exit(node);
+}
+function walkTSExportAssignment(node, visitors) {
+	let enterExit = visitors[121], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkTSExternalModuleReference(node, visitors) {
+	let enterExit = visitors[122], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkTSFunctionType(node, visitors) {
+	let enterExit = visitors[123], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSImportEqualsDeclaration(node, visitors) {
+	let enterExit = visitors[124], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.moduleReference, visitors);
+	exit !== null && exit(node);
+}
+function walkTSImportType(node, visitors) {
+	let enterExit = visitors[125], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.source, visitors);
+	walkNode(node.options, visitors);
+	walkNode(node.qualifier, visitors);
+	walkNode(node.typeArguments, visitors);
+	exit !== null && exit(node);
+}
+function walkTSIndexSignature(node, visitors) {
+	let enterExit = visitors[126], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.parameters, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSIndexedAccessType(node, visitors) {
+	let enterExit = visitors[127], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.objectType, visitors);
+	walkNode(node.indexType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSInferType(node, visitors) {
+	let enterExit = visitors[128], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeParameter, visitors);
+	exit !== null && exit(node);
+}
+function walkTSInstantiationExpression(node, visitors) {
+	let enterExit = visitors[129], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	walkNode(node.typeArguments, visitors);
+	exit !== null && exit(node);
+}
+function walkTSInterfaceBody(node, visitors) {
+	let enterExit = visitors[130], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkTSInterfaceDeclaration(node, visitors) {
+	let enterExit = visitors[131], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.extends, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkTSInterfaceHeritage(node, visitors) {
+	let enterExit = visitors[132], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	walkNode(node.typeArguments, visitors);
+	exit !== null && exit(node);
+}
+function walkTSIntersectionType(node, visitors) {
+	let enterExit = visitors[133], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.types, visitors);
+	exit !== null && exit(node);
+}
+function walkTSJSDocNonNullableType(node, visitors) {
+	let enterExit = visitors[134], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSJSDocNullableType(node, visitors) {
+	let enterExit = visitors[135], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSLiteralType(node, visitors) {
+	let enterExit = visitors[136], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.literal, visitors);
+	exit !== null && exit(node);
+}
+function walkTSMappedType(node, visitors) {
+	let enterExit = visitors[137], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.key, visitors);
+	walkNode(node.constraint, visitors);
+	walkNode(node.nameType, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSMethodSignature(node, visitors) {
+	let enterExit = visitors[138], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.key, visitors);
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.params, visitors);
+	walkNode(node.returnType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSModuleBlock(node, visitors) {
+	let enterExit = visitors[139], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkTSModuleDeclaration(node, visitors) {
+	let enterExit = visitors[140], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.body, visitors);
+	exit !== null && exit(node);
+}
+function walkTSNamedTupleMember(node, visitors) {
+	let enterExit = visitors[141], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.label, visitors);
+	walkNode(node.elementType, visitors);
+	exit !== null && exit(node);
+}
+function walkTSNamespaceExportDeclaration(node, visitors) {
+	let enterExit = visitors[142], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	exit !== null && exit(node);
+}
+function walkTSNonNullExpression(node, visitors) {
+	let enterExit = visitors[143], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkTSOptionalType(node, visitors) {
+	let enterExit = visitors[144], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSParameterProperty(node, visitors) {
+	let enterExit = visitors[145], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.decorators, visitors);
+	walkNode(node.parameter, visitors);
+	exit !== null && exit(node);
+}
+function walkTSParenthesizedType(node, visitors) {
+	let enterExit = visitors[146], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSPropertySignature(node, visitors) {
+	let enterExit = visitors[147], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.key, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSQualifiedName(node, visitors) {
+	let enterExit = visitors[148], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.left, visitors);
+	walkNode(node.right, visitors);
+	exit !== null && exit(node);
+}
+function walkTSRestType(node, visitors) {
+	let enterExit = visitors[149], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSSatisfiesExpression(node, visitors) {
+	let enterExit = visitors[150], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.expression, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTemplateLiteralType(node, visitors) {
+	let enterExit = visitors[151], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.quasis, visitors);
+	walkNode(node.types, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTupleType(node, visitors) {
+	let enterExit = visitors[152], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.elementTypes, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeAliasDeclaration(node, visitors) {
+	let enterExit = visitors[153], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.id, visitors);
+	walkNode(node.typeParameters, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeAnnotation(node, visitors) {
+	let enterExit = visitors[154], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeAssertion(node, visitors) {
+	let enterExit = visitors[155], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeAnnotation, visitors);
+	walkNode(node.expression, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeLiteral(node, visitors) {
+	let enterExit = visitors[156], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.members, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeOperator(node, visitors) {
+	let enterExit = visitors[157], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeParameter(node, visitors) {
+	let enterExit = visitors[158], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.name, visitors);
+	walkNode(node.constraint, visitors);
+	walkNode(node.default, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeParameterDeclaration(node, visitors) {
+	let enterExit = visitors[159], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.params, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeParameterInstantiation(node, visitors) {
+	let enterExit = visitors[160], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.params, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypePredicate(node, visitors) {
+	let enterExit = visitors[161], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.parameterName, visitors);
+	walkNode(node.typeAnnotation, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeQuery(node, visitors) {
+	let enterExit = visitors[162], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.exprName, visitors);
+	walkNode(node.typeArguments, visitors);
+	exit !== null && exit(node);
+}
+function walkTSTypeReference(node, visitors) {
+	let enterExit = visitors[163], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.typeName, visitors);
+	walkNode(node.typeArguments, visitors);
+	exit !== null && exit(node);
+}
+function walkTSUnionType(node, visitors) {
+	let enterExit = visitors[164], exit = null, enter;
+	if (enterExit !== null) {
+		({enter, exit} = enterExit);
+		enter !== null && enter(node);
+	}
+	walkNode(node.types, visitors);
+	exit !== null && exit(node);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/oxc-parser@0.130.0/node_modules/oxc-parser/src-js/generated/visit/type_ids.js
+/** Mapping from node type name to node type ID */
+const NODE_TYPE_IDS_MAP = new Map([
+	["DebuggerStatement", 0],
+	["EmptyStatement", 1],
+	["Literal", 2],
+	["PrivateIdentifier", 3],
+	["Super", 4],
+	["TemplateElement", 5],
+	["ThisExpression", 6],
+	["JSXClosingFragment", 7],
+	["JSXEmptyExpression", 8],
+	["JSXIdentifier", 9],
+	["JSXOpeningFragment", 10],
+	["JSXText", 11],
+	["TSAnyKeyword", 12],
+	["TSBigIntKeyword", 13],
+	["TSBooleanKeyword", 14],
+	["TSIntrinsicKeyword", 15],
+	["TSJSDocUnknownType", 16],
+	["TSNeverKeyword", 17],
+	["TSNullKeyword", 18],
+	["TSNumberKeyword", 19],
+	["TSObjectKeyword", 20],
+	["TSStringKeyword", 21],
+	["TSSymbolKeyword", 22],
+	["TSThisType", 23],
+	["TSUndefinedKeyword", 24],
+	["TSUnknownKeyword", 25],
+	["TSVoidKeyword", 26],
+	["AccessorProperty", 27],
+	["ArrayExpression", 28],
+	["ArrayPattern", 29],
+	["ArrowFunctionExpression", 30],
+	["AssignmentExpression", 31],
+	["AssignmentPattern", 32],
+	["AwaitExpression", 33],
+	["BinaryExpression", 34],
+	["BlockStatement", 35],
+	["BreakStatement", 36],
+	["CallExpression", 37],
+	["CatchClause", 38],
+	["ChainExpression", 39],
+	["ClassBody", 40],
+	["ClassDeclaration", 41],
+	["ClassExpression", 42],
+	["ConditionalExpression", 43],
+	["ContinueStatement", 44],
+	["Decorator", 45],
+	["DoWhileStatement", 46],
+	["ExportAllDeclaration", 47],
+	["ExportDefaultDeclaration", 48],
+	["ExportNamedDeclaration", 49],
+	["ExportSpecifier", 50],
+	["ExpressionStatement", 51],
+	["ForInStatement", 52],
+	["ForOfStatement", 53],
+	["ForStatement", 54],
+	["FunctionDeclaration", 55],
+	["FunctionExpression", 56],
+	["Identifier", 57],
+	["IfStatement", 58],
+	["ImportAttribute", 59],
+	["ImportDeclaration", 60],
+	["ImportDefaultSpecifier", 61],
+	["ImportExpression", 62],
+	["ImportNamespaceSpecifier", 63],
+	["ImportSpecifier", 64],
+	["LabeledStatement", 65],
+	["LogicalExpression", 66],
+	["MemberExpression", 67],
+	["MetaProperty", 68],
+	["MethodDefinition", 69],
+	["NewExpression", 70],
+	["ObjectExpression", 71],
+	["ObjectPattern", 72],
+	["ParenthesizedExpression", 73],
+	["Program", 74],
+	["Property", 75],
+	["PropertyDefinition", 76],
+	["RestElement", 77],
+	["ReturnStatement", 78],
+	["SequenceExpression", 79],
+	["SpreadElement", 80],
+	["StaticBlock", 81],
+	["SwitchCase", 82],
+	["SwitchStatement", 83],
+	["TaggedTemplateExpression", 84],
+	["TemplateLiteral", 85],
+	["ThrowStatement", 86],
+	["TryStatement", 87],
+	["UnaryExpression", 88],
+	["UpdateExpression", 89],
+	["V8IntrinsicExpression", 90],
+	["VariableDeclaration", 91],
+	["VariableDeclarator", 92],
+	["WhileStatement", 93],
+	["WithStatement", 94],
+	["YieldExpression", 95],
+	["JSXAttribute", 96],
+	["JSXClosingElement", 97],
+	["JSXElement", 98],
+	["JSXExpressionContainer", 99],
+	["JSXFragment", 100],
+	["JSXMemberExpression", 101],
+	["JSXNamespacedName", 102],
+	["JSXOpeningElement", 103],
+	["JSXSpreadAttribute", 104],
+	["JSXSpreadChild", 105],
+	["TSAbstractAccessorProperty", 106],
+	["TSAbstractMethodDefinition", 107],
+	["TSAbstractPropertyDefinition", 108],
+	["TSArrayType", 109],
+	["TSAsExpression", 110],
+	["TSCallSignatureDeclaration", 111],
+	["TSClassImplements", 112],
+	["TSConditionalType", 113],
+	["TSConstructSignatureDeclaration", 114],
+	["TSConstructorType", 115],
+	["TSDeclareFunction", 116],
+	["TSEmptyBodyFunctionExpression", 117],
+	["TSEnumBody", 118],
+	["TSEnumDeclaration", 119],
+	["TSEnumMember", 120],
+	["TSExportAssignment", 121],
+	["TSExternalModuleReference", 122],
+	["TSFunctionType", 123],
+	["TSImportEqualsDeclaration", 124],
+	["TSImportType", 125],
+	["TSIndexSignature", 126],
+	["TSIndexedAccessType", 127],
+	["TSInferType", 128],
+	["TSInstantiationExpression", 129],
+	["TSInterfaceBody", 130],
+	["TSInterfaceDeclaration", 131],
+	["TSInterfaceHeritage", 132],
+	["TSIntersectionType", 133],
+	["TSJSDocNonNullableType", 134],
+	["TSJSDocNullableType", 135],
+	["TSLiteralType", 136],
+	["TSMappedType", 137],
+	["TSMethodSignature", 138],
+	["TSModuleBlock", 139],
+	["TSModuleDeclaration", 140],
+	["TSNamedTupleMember", 141],
+	["TSNamespaceExportDeclaration", 142],
+	["TSNonNullExpression", 143],
+	["TSOptionalType", 144],
+	["TSParameterProperty", 145],
+	["TSParenthesizedType", 146],
+	["TSPropertySignature", 147],
+	["TSQualifiedName", 148],
+	["TSRestType", 149],
+	["TSSatisfiesExpression", 150],
+	["TSTemplateLiteralType", 151],
+	["TSTupleType", 152],
+	["TSTypeAliasDeclaration", 153],
+	["TSTypeAnnotation", 154],
+	["TSTypeAssertion", 155],
+	["TSTypeLiteral", 156],
+	["TSTypeOperator", 157],
+	["TSTypeParameter", 158],
+	["TSTypeParameterDeclaration", 159],
+	["TSTypeParameterInstantiation", 160],
+	["TSTypePredicate", 161],
+	["TSTypeQuery", 162],
+	["TSTypeReference", 163],
+	["TSUnionType", 164]
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/oxc-parser@0.130.0/node_modules/oxc-parser/src-js/visit/visitor.js
+let compiledVisitor;
+function createCompiledVisitor() {
+	compiledVisitor = [];
+	for (let i = 165; i !== 0; i--) compiledVisitor.push(null);
+	return compiledVisitor;
+}
+const mergedLeafVisitorTypeIds = [], mergedEnterVisitorTypeIds = [], mergedExitVisitorTypeIds = [];
+for (let i = 27; i !== 0; i--) mergedLeafVisitorTypeIds.push(0);
+for (let i = 138; i !== 0; i--) {
+	mergedEnterVisitorTypeIds.push(0);
+	mergedExitVisitorTypeIds.push(0);
+}
+mergedLeafVisitorTypeIds.length = 0;
+mergedEnterVisitorTypeIds.length = 0;
+mergedExitVisitorTypeIds.length = 0;
+let hasActiveVisitors = false;
+const enterExitObjectCache = [];
+let enterExitObjectCacheNextIndex = 0;
+function getEnterExitObject() {
+	if (enterExitObjectCacheNextIndex < enterExitObjectCache.length) return enterExitObjectCache[enterExitObjectCacheNextIndex++];
+	const enterExit = {
+		enter: null,
+		exit: null
+	};
+	enterExitObjectCache.push(enterExit);
+	enterExitObjectCacheNextIndex++;
+	return enterExit;
+}
+const visitFnArrayCache = [];
+let visitFnArrayCacheNextIndex = 0;
+function createVisitFnArray(visit1, visit2) {
+	if (visitFnArrayCacheNextIndex < visitFnArrayCache.length) {
+		const arr = visitFnArrayCache[visitFnArrayCacheNextIndex++];
+		arr.push(visit1, visit2);
+		return arr;
+	}
+	const arr = [visit1, visit2];
+	visitFnArrayCache.push(arr);
+	visitFnArrayCacheNextIndex++;
+	return arr;
+}
+/**
+* Add a visitor to compiled visitor.
+*
+* @param visitor - Visitor object
+*/
+function addVisitorToCompiled(visitor) {
+	if (visitor === null || typeof visitor !== "object") throw new TypeError("Visitor must be an object");
+	const keys = Object.keys(visitor), keysLen = keys.length;
+	if (keysLen === 0) return;
+	hasActiveVisitors = true;
+	for (let i = 0; i < keysLen; i++) {
+		let name = keys[i];
+		const visitFn = visitor[name];
+		if (typeof visitFn !== "function") throw new TypeError(`'${name}' property of visitor object is not a function`);
+		const isExit = name.endsWith(":exit");
+		if (isExit) name = name.slice(0, -5);
+		const typeId = NODE_TYPE_IDS_MAP.get(name);
+		if (typeId === void 0) throw new Error(`Unknown node type '${name}' in visitor object`);
+		const existing = compiledVisitor[typeId];
+		if (typeId < 27) if (existing === null) compiledVisitor[typeId] = visitFn;
+		else if (Array.isArray(existing)) if (isExit) existing.push(visitFn);
+		else existing.splice(existing.length - 1, 0, visitFn);
+		else {
+			compiledVisitor[typeId] = isExit ? createVisitFnArray(existing, visitFn) : createVisitFnArray(visitFn, existing);
+			mergedLeafVisitorTypeIds.push(typeId);
+		}
+		else if (existing === null) {
+			const enterExit = compiledVisitor[typeId] = getEnterExitObject();
+			if (isExit) enterExit.exit = visitFn;
+			else enterExit.enter = visitFn;
+		} else if (isExit) {
+			const { exit } = existing;
+			if (exit === null) existing.exit = visitFn;
+			else if (Array.isArray(exit)) exit.push(visitFn);
+			else {
+				existing.exit = createVisitFnArray(exit, visitFn);
+				mergedExitVisitorTypeIds.push(typeId);
+			}
+		} else {
+			const { enter } = existing;
+			if (enter === null) existing.enter = visitFn;
+			else if (Array.isArray(enter)) enter.push(visitFn);
+			else {
+				existing.enter = createVisitFnArray(enter, visitFn);
+				mergedEnterVisitorTypeIds.push(typeId);
+			}
+		}
+	}
+}
+/**
+* Finalize compiled visitor.
+*
+* After calling this function, `compiledVisitor` is ready to be used to walk the AST.
+*
+* @returns {boolean} - `true` if compiled visitor visits at least 1 AST type
+*/
+function finalizeCompiledVisitor() {
+	if (hasActiveVisitors === false) return false;
+	for (let i = mergedLeafVisitorTypeIds.length - 1; i >= 0; i--) {
+		const typeId = mergedLeafVisitorTypeIds[i];
+		compiledVisitor[typeId] = mergeVisitFns(compiledVisitor[typeId]);
+	}
+	for (let i = mergedEnterVisitorTypeIds.length - 1; i >= 0; i--) {
+		const typeId = mergedEnterVisitorTypeIds[i];
+		const enterExit = compiledVisitor[typeId];
+		enterExit.enter = mergeVisitFns(enterExit.enter);
+	}
+	for (let i = mergedExitVisitorTypeIds.length - 1; i >= 0; i--) {
+		const typeId = mergedExitVisitorTypeIds[i];
+		const enterExit = compiledVisitor[typeId];
+		enterExit.exit = mergeVisitFns(enterExit.exit);
+	}
+	mergedLeafVisitorTypeIds.length = 0;
+	mergedEnterVisitorTypeIds.length = 0;
+	mergedExitVisitorTypeIds.length = 0;
+	visitFnArrayCacheNextIndex = 0;
+	hasActiveVisitors = false;
+	return true;
+}
+/**
+* Merge array of visit functions into a single function, which calls each of input functions in turn.
+*
+* The array passed is cleared (length set to 0), so the array can be reused.
+*
+* The merged function is statically defined and does not contain a loop, to hopefully allow
+* JS engine to heavily optimize it.
+*
+* `mergers` contains pre-defined functions to merge up to 5 visit functions.
+* Merger functions for merging more than 5 visit functions are created dynamically on demand.
+*
+* @param visitFns - Array of visit functions
+* @returns Function which calls all of `visitFns` in turn.
+*/
+function mergeVisitFns(visitFns) {
+	const numVisitFns = visitFns.length;
+	let merger;
+	if (mergers.length <= numVisitFns) {
+		while (mergers.length < numVisitFns) mergers.push(null);
+		merger = createMerger(numVisitFns);
+		mergers.push(merger);
+	} else {
+		merger = mergers[numVisitFns];
+		if (merger === null) merger = mergers[numVisitFns] = createMerger(numVisitFns);
+	}
+	const mergedFn = merger(...visitFns);
+	visitFns.length = 0;
+	return mergedFn;
+}
+/**
+* Create a merger function that merges `fnCount` functions.
+*
+* @param fnCount - Number of functions to be merged
+* @returns Function to merge `fnCount` functions
+*/
+function createMerger(fnCount) {
+	const args = [];
+	let body = "return node=>{";
+	for (let i = 1; i <= fnCount; i++) {
+		args.push(`visit${i}`);
+		body += `visit${i}(node);`;
+	}
+	body += "}";
+	args.push(body);
+	return new Function(...args);
+}
+const mergers = [
+	null,
+	null,
+	(visit1, visit2) => (node) => {
+		visit1(node);
+		visit2(node);
+	},
+	(visit1, visit2, visit3) => (node) => {
+		visit1(node);
+		visit2(node);
+		visit3(node);
+	},
+	(visit1, visit2, visit3, visit4) => (node) => {
+		visit1(node);
+		visit2(node);
+		visit3(node);
+		visit4(node);
+	},
+	(visit1, visit2, visit3, visit4, visit5) => (node) => {
+		visit1(node);
+		visit2(node);
+		visit3(node);
+		visit4(node);
+		visit5(node);
+	}
+];
+//#endregion
+//#region src/utils/visitor.ts
+/**
+* Visitor class for traversing AST.
+*
+* @example
+* ```ts
+* import { Visitor } from 'rolldown/utils';
+* import { parseSync } from 'rolldown/utils';
+*
+* const result = parseSync(...);
+* const visitor = new Visitor({
+*   VariableDeclaration(path) {
+*     // Do something with the variable declaration
+*   },
+*   "VariableDeclaration:exit"(path) {
+*     // Do something after visiting the variable declaration
+*   }
+* });
+* visitor.visit(result.program);
+* ```
+*
+* @category Utilities
+* @experimental
+*/
+var Visitor = class {
+	#compiledVisitor = null;
+	constructor(visitor) {
+		const compiledVisitor = createCompiledVisitor();
+		addVisitorToCompiled(visitor);
+		if (finalizeCompiledVisitor()) this.#compiledVisitor = compiledVisitor;
+	}
+	visit(program) {
+		const compiledVisitor = this.#compiledVisitor;
+		if (compiledVisitor !== null) walkProgram(program, compiledVisitor);
+	}
+};
+//#endregion
+export { TsconfigCache, Visitor, minify, minifySync, parse, parseSync, transform, transformSync };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/package.json
new file mode 100644
index 0000000..29f0402
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/rolldown/package.json
@@ -0,0 +1,153 @@
+{
+  "name": "rolldown",
+  "version": "1.0.1",
+  "description": "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.",
+  "keywords": [
+    "bundler",
+    "esbuild",
+    "parcel",
+    "rolldown",
+    "rollup",
+    "webpack"
+  ],
+  "homepage": "https://rolldown.rs/",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rolldown/rolldown.git",
+    "directory": "packages/rolldown"
+  },
+  "bin": {
+    "rolldown": "./bin/cli.mjs"
+  },
+  "files": [
+    "bin",
+    "cli",
+    "dist",
+    "!dist/*.node"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "imports": {
+    "#parallel-plugin-worker": "./dist/parallel-plugin-worker.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./config": "./dist/config.mjs",
+    "./experimental": "./dist/experimental-index.mjs",
+    "./experimental/runtime-types": {
+      "types": "./dist/experimental-runtime-types.d.ts"
+    },
+    "./filter": "./dist/filter-index.mjs",
+    "./getLogFilter": "./dist/get-log-filter.mjs",
+    "./parallelPlugin": "./dist/parallel-plugin.mjs",
+    "./parseAst": "./dist/parse-ast-index.mjs",
+    "./package.json": "./package.json",
+    "./plugins": "./dist/plugins-index.mjs",
+    "./utils": "./dist/utils-index.mjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@oxc-project/types": "=0.130.0",
+    "@rolldown/pluginutils": "^1.0.0"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^3.6.1",
+    "@napi-rs/wasm-runtime": "^1.1.4",
+    "@oxc-node/cli": "^0.1.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "buble": "^0.20.0",
+    "cac": "^7.0.0",
+    "consola": "^3.4.2",
+    "execa": "^9.2.0",
+    "glob": "^13.0.0",
+    "oxc-parser": "=0.130.0",
+    "pathe": "^2.0.3",
+    "remeda": "^2.10.0",
+    "rolldown-plugin-dts": "^0.25.0",
+    "rollup": "^4.18.0",
+    "signal-exit": "4.1.0",
+    "source-map": "0.7.6",
+    "typescript": "^6.0.0",
+    "valibot": "1.4.0",
+    "rolldown": "1.0.1"
+  },
+  "napi": {
+    "binaryName": "rolldown-binding",
+    "dtsHeader": "type MaybePromise<T> = T | Promise<T>\ntype Nullable<T> = T | null | undefined\ntype VoidNullable<T = void> = T | null | undefined | void\nexport type BindingStringOrRegex = string | RegExp\nexport type BindingResult<T> = { errors: BindingError[], isBindingErrors: boolean } | T\n\n",
+    "packageName": "@rolldown/binding",
+    "targets": [
+      "x86_64-apple-darwin",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "x86_64-unknown-freebsd",
+      "armv7-unknown-linux-gnueabihf",
+      "aarch64-unknown-linux-gnu",
+      "aarch64-apple-darwin",
+      "aarch64-unknown-linux-musl",
+      "aarch64-unknown-linux-ohos",
+      "aarch64-pc-windows-msvc",
+      "aarch64-linux-android",
+      "wasm32-wasip1-threads",
+      "s390x-unknown-linux-gnu",
+      "powerpc64le-unknown-linux-gnu"
+    ],
+    "wasm": {
+      "initialMemory": 16384,
+      "browser": {
+        "fs": true,
+        "asyncInit": true,
+        "errorEvent": true
+      }
+    }
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "optionalDependencies": {
+    "@rolldown/binding-darwin-x64": "1.0.1",
+    "@rolldown/binding-win32-x64-msvc": "1.0.1",
+    "@rolldown/binding-linux-x64-gnu": "1.0.1",
+    "@rolldown/binding-linux-x64-musl": "1.0.1",
+    "@rolldown/binding-freebsd-x64": "1.0.1",
+    "@rolldown/binding-linux-arm-gnueabihf": "1.0.1",
+    "@rolldown/binding-linux-arm64-gnu": "1.0.1",
+    "@rolldown/binding-darwin-arm64": "1.0.1",
+    "@rolldown/binding-linux-arm64-musl": "1.0.1",
+    "@rolldown/binding-openharmony-arm64": "1.0.1",
+    "@rolldown/binding-win32-arm64-msvc": "1.0.1",
+    "@rolldown/binding-android-arm64": "1.0.1",
+    "@rolldown/binding-wasm32-wasi": "1.0.1",
+    "@rolldown/binding-linux-s390x-gnu": "1.0.1",
+    "@rolldown/binding-linux-ppc64-gnu": "1.0.1"
+  },
+  "scripts": {
+    "# Scrips for binding #": "_",
+    "artifacts": "napi artifacts --cwd ./src --package-json-path ../package.json -o=../artifacts --npm-dir ../npm",
+    "build-binding": "oxnode ./build-binding.ts",
+    "build-binding:release": "pnpm build-binding --release",
+    "build-binding:profile": "pnpm build-binding --profile profile",
+    "build-binding:wasi": "pnpm build-binding --target wasm32-wasip1-threads",
+    "build-binding:wasi:release": "pnpm build-binding --profile release-wasi --target wasm32-wasip1-threads",
+    "# Scrips for node #": "_",
+    "build-node": "node --enable-source-maps --import @oxc-node/core/register -C dev ./build.ts",
+    "build-types-check": "tsc -p ./tsconfig.check.json",
+    "build-js-glue": "pnpm run --sequential '/^build-(node|types-check)$/'",
+    "build-native:debug": "pnpm run --sequential '/^build-(binding|js-glue)$/'",
+    "build-native:release": "pnpm run --sequential '/^build-(binding:release|js-glue)$/'",
+    "build-native:profile": "pnpm run build-binding:profile && pnpm run build-js-glue",
+    "build-native:memory-profile": "pnpm run build-binding:profile --features default_global_allocator && pnpm run build-js-glue",
+    "build-wasi:debug": "TARGET='rolldown-wasi' pnpm run --sequential '/^build-(binding|binding:wasi|node)$/'",
+    "build-wasi:release": "TARGET='rolldown-wasi' pnpm run --sequential '/^build-(binding|binding:wasi:release|node)$/'",
+    "build-browser-pkg:debug": "TARGET='browser' pnpm run --sequential '/^build-(binding:wasi|node)$/'",
+    "build-browser-pkg:release": "TARGET='browser' pnpm run --sequential '/^build-(binding:wasi:release|node)$/'",
+    "# Scrips for docs #": "_",
+    "publint": "publint ."
+  }
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/LICENSE
new file mode 100644
index 0000000..ed1b7cf
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/LICENSE
@@ -0,0 +1,28 @@
+
+Copyright (c) 2009-2011, Mozilla Foundation and contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the names of the Mozilla Foundation nor the names of project
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/README.md
new file mode 100644
index 0000000..614962d
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/README.md
@@ -0,0 +1,765 @@
+# Source Map JS
+
+[![NPM](https://nodei.co/npm/source-map-js.png?downloads=true&downloadRank=true)](https://www.npmjs.com/package/source-map-js)
+
+Difference between original [source-map](https://github.com/mozilla/source-map):
+
+> TL,DR: it's fork of original source-map@0.6, but with perfomance optimizations.
+
+This journey starts from [source-map@0.7.0](https://github.com/mozilla/source-map/blob/master/CHANGELOG.md#070). Some part of it was rewritten to Rust and WASM and API became async.
+
+It's still a major block for many libraries like PostCSS or Sass for example because they need to migrate the whole API to the async way. This is the reason why 0.6.1 has 2x more downloads than 0.7.3 while it's faster several times.
+
+![Downloads count](media/downloads.png)
+
+More important that WASM version has some optimizations in JS code too. This is why [community asked to create branch for 0.6 version](https://github.com/mozilla/source-map/issues/324) and port these optimizations but, sadly, the answer was «no». A bit later I discovered [the issue](https://github.com/mozilla/source-map/issues/370) created by [Ben Rothman (@benthemonkey)](https://github.com/benthemonkey) with no response at all.
+
+[Roman Dvornov (@lahmatiy)](https://github.com/lahmatiy) wrote a [serveral posts](https://t.me/gorshochekvarit/76) (russian, only, sorry) about source-map library in his own Telegram channel. He mentioned the article [«Maybe you don't need Rust and WASM to speed up your JS»](https://mrale.ph/blog/2018/02/03/maybe-you-dont-need-rust-to-speed-up-your-js.html) written by [Vyacheslav Egorov (@mraleph)](https://github.com/mraleph). This article contains optimizations and hacks that lead to almost the same performance compare to WASM implementation.
+
+I decided to fork the original source-map and port these optimizations from the article and several others PR from the original source-map.
+
+---------
+
+This is a library to generate and consume the source map format
+[described here][format].
+
+[format]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+
+## Use with Node
+
+    $ npm install source-map-js
+
+<!-- ## Use on the Web
+
+    <script src="https://raw.githubusercontent.com/mozilla/source-map/master/dist/source-map.min.js" defer></script> -->
+
+--------------------------------------------------------------------------------
+
+<!-- `npm run toc` to regenerate the Table of Contents -->
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+## Table of Contents
+
+- [Examples](#examples)
+  - [Consuming a source map](#consuming-a-source-map)
+  - [Generating a source map](#generating-a-source-map)
+    - [With SourceNode (high level API)](#with-sourcenode-high-level-api)
+    - [With SourceMapGenerator (low level API)](#with-sourcemapgenerator-low-level-api)
+- [API](#api)
+  - [SourceMapConsumer](#sourcemapconsumer)
+    - [new SourceMapConsumer(rawSourceMap)](#new-sourcemapconsumerrawsourcemap)
+    - [SourceMapConsumer.prototype.computeColumnSpans()](#sourcemapconsumerprototypecomputecolumnspans)
+    - [SourceMapConsumer.prototype.originalPositionFor(generatedPosition)](#sourcemapconsumerprototypeoriginalpositionforgeneratedposition)
+    - [SourceMapConsumer.prototype.generatedPositionFor(originalPosition)](#sourcemapconsumerprototypegeneratedpositionfororiginalposition)
+    - [SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)](#sourcemapconsumerprototypeallgeneratedpositionsfororiginalposition)
+    - [SourceMapConsumer.prototype.hasContentsOfAllSources()](#sourcemapconsumerprototypehascontentsofallsources)
+    - [SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])](#sourcemapconsumerprototypesourcecontentforsource-returnnullonmissing)
+    - [SourceMapConsumer.prototype.eachMapping(callback, context, order)](#sourcemapconsumerprototypeeachmappingcallback-context-order)
+  - [SourceMapGenerator](#sourcemapgenerator)
+    - [new SourceMapGenerator([startOfSourceMap])](#new-sourcemapgeneratorstartofsourcemap)
+    - [SourceMapGenerator.fromSourceMap(sourceMapConsumer)](#sourcemapgeneratorfromsourcemapsourcemapconsumer)
+    - [SourceMapGenerator.prototype.addMapping(mapping)](#sourcemapgeneratorprototypeaddmappingmapping)
+    - [SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)](#sourcemapgeneratorprototypesetsourcecontentsourcefile-sourcecontent)
+    - [SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])](#sourcemapgeneratorprototypeapplysourcemapsourcemapconsumer-sourcefile-sourcemappath)
+    - [SourceMapGenerator.prototype.toString()](#sourcemapgeneratorprototypetostring)
+  - [SourceNode](#sourcenode)
+    - [new SourceNode([line, column, source[, chunk[, name]]])](#new-sourcenodeline-column-source-chunk-name)
+    - [SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relativePath])](#sourcenodefromstringwithsourcemapcode-sourcemapconsumer-relativepath)
+    - [SourceNode.prototype.add(chunk)](#sourcenodeprototypeaddchunk)
+    - [SourceNode.prototype.prepend(chunk)](#sourcenodeprototypeprependchunk)
+    - [SourceNode.prototype.setSourceContent(sourceFile, sourceContent)](#sourcenodeprototypesetsourcecontentsourcefile-sourcecontent)
+    - [SourceNode.prototype.walk(fn)](#sourcenodeprototypewalkfn)
+    - [SourceNode.prototype.walkSourceContents(fn)](#sourcenodeprototypewalksourcecontentsfn)
+    - [SourceNode.prototype.join(sep)](#sourcenodeprototypejoinsep)
+    - [SourceNode.prototype.replaceRight(pattern, replacement)](#sourcenodeprototypereplacerightpattern-replacement)
+    - [SourceNode.prototype.toString()](#sourcenodeprototypetostring)
+    - [SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])](#sourcenodeprototypetostringwithsourcemapstartofsourcemap)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Examples
+
+### Consuming a source map
+
+```js
+var rawSourceMap = {
+  version: 3,
+  file: 'min.js',
+  names: ['bar', 'baz', 'n'],
+  sources: ['one.js', 'two.js'],
+  sourceRoot: 'http://example.com/www/js/',
+  mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
+};
+
+var smc = new SourceMapConsumer(rawSourceMap);
+
+console.log(smc.sources);
+// [ 'http://example.com/www/js/one.js',
+//   'http://example.com/www/js/two.js' ]
+
+console.log(smc.originalPositionFor({
+  line: 2,
+  column: 28
+}));
+// { source: 'http://example.com/www/js/two.js',
+//   line: 2,
+//   column: 10,
+//   name: 'n' }
+
+console.log(smc.generatedPositionFor({
+  source: 'http://example.com/www/js/two.js',
+  line: 2,
+  column: 10
+}));
+// { line: 2, column: 28 }
+
+smc.eachMapping(function (m) {
+  // ...
+});
+```
+
+### Generating a source map
+
+In depth guide:
+[**Compiling to JavaScript, and Debugging with Source Maps**](https://hacks.mozilla.org/2013/05/compiling-to-javascript-and-debugging-with-source-maps/)
+
+#### With SourceNode (high level API)
+
+```js
+function compile(ast) {
+  switch (ast.type) {
+  case 'BinaryExpression':
+    return new SourceNode(
+      ast.location.line,
+      ast.location.column,
+      ast.location.source,
+      [compile(ast.left), " + ", compile(ast.right)]
+    );
+  case 'Literal':
+    return new SourceNode(
+      ast.location.line,
+      ast.location.column,
+      ast.location.source,
+      String(ast.value)
+    );
+  // ...
+  default:
+    throw new Error("Bad AST");
+  }
+}
+
+var ast = parse("40 + 2", "add.js");
+console.log(compile(ast).toStringWithSourceMap({
+  file: 'add.js'
+}));
+// { code: '40 + 2',
+//   map: [object SourceMapGenerator] }
+```
+
+#### With SourceMapGenerator (low level API)
+
+```js
+var map = new SourceMapGenerator({
+  file: "source-mapped.js"
+});
+
+map.addMapping({
+  generated: {
+    line: 10,
+    column: 35
+  },
+  source: "foo.js",
+  original: {
+    line: 33,
+    column: 2
+  },
+  name: "christopher"
+});
+
+console.log(map.toString());
+// '{"version":3,"file":"source-mapped.js","sources":["foo.js"],"names":["christopher"],"mappings":";;;;;;;;;mCAgCEA"}'
+```
+
+## API
+
+Get a reference to the module:
+
+```js
+// Node.js
+var sourceMap = require('source-map');
+
+// Browser builds
+var sourceMap = window.sourceMap;
+
+// Inside Firefox
+const sourceMap = require("devtools/toolkit/sourcemap/source-map.js");
+```
+
+### SourceMapConsumer
+
+A SourceMapConsumer instance represents a parsed source map which we can query
+for information about the original file positions by giving it a file position
+in the generated source.
+
+#### new SourceMapConsumer(rawSourceMap)
+
+The only parameter is the raw source map (either as a string which can be
+`JSON.parse`'d, or an object). According to the spec, source maps have the
+following attributes:
+
+* `version`: Which version of the source map spec this map is following.
+
+* `sources`: An array of URLs to the original source files.
+
+* `names`: An array of identifiers which can be referenced by individual
+  mappings.
+
+* `sourceRoot`: Optional. The URL root from which all sources are relative.
+
+* `sourcesContent`: Optional. An array of contents of the original source files.
+
+* `mappings`: A string of base64 VLQs which contain the actual mappings.
+
+* `file`: Optional. The generated filename this source map is associated with.
+
+```js
+var consumer = new sourceMap.SourceMapConsumer(rawSourceMapJsonData);
+```
+
+#### SourceMapConsumer.prototype.computeColumnSpans()
+
+Compute the last column for each generated mapping. The last column is
+inclusive.
+
+```js
+// Before:
+consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1 },
+//   { line: 2,
+//     column: 10 },
+//   { line: 2,
+//     column: 20 } ]
+
+consumer.computeColumnSpans();
+
+// After:
+consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1,
+//     lastColumn: 9 },
+//   { line: 2,
+//     column: 10,
+//     lastColumn: 19 },
+//   { line: 2,
+//     column: 20,
+//     lastColumn: Infinity } ]
+
+```
+
+#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition)
+
+Returns the original source, line, and column information for the generated
+source's line and column positions provided. The only argument is an object with
+the following properties:
+
+* `line`: The line number in the generated source.  Line numbers in
+  this library are 1-based (note that the underlying source map
+  specification uses 0-based line numbers -- this library handles the
+  translation).
+
+* `column`: The column number in the generated source.  Column numbers
+  in this library are 0-based.
+
+* `bias`: Either `SourceMapConsumer.GREATEST_LOWER_BOUND` or
+  `SourceMapConsumer.LEAST_UPPER_BOUND`. Specifies whether to return the closest
+  element that is smaller than or greater than the one we are searching for,
+  respectively, if the exact element cannot be found.  Defaults to
+  `SourceMapConsumer.GREATEST_LOWER_BOUND`.
+
+and an object is returned with the following properties:
+
+* `source`: The original source file, or null if this information is not
+  available.
+
+* `line`: The line number in the original source, or null if this information is
+  not available.  The line number is 1-based.
+
+* `column`: The column number in the original source, or null if this
+  information is not available.  The column number is 0-based.
+
+* `name`: The original identifier, or null if this information is not available.
+
+```js
+consumer.originalPositionFor({ line: 2, column: 10 })
+// { source: 'foo.coffee',
+//   line: 2,
+//   column: 2,
+//   name: null }
+
+consumer.originalPositionFor({ line: 99999999999999999, column: 999999999999999 })
+// { source: null,
+//   line: null,
+//   column: null,
+//   name: null }
+```
+
+#### SourceMapConsumer.prototype.generatedPositionFor(originalPosition)
+
+Returns the generated line and column information for the original source,
+line, and column positions provided. The only argument is an object with
+the following properties:
+
+* `source`: The filename of the original source.
+
+* `line`: The line number in the original source.  The line number is
+  1-based.
+
+* `column`: The column number in the original source.  The column
+  number is 0-based.
+
+and an object is returned with the following properties:
+
+* `line`: The line number in the generated source, or null.  The line
+  number is 1-based.
+
+* `column`: The column number in the generated source, or null.  The
+  column number is 0-based.
+
+```js
+consumer.generatedPositionFor({ source: "example.js", line: 2, column: 10 })
+// { line: 1,
+//   column: 56 }
+```
+
+#### SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)
+
+Returns all generated line and column information for the original source, line,
+and column provided. If no column is provided, returns all mappings
+corresponding to a either the line we are searching for or the next closest line
+that has any mappings. Otherwise, returns all mappings corresponding to the
+given line and either the column we are searching for or the next closest column
+that has any offsets.
+
+The only argument is an object with the following properties:
+
+* `source`: The filename of the original source.
+
+* `line`: The line number in the original source.  The line number is
+  1-based.
+
+* `column`: Optional. The column number in the original source.  The
+  column number is 0-based.
+
+and an array of objects is returned, each with the following properties:
+
+* `line`: The line number in the generated source, or null.  The line
+  number is 1-based.
+
+* `column`: The column number in the generated source, or null.  The
+  column number is 0-based.
+
+```js
+consumer.allGeneratedpositionsfor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1 },
+//   { line: 2,
+//     column: 10 },
+//   { line: 2,
+//     column: 20 } ]
+```
+
+#### SourceMapConsumer.prototype.hasContentsOfAllSources()
+
+Return true if we have the embedded source content for every source listed in
+the source map, false otherwise.
+
+In other words, if this method returns `true`, then
+`consumer.sourceContentFor(s)` will succeed for every source `s` in
+`consumer.sources`.
+
+```js
+// ...
+if (consumer.hasContentsOfAllSources()) {
+  consumerReadyCallback(consumer);
+} else {
+  fetchSources(consumer, consumerReadyCallback);
+}
+// ...
+```
+
+#### SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])
+
+Returns the original source content for the source provided. The only
+argument is the URL of the original source file.
+
+If the source content for the given source is not found, then an error is
+thrown. Optionally, pass `true` as the second param to have `null` returned
+instead.
+
+```js
+consumer.sources
+// [ "my-cool-lib.clj" ]
+
+consumer.sourceContentFor("my-cool-lib.clj")
+// "..."
+
+consumer.sourceContentFor("this is not in the source map");
+// Error: "this is not in the source map" is not in the source map
+
+consumer.sourceContentFor("this is not in the source map", true);
+// null
+```
+
+#### SourceMapConsumer.prototype.eachMapping(callback, context, order)
+
+Iterate over each mapping between an original source/line/column and a
+generated line/column in this source map.
+
+* `callback`: The function that is called with each mapping. Mappings have the
+  form `{ source, generatedLine, generatedColumn, originalLine, originalColumn,
+  name }`
+
+* `context`: Optional. If specified, this object will be the value of `this`
+  every time that `callback` is called.
+
+* `order`: Either `SourceMapConsumer.GENERATED_ORDER` or
+  `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to iterate over
+  the mappings sorted by the generated file's line/column order or the
+  original's source/line/column order, respectively. Defaults to
+  `SourceMapConsumer.GENERATED_ORDER`.
+
+```js
+consumer.eachMapping(function (m) { console.log(m); })
+// ...
+// { source: 'illmatic.js',
+//   generatedLine: 1,
+//   generatedColumn: 0,
+//   originalLine: 1,
+//   originalColumn: 0,
+//   name: null }
+// { source: 'illmatic.js',
+//   generatedLine: 2,
+//   generatedColumn: 0,
+//   originalLine: 2,
+//   originalColumn: 0,
+//   name: null }
+// ...
+```
+### SourceMapGenerator
+
+An instance of the SourceMapGenerator represents a source map which is being
+built incrementally.
+
+#### new SourceMapGenerator([startOfSourceMap])
+
+You may pass an object with the following properties:
+
+* `file`: The filename of the generated source that this source map is
+  associated with.
+
+* `sourceRoot`: A root for all relative URLs in this source map.
+
+* `skipValidation`: Optional. When `true`, disables validation of mappings as
+  they are added. This can improve performance but should be used with
+  discretion, as a last resort. Even then, one should avoid using this flag when
+  running tests, if possible.
+
+* `ignoreInvalidMapping`: Optional. When `true`, instead of throwing error on
+  invalid mapping, it will be ignored.
+
+```js
+var generator = new sourceMap.SourceMapGenerator({
+  file: "my-generated-javascript-file.js",
+  sourceRoot: "http://example.com/app/js/"
+});
+```
+
+#### SourceMapGenerator.fromSourceMap(sourceMapConsumer, sourceMapGeneratorOptions)
+
+Creates a new `SourceMapGenerator` from an existing `SourceMapConsumer` instance.
+
+* `sourceMapConsumer` The SourceMap.
+
+* `sourceMapGeneratorOptions` options that will be passed to the SourceMapGenerator constructor which used under the hood.
+
+```js
+var generator = sourceMap.SourceMapGenerator.fromSourceMap(consumer, {
+  ignoreInvalidMapping: true,
+});
+```
+
+#### SourceMapGenerator.prototype.addMapping(mapping)
+
+Add a single mapping from original source line and column to the generated
+source's line and column for this source map being created. The mapping object
+should have the following properties:
+
+* `generated`: An object with the generated line and column positions.
+
+* `original`: An object with the original line and column positions.
+
+* `source`: The original source file (relative to the sourceRoot).
+
+* `name`: An optional original token name for this mapping.
+
+```js
+generator.addMapping({
+  source: "module-one.scm",
+  original: { line: 128, column: 0 },
+  generated: { line: 3, column: 456 }
+})
+```
+
+#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for an original source file.
+
+* `sourceFile` the URL of the original source file.
+
+* `sourceContent` the content of the source file.
+
+```js
+generator.setSourceContent("module-one.scm",
+                           fs.readFileSync("path/to/module-one.scm"))
+```
+
+#### SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])
+
+Applies a SourceMap for a source file to the SourceMap.
+Each mapping to the supplied source file is rewritten using the
+supplied SourceMap. Note: The resolution for the resulting mappings
+is the minimum of this map and the supplied map.
+
+* `sourceMapConsumer`: The SourceMap to be applied.
+
+* `sourceFile`: Optional. The filename of the source file.
+  If omitted, sourceMapConsumer.file will be used, if it exists.
+  Otherwise an error will be thrown.
+
+* `sourceMapPath`: Optional. The dirname of the path to the SourceMap
+  to be applied. If relative, it is relative to the SourceMap.
+
+  This parameter is needed when the two SourceMaps aren't in the same
+  directory, and the SourceMap to be applied contains relative source
+  paths. If so, those relative source paths need to be rewritten
+  relative to the SourceMap.
+
+  If omitted, it is assumed that both SourceMaps are in the same directory,
+  thus not needing any rewriting. (Supplying `'.'` has the same effect.)
+
+#### SourceMapGenerator.prototype.toString()
+
+Renders the source map being generated to a string.
+
+```js
+generator.toString()
+// '{"version":3,"sources":["module-one.scm"],"names":[],"mappings":"...snip...","file":"my-generated-javascript-file.js","sourceRoot":"http://example.com/app/js/"}'
+```
+
+### SourceNode
+
+SourceNodes provide a way to abstract over interpolating and/or concatenating
+snippets of generated JavaScript source code, while maintaining the line and
+column information associated between those snippets and the original source
+code. This is useful as the final intermediate representation a compiler might
+use before outputting the generated JS and source map.
+
+#### new SourceNode([line, column, source[, chunk[, name]]])
+
+* `line`: The original line number associated with this source node, or null if
+  it isn't associated with an original line.  The line number is 1-based.
+
+* `column`: The original column number associated with this source node, or null
+  if it isn't associated with an original column.  The column number
+  is 0-based.
+
+* `source`: The original source's filename; null if no filename is provided.
+
+* `chunk`: Optional. Is immediately passed to `SourceNode.prototype.add`, see
+  below.
+
+* `name`: Optional. The original identifier.
+
+```js
+var node = new SourceNode(1, 2, "a.cpp", [
+  new SourceNode(3, 4, "b.cpp", "extern int status;\n"),
+  new SourceNode(5, 6, "c.cpp", "std::string* make_string(size_t n);\n"),
+  new SourceNode(7, 8, "d.cpp", "int main(int argc, char** argv) {}\n"),
+]);
+```
+
+#### SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relativePath])
+
+Creates a SourceNode from generated code and a SourceMapConsumer.
+
+* `code`: The generated code
+
+* `sourceMapConsumer` The SourceMap for the generated code
+
+* `relativePath` The optional path that relative sources in `sourceMapConsumer`
+  should be relative to.
+
+```js
+var consumer = new SourceMapConsumer(fs.readFileSync("path/to/my-file.js.map", "utf8"));
+var node = SourceNode.fromStringWithSourceMap(fs.readFileSync("path/to/my-file.js"),
+                                              consumer);
+```
+
+#### SourceNode.prototype.add(chunk)
+
+Add a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+```js
+node.add(" + ");
+node.add(otherNode);
+node.add([leftHandOperandNode, " + ", rightHandOperandNode]);
+```
+
+#### SourceNode.prototype.prepend(chunk)
+
+Prepend a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+```js
+node.prepend("/** Build Id: f783haef86324gf **/\n\n");
+```
+
+#### SourceNode.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for a source file. This will be added to the
+`SourceMap` in the `sourcesContent` field.
+
+* `sourceFile`: The filename of the source file
+
+* `sourceContent`: The content of the source file
+
+```js
+node.setSourceContent("module-one.scm",
+                      fs.readFileSync("path/to/module-one.scm"))
+```
+
+#### SourceNode.prototype.walk(fn)
+
+Walk over the tree of JS snippets in this node and its children. The walking
+function is called once for each snippet of JS and is passed that snippet and
+the its original associated source's line/column location.
+
+* `fn`: The traversal function.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.walk(function (code, loc) { console.log("WALK:", code, loc); })
+// WALK: uno { source: 'b.js', line: 3, column: 4, name: null }
+// WALK: dos { source: 'a.js', line: 1, column: 2, name: null }
+// WALK: tres { source: 'a.js', line: 1, column: 2, name: null }
+// WALK: quatro { source: 'c.js', line: 5, column: 6, name: null }
+```
+
+#### SourceNode.prototype.walkSourceContents(fn)
+
+Walk over the tree of SourceNodes. The walking function is called for each
+source file content and is passed the filename and source content.
+
+* `fn`: The traversal function.
+
+```js
+var a = new SourceNode(1, 2, "a.js", "generated from a");
+a.setSourceContent("a.js", "original a");
+var b = new SourceNode(1, 2, "b.js", "generated from b");
+b.setSourceContent("b.js", "original b");
+var c = new SourceNode(1, 2, "c.js", "generated from c");
+c.setSourceContent("c.js", "original c");
+
+var node = new SourceNode(null, null, null, [a, b, c]);
+node.walkSourceContents(function (source, contents) { console.log("WALK:", source, ":", contents); })
+// WALK: a.js : original a
+// WALK: b.js : original b
+// WALK: c.js : original c
+```
+
+#### SourceNode.prototype.join(sep)
+
+Like `Array.prototype.join` except for SourceNodes. Inserts the separator
+between each of this source node's children.
+
+* `sep`: The separator.
+
+```js
+var lhs = new SourceNode(1, 2, "a.rs", "my_copy");
+var operand = new SourceNode(3, 4, "a.rs", "=");
+var rhs = new SourceNode(5, 6, "a.rs", "orig.clone()");
+
+var node = new SourceNode(null, null, null, [ lhs, operand, rhs ]);
+var joinedNode = node.join(" ");
+```
+
+#### SourceNode.prototype.replaceRight(pattern, replacement)
+
+Call `String.prototype.replace` on the very right-most source snippet. Useful
+for trimming white space from the end of a source node, etc.
+
+* `pattern`: The pattern to replace.
+
+* `replacement`: The thing to replace the pattern with.
+
+```js
+// Trim trailing white space.
+node.replaceRight(/\s*$/, "");
+```
+
+#### SourceNode.prototype.toString()
+
+Return the string representation of this source node. Walks over the tree and
+concatenates all the various snippets together to one string.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.toString()
+// 'unodostresquatro'
+```
+
+#### SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])
+
+Returns the string representation of this tree of source nodes, plus a
+SourceMapGenerator which contains all the mappings between the generated and
+original sources.
+
+The arguments are the same as those to `new SourceMapGenerator`.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.toStringWithSourceMap({ file: "my-output-file.js" })
+// { code: 'unodostresquatro',
+//   map: [object SourceMapGenerator] }
+```
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/array-set.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/array-set.js
new file mode 100644
index 0000000..fbd5c81
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/array-set.js
@@ -0,0 +1,121 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var util = require('./util');
+var has = Object.prototype.hasOwnProperty;
+var hasNativeMap = typeof Map !== "undefined";
+
+/**
+ * A data structure which is a combination of an array and a set. Adding a new
+ * member is O(1), testing for membership is O(1), and finding the index of an
+ * element is O(1). Removing elements from the set is not supported. Only
+ * strings are supported for membership.
+ */
+function ArraySet() {
+  this._array = [];
+  this._set = hasNativeMap ? new Map() : Object.create(null);
+}
+
+/**
+ * Static method for creating ArraySet instances from an existing array.
+ */
+ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
+  var set = new ArraySet();
+  for (var i = 0, len = aArray.length; i < len; i++) {
+    set.add(aArray[i], aAllowDuplicates);
+  }
+  return set;
+};
+
+/**
+ * Return how many unique items are in this ArraySet. If duplicates have been
+ * added, than those do not count towards the size.
+ *
+ * @returns Number
+ */
+ArraySet.prototype.size = function ArraySet_size() {
+  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
+};
+
+/**
+ * Add the given string to this set.
+ *
+ * @param String aStr
+ */
+ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
+  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
+  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+  var idx = this._array.length;
+  if (!isDuplicate || aAllowDuplicates) {
+    this._array.push(aStr);
+  }
+  if (!isDuplicate) {
+    if (hasNativeMap) {
+      this._set.set(aStr, idx);
+    } else {
+      this._set[sStr] = idx;
+    }
+  }
+};
+
+/**
+ * Is the given string a member of this set?
+ *
+ * @param String aStr
+ */
+ArraySet.prototype.has = function ArraySet_has(aStr) {
+  if (hasNativeMap) {
+    return this._set.has(aStr);
+  } else {
+    var sStr = util.toSetString(aStr);
+    return has.call(this._set, sStr);
+  }
+};
+
+/**
+ * What is the index of the given string in the array?
+ *
+ * @param String aStr
+ */
+ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+  if (hasNativeMap) {
+    var idx = this._set.get(aStr);
+    if (idx >= 0) {
+        return idx;
+    }
+  } else {
+    var sStr = util.toSetString(aStr);
+    if (has.call(this._set, sStr)) {
+      return this._set[sStr];
+    }
+  }
+
+  throw new Error('"' + aStr + '" is not in the set.');
+};
+
+/**
+ * What is the element at the given index?
+ *
+ * @param Number aIdx
+ */
+ArraySet.prototype.at = function ArraySet_at(aIdx) {
+  if (aIdx >= 0 && aIdx < this._array.length) {
+    return this._array[aIdx];
+  }
+  throw new Error('No element indexed by ' + aIdx);
+};
+
+/**
+ * Returns the array representation of this set (which has the proper indices
+ * indicated by indexOf). Note that this is a copy of the internal array used
+ * for storing the members so that no one can mess with internal state.
+ */
+ArraySet.prototype.toArray = function ArraySet_toArray() {
+  return this._array.slice();
+};
+
+exports.ArraySet = ArraySet;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/base64-vlq.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/base64-vlq.js
new file mode 100644
index 0000000..612b404
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/base64-vlq.js
@@ -0,0 +1,140 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ *
+ * Based on the Base 64 VLQ implementation in Closure Compiler:
+ * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
+ *
+ * Copyright 2011 The Closure Compiler Authors. All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *  * Neither the name of Google Inc. nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+var base64 = require('./base64');
+
+// A single base 64 digit can contain 6 bits of data. For the base 64 variable
+// length quantities we use in the source map spec, the first bit is the sign,
+// the next four bits are the actual value, and the 6th bit is the
+// continuation bit. The continuation bit tells us whether there are more
+// digits in this value following this digit.
+//
+//   Continuation
+//   |    Sign
+//   |    |
+//   V    V
+//   101011
+
+var VLQ_BASE_SHIFT = 5;
+
+// binary: 100000
+var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+
+// binary: 011111
+var VLQ_BASE_MASK = VLQ_BASE - 1;
+
+// binary: 100000
+var VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+/**
+ * Converts from a two-complement value to a value where the sign bit is
+ * placed in the least significant bit.  For example, as decimals:
+ *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+ *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+ */
+function toVLQSigned(aValue) {
+  return aValue < 0
+    ? ((-aValue) << 1) + 1
+    : (aValue << 1) + 0;
+}
+
+/**
+ * Converts to a two-complement value from a value where the sign bit is
+ * placed in the least significant bit.  For example, as decimals:
+ *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+ *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+ */
+function fromVLQSigned(aValue) {
+  var isNegative = (aValue & 1) === 1;
+  var shifted = aValue >> 1;
+  return isNegative
+    ? -shifted
+    : shifted;
+}
+
+/**
+ * Returns the base 64 VLQ encoded value.
+ */
+exports.encode = function base64VLQ_encode(aValue) {
+  var encoded = "";
+  var digit;
+
+  var vlq = toVLQSigned(aValue);
+
+  do {
+    digit = vlq & VLQ_BASE_MASK;
+    vlq >>>= VLQ_BASE_SHIFT;
+    if (vlq > 0) {
+      // There are still more digits in this value, so we must make sure the
+      // continuation bit is marked.
+      digit |= VLQ_CONTINUATION_BIT;
+    }
+    encoded += base64.encode(digit);
+  } while (vlq > 0);
+
+  return encoded;
+};
+
+/**
+ * Decodes the next base 64 VLQ value from the given string and returns the
+ * value and the rest of the string via the out parameter.
+ */
+exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
+  var strLen = aStr.length;
+  var result = 0;
+  var shift = 0;
+  var continuation, digit;
+
+  do {
+    if (aIndex >= strLen) {
+      throw new Error("Expected more digits in base 64 VLQ value.");
+    }
+
+    digit = base64.decode(aStr.charCodeAt(aIndex++));
+    if (digit === -1) {
+      throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
+    }
+
+    continuation = !!(digit & VLQ_CONTINUATION_BIT);
+    digit &= VLQ_BASE_MASK;
+    result = result + (digit << shift);
+    shift += VLQ_BASE_SHIFT;
+  } while (continuation);
+
+  aOutParam.value = fromVLQSigned(result);
+  aOutParam.rest = aIndex;
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/base64.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/base64.js
new file mode 100644
index 0000000..8aa86b3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/base64.js
@@ -0,0 +1,67 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+
+/**
+ * Encode an integer in the range of 0 to 63 to a single base 64 digit.
+ */
+exports.encode = function (number) {
+  if (0 <= number && number < intToCharMap.length) {
+    return intToCharMap[number];
+  }
+  throw new TypeError("Must be between 0 and 63: " + number);
+};
+
+/**
+ * Decode a single base 64 character code digit to an integer. Returns -1 on
+ * failure.
+ */
+exports.decode = function (charCode) {
+  var bigA = 65;     // 'A'
+  var bigZ = 90;     // 'Z'
+
+  var littleA = 97;  // 'a'
+  var littleZ = 122; // 'z'
+
+  var zero = 48;     // '0'
+  var nine = 57;     // '9'
+
+  var plus = 43;     // '+'
+  var slash = 47;    // '/'
+
+  var littleOffset = 26;
+  var numberOffset = 52;
+
+  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
+  if (bigA <= charCode && charCode <= bigZ) {
+    return (charCode - bigA);
+  }
+
+  // 26 - 51: abcdefghijklmnopqrstuvwxyz
+  if (littleA <= charCode && charCode <= littleZ) {
+    return (charCode - littleA + littleOffset);
+  }
+
+  // 52 - 61: 0123456789
+  if (zero <= charCode && charCode <= nine) {
+    return (charCode - zero + numberOffset);
+  }
+
+  // 62: +
+  if (charCode == plus) {
+    return 62;
+  }
+
+  // 63: /
+  if (charCode == slash) {
+    return 63;
+  }
+
+  // Invalid base64 digit.
+  return -1;
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/binary-search.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/binary-search.js
new file mode 100644
index 0000000..010ac94
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/binary-search.js
@@ -0,0 +1,111 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+exports.GREATEST_LOWER_BOUND = 1;
+exports.LEAST_UPPER_BOUND = 2;
+
+/**
+ * Recursive implementation of binary search.
+ *
+ * @param aLow Indices here and lower do not contain the needle.
+ * @param aHigh Indices here and higher do not contain the needle.
+ * @param aNeedle The element being searched for.
+ * @param aHaystack The non-empty array being searched.
+ * @param aCompare Function which takes two elements and returns -1, 0, or 1.
+ * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+ *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+ *     closest element that is smaller than or greater than the one we are
+ *     searching for, respectively, if the exact element cannot be found.
+ */
+function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
+  // This function terminates when one of the following is true:
+  //
+  //   1. We find the exact element we are looking for.
+  //
+  //   2. We did not find the exact element, but we can return the index of
+  //      the next-closest element.
+  //
+  //   3. We did not find the exact element, and there is no next-closest
+  //      element than the one we are searching for, so we return -1.
+  var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+  var cmp = aCompare(aNeedle, aHaystack[mid], true);
+  if (cmp === 0) {
+    // Found the element we are looking for.
+    return mid;
+  }
+  else if (cmp > 0) {
+    // Our needle is greater than aHaystack[mid].
+    if (aHigh - mid > 1) {
+      // The element is in the upper half.
+      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
+    }
+
+    // The exact needle element was not found in this haystack. Determine if
+    // we are in termination case (3) or (2) and return the appropriate thing.
+    if (aBias == exports.LEAST_UPPER_BOUND) {
+      return aHigh < aHaystack.length ? aHigh : -1;
+    } else {
+      return mid;
+    }
+  }
+  else {
+    // Our needle is less than aHaystack[mid].
+    if (mid - aLow > 1) {
+      // The element is in the lower half.
+      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
+    }
+
+    // we are in termination case (3) or (2) and return the appropriate thing.
+    if (aBias == exports.LEAST_UPPER_BOUND) {
+      return mid;
+    } else {
+      return aLow < 0 ? -1 : aLow;
+    }
+  }
+}
+
+/**
+ * This is an implementation of binary search which will always try and return
+ * the index of the closest element if there is no exact hit. This is because
+ * mappings between original and generated line/col pairs are single points,
+ * and there is an implicit region between each of them, so a miss just means
+ * that you aren't on the very start of a region.
+ *
+ * @param aNeedle The element you are looking for.
+ * @param aHaystack The array that is being searched.
+ * @param aCompare A function which takes the needle and an element in the
+ *     array and returns -1, 0, or 1 depending on whether the needle is less
+ *     than, equal to, or greater than the element, respectively.
+ * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+ *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+ *     closest element that is smaller than or greater than the one we are
+ *     searching for, respectively, if the exact element cannot be found.
+ *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
+ */
+exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+  if (aHaystack.length === 0) {
+    return -1;
+  }
+
+  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
+                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);
+  if (index < 0) {
+    return -1;
+  }
+
+  // We have found either the exact element, or the next-closest element than
+  // the one we are searching for. However, there may be more than one such
+  // element. Make sure we always return the smallest of these.
+  while (index - 1 >= 0) {
+    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+      break;
+    }
+    --index;
+  }
+
+  return index;
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/mapping-list.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/mapping-list.js
new file mode 100644
index 0000000..06d1274
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/mapping-list.js
@@ -0,0 +1,79 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2014 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var util = require('./util');
+
+/**
+ * Determine whether mappingB is after mappingA with respect to generated
+ * position.
+ */
+function generatedPositionAfter(mappingA, mappingB) {
+  // Optimized for most common case
+  var lineA = mappingA.generatedLine;
+  var lineB = mappingB.generatedLine;
+  var columnA = mappingA.generatedColumn;
+  var columnB = mappingB.generatedColumn;
+  return lineB > lineA || lineB == lineA && columnB >= columnA ||
+         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
+}
+
+/**
+ * A data structure to provide a sorted view of accumulated mappings in a
+ * performance conscious manner. It trades a neglibable overhead in general
+ * case for a large speedup in case of mappings being added in order.
+ */
+function MappingList() {
+  this._array = [];
+  this._sorted = true;
+  // Serves as infimum
+  this._last = {generatedLine: -1, generatedColumn: 0};
+}
+
+/**
+ * Iterate through internal items. This method takes the same arguments that
+ * `Array.prototype.forEach` takes.
+ *
+ * NOTE: The order of the mappings is NOT guaranteed.
+ */
+MappingList.prototype.unsortedForEach =
+  function MappingList_forEach(aCallback, aThisArg) {
+    this._array.forEach(aCallback, aThisArg);
+  };
+
+/**
+ * Add the given source mapping.
+ *
+ * @param Object aMapping
+ */
+MappingList.prototype.add = function MappingList_add(aMapping) {
+  if (generatedPositionAfter(this._last, aMapping)) {
+    this._last = aMapping;
+    this._array.push(aMapping);
+  } else {
+    this._sorted = false;
+    this._array.push(aMapping);
+  }
+};
+
+/**
+ * Returns the flat, sorted array of mappings. The mappings are sorted by
+ * generated position.
+ *
+ * WARNING: This method returns internal data without copying, for
+ * performance. The return value must NOT be mutated, and should be treated as
+ * an immutable borrow. If you want to take ownership, you must make your own
+ * copy.
+ */
+MappingList.prototype.toArray = function MappingList_toArray() {
+  if (!this._sorted) {
+    this._array.sort(util.compareByGeneratedPositionsInflated);
+    this._sorted = true;
+  }
+  return this._array;
+};
+
+exports.MappingList = MappingList;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/quick-sort.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/quick-sort.js
new file mode 100644
index 0000000..23f9eda
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/quick-sort.js
@@ -0,0 +1,132 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+// It turns out that some (most?) JavaScript engines don't self-host
+// `Array.prototype.sort`. This makes sense because C++ will likely remain
+// faster than JS when doing raw CPU-intensive sorting. However, when using a
+// custom comparator function, calling back and forth between the VM's C++ and
+// JIT'd JS is rather slow *and* loses JIT type information, resulting in
+// worse generated code for the comparator function than would be optimal. In
+// fact, when sorting with a comparator, these costs outweigh the benefits of
+// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
+// a ~3500ms mean speed-up in `bench/bench.html`.
+
+function SortTemplate(comparator) {
+
+/**
+ * Swap the elements indexed by `x` and `y` in the array `ary`.
+ *
+ * @param {Array} ary
+ *        The array.
+ * @param {Number} x
+ *        The index of the first item.
+ * @param {Number} y
+ *        The index of the second item.
+ */
+function swap(ary, x, y) {
+  var temp = ary[x];
+  ary[x] = ary[y];
+  ary[y] = temp;
+}
+
+/**
+ * Returns a random integer within the range `low .. high` inclusive.
+ *
+ * @param {Number} low
+ *        The lower bound on the range.
+ * @param {Number} high
+ *        The upper bound on the range.
+ */
+function randomIntInRange(low, high) {
+  return Math.round(low + (Math.random() * (high - low)));
+}
+
+/**
+ * The Quick Sort algorithm.
+ *
+ * @param {Array} ary
+ *        An array to sort.
+ * @param {function} comparator
+ *        Function to use to compare two items.
+ * @param {Number} p
+ *        Start index of the array
+ * @param {Number} r
+ *        End index of the array
+ */
+function doQuickSort(ary, comparator, p, r) {
+  // If our lower bound is less than our upper bound, we (1) partition the
+  // array into two pieces and (2) recurse on each half. If it is not, this is
+  // the empty array and our base case.
+
+  if (p < r) {
+    // (1) Partitioning.
+    //
+    // The partitioning chooses a pivot between `p` and `r` and moves all
+    // elements that are less than or equal to the pivot to the before it, and
+    // all the elements that are greater than it after it. The effect is that
+    // once partition is done, the pivot is in the exact place it will be when
+    // the array is put in sorted order, and it will not need to be moved
+    // again. This runs in O(n) time.
+
+    // Always choose a random pivot so that an input array which is reverse
+    // sorted does not cause O(n^2) running time.
+    var pivotIndex = randomIntInRange(p, r);
+    var i = p - 1;
+
+    swap(ary, pivotIndex, r);
+    var pivot = ary[r];
+
+    // Immediately after `j` is incremented in this loop, the following hold
+    // true:
+    //
+    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.
+    //
+    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
+    for (var j = p; j < r; j++) {
+      if (comparator(ary[j], pivot, false) <= 0) {
+        i += 1;
+        swap(ary, i, j);
+      }
+    }
+
+    swap(ary, i + 1, j);
+    var q = i + 1;
+
+    // (2) Recurse on each half.
+
+    doQuickSort(ary, comparator, p, q - 1);
+    doQuickSort(ary, comparator, q + 1, r);
+  }
+}
+
+  return doQuickSort;
+}
+
+function cloneSort(comparator) {
+  let template = SortTemplate.toString();
+  let templateFn = new Function(`return ${template}`)();
+  return templateFn(comparator);
+}
+
+/**
+ * Sort the given array in-place with the given comparator function.
+ *
+ * @param {Array} ary
+ *        An array to sort.
+ * @param {function} comparator
+ *        Function to use to compare two items.
+ */
+
+let sortCache = new WeakMap();
+exports.quickSort = function (ary, comparator, start = 0) {
+  let doQuickSort = sortCache.get(comparator);
+  if (doQuickSort === void 0) {
+    doQuickSort = cloneSort(comparator);
+    sortCache.set(comparator, doQuickSort);
+  }
+  doQuickSort(ary, comparator, start, ary.length - 1);
+};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-consumer.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-consumer.d.ts
new file mode 100644
index 0000000..744bda7
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-consumer.d.ts
@@ -0,0 +1 @@
+export { SourceMapConsumer } from '..';
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-consumer.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-consumer.js
new file mode 100644
index 0000000..ee66114
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-consumer.js
@@ -0,0 +1,1188 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var util = require('./util');
+var binarySearch = require('./binary-search');
+var ArraySet = require('./array-set').ArraySet;
+var base64VLQ = require('./base64-vlq');
+var quickSort = require('./quick-sort').quickSort;
+
+function SourceMapConsumer(aSourceMap, aSourceMapURL) {
+  var sourceMap = aSourceMap;
+  if (typeof aSourceMap === 'string') {
+    sourceMap = util.parseSourceMapInput(aSourceMap);
+  }
+
+  return sourceMap.sections != null
+    ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
+    : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
+}
+
+SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
+  return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
+}
+
+/**
+ * The version of the source mapping spec that we are consuming.
+ */
+SourceMapConsumer.prototype._version = 3;
+
+// `__generatedMappings` and `__originalMappings` are arrays that hold the
+// parsed mapping coordinates from the source map's "mappings" attribute. They
+// are lazily instantiated, accessed via the `_generatedMappings` and
+// `_originalMappings` getters respectively, and we only parse the mappings
+// and create these arrays once queried for a source location. We jump through
+// these hoops because there can be many thousands of mappings, and parsing
+// them is expensive, so we only want to do it if we must.
+//
+// Each object in the arrays is of the form:
+//
+//     {
+//       generatedLine: The line number in the generated code,
+//       generatedColumn: The column number in the generated code,
+//       source: The path to the original source file that generated this
+//               chunk of code,
+//       originalLine: The line number in the original source that
+//                     corresponds to this chunk of generated code,
+//       originalColumn: The column number in the original source that
+//                       corresponds to this chunk of generated code,
+//       name: The name of the original symbol which generated this chunk of
+//             code.
+//     }
+//
+// All properties except for `generatedLine` and `generatedColumn` can be
+// `null`.
+//
+// `_generatedMappings` is ordered by the generated positions.
+//
+// `_originalMappings` is ordered by the original positions.
+
+SourceMapConsumer.prototype.__generatedMappings = null;
+Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
+  configurable: true,
+  enumerable: true,
+  get: function () {
+    if (!this.__generatedMappings) {
+      this._parseMappings(this._mappings, this.sourceRoot);
+    }
+
+    return this.__generatedMappings;
+  }
+});
+
+SourceMapConsumer.prototype.__originalMappings = null;
+Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
+  configurable: true,
+  enumerable: true,
+  get: function () {
+    if (!this.__originalMappings) {
+      this._parseMappings(this._mappings, this.sourceRoot);
+    }
+
+    return this.__originalMappings;
+  }
+});
+
+SourceMapConsumer.prototype._charIsMappingSeparator =
+  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
+    var c = aStr.charAt(index);
+    return c === ";" || c === ",";
+  };
+
+/**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (the ordered arrays in the `this.__generatedMappings` and
+ * `this.__originalMappings` properties).
+ */
+SourceMapConsumer.prototype._parseMappings =
+  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    throw new Error("Subclasses must implement _parseMappings");
+  };
+
+SourceMapConsumer.GENERATED_ORDER = 1;
+SourceMapConsumer.ORIGINAL_ORDER = 2;
+
+SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+
+/**
+ * Iterate over each mapping between an original source/line/column and a
+ * generated line/column in this source map.
+ *
+ * @param Function aCallback
+ *        The function that is called with each mapping.
+ * @param Object aContext
+ *        Optional. If specified, this object will be the value of `this` every
+ *        time that `aCallback` is called.
+ * @param aOrder
+ *        Either `SourceMapConsumer.GENERATED_ORDER` or
+ *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+ *        iterate over the mappings sorted by the generated file's line/column
+ *        order or the original's source/line/column order, respectively. Defaults to
+ *        `SourceMapConsumer.GENERATED_ORDER`.
+ */
+SourceMapConsumer.prototype.eachMapping =
+  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+    var context = aContext || null;
+    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+
+    var mappings;
+    switch (order) {
+    case SourceMapConsumer.GENERATED_ORDER:
+      mappings = this._generatedMappings;
+      break;
+    case SourceMapConsumer.ORIGINAL_ORDER:
+      mappings = this._originalMappings;
+      break;
+    default:
+      throw new Error("Unknown order of iteration.");
+    }
+
+    var sourceRoot = this.sourceRoot;
+    var boundCallback = aCallback.bind(context);
+    var names = this._names;
+    var sources = this._sources;
+    var sourceMapURL = this._sourceMapURL;
+
+    for (var i = 0, n = mappings.length; i < n; i++) {
+      var mapping = mappings[i];
+      var source = mapping.source === null ? null : sources.at(mapping.source);
+      if(source !== null) {
+        source = util.computeSourceURL(sourceRoot, source, sourceMapURL);
+      }
+      boundCallback({
+        source: source,
+        generatedLine: mapping.generatedLine,
+        generatedColumn: mapping.generatedColumn,
+        originalLine: mapping.originalLine,
+        originalColumn: mapping.originalColumn,
+        name: mapping.name === null ? null : names.at(mapping.name)
+      });
+    }
+  };
+
+/**
+ * Returns all generated line and column information for the original source,
+ * line, and column provided. If no column is provided, returns all mappings
+ * corresponding to a either the line we are searching for or the next
+ * closest line that has any mappings. Otherwise, returns all mappings
+ * corresponding to the given line and either the column we are searching for
+ * or the next closest column that has any offsets.
+ *
+ * The only argument is an object with the following properties:
+ *
+ *   - source: The filename of the original source.
+ *   - line: The line number in the original source.  The line number is 1-based.
+ *   - column: Optional. the column number in the original source.
+ *    The column number is 0-based.
+ *
+ * and an array of objects is returned, each with the following properties:
+ *
+ *   - line: The line number in the generated source, or null.  The
+ *    line number is 1-based.
+ *   - column: The column number in the generated source, or null.
+ *    The column number is 0-based.
+ */
+SourceMapConsumer.prototype.allGeneratedPositionsFor =
+  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+    var line = util.getArg(aArgs, 'line');
+
+    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
+    // returns the index of the closest mapping less than the needle. By
+    // setting needle.originalColumn to 0, we thus find the last mapping for
+    // the given line, provided such a mapping exists.
+    var needle = {
+      source: util.getArg(aArgs, 'source'),
+      originalLine: line,
+      originalColumn: util.getArg(aArgs, 'column', 0)
+    };
+
+    needle.source = this._findSourceIndex(needle.source);
+    if (needle.source < 0) {
+      return [];
+    }
+
+    var mappings = [];
+
+    var index = this._findMapping(needle,
+                                  this._originalMappings,
+                                  "originalLine",
+                                  "originalColumn",
+                                  util.compareByOriginalPositions,
+                                  binarySearch.LEAST_UPPER_BOUND);
+    if (index >= 0) {
+      var mapping = this._originalMappings[index];
+
+      if (aArgs.column === undefined) {
+        var originalLine = mapping.originalLine;
+
+        // Iterate until either we run out of mappings, or we run into
+        // a mapping for a different line than the one we found. Since
+        // mappings are sorted, this is guaranteed to find all mappings for
+        // the line we found.
+        while (mapping && mapping.originalLine === originalLine) {
+          mappings.push({
+            line: util.getArg(mapping, 'generatedLine', null),
+            column: util.getArg(mapping, 'generatedColumn', null),
+            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+          });
+
+          mapping = this._originalMappings[++index];
+        }
+      } else {
+        var originalColumn = mapping.originalColumn;
+
+        // Iterate until either we run out of mappings, or we run into
+        // a mapping for a different line than the one we were searching for.
+        // Since mappings are sorted, this is guaranteed to find all mappings for
+        // the line we are searching for.
+        while (mapping &&
+               mapping.originalLine === line &&
+               mapping.originalColumn == originalColumn) {
+          mappings.push({
+            line: util.getArg(mapping, 'generatedLine', null),
+            column: util.getArg(mapping, 'generatedColumn', null),
+            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+          });
+
+          mapping = this._originalMappings[++index];
+        }
+      }
+    }
+
+    return mappings;
+  };
+
+exports.SourceMapConsumer = SourceMapConsumer;
+
+/**
+ * A BasicSourceMapConsumer instance represents a parsed source map which we can
+ * query for information about the original file positions by giving it a file
+ * position in the generated source.
+ *
+ * The first parameter is the raw source map (either as a JSON string, or
+ * already parsed to an object). According to the spec, source maps have the
+ * following attributes:
+ *
+ *   - version: Which version of the source map spec this map is following.
+ *   - sources: An array of URLs to the original source files.
+ *   - names: An array of identifiers which can be referrenced by individual mappings.
+ *   - sourceRoot: Optional. The URL root from which all sources are relative.
+ *   - sourcesContent: Optional. An array of contents of the original source files.
+ *   - mappings: A string of base64 VLQs which contain the actual mappings.
+ *   - file: Optional. The generated file this source map is associated with.
+ *
+ * Here is an example source map, taken from the source map spec[0]:
+ *
+ *     {
+ *       version : 3,
+ *       file: "out.js",
+ *       sourceRoot : "",
+ *       sources: ["foo.js", "bar.js"],
+ *       names: ["src", "maps", "are", "fun"],
+ *       mappings: "AA,AB;;ABCDE;"
+ *     }
+ *
+ * The second parameter, if given, is a string whose value is the URL
+ * at which the source map was found.  This URL is used to compute the
+ * sources array.
+ *
+ * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
+ */
+function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
+  var sourceMap = aSourceMap;
+  if (typeof aSourceMap === 'string') {
+    sourceMap = util.parseSourceMapInput(aSourceMap);
+  }
+
+  var version = util.getArg(sourceMap, 'version');
+  var sources = util.getArg(sourceMap, 'sources');
+  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
+  // requires the array) to play nice here.
+  var names = util.getArg(sourceMap, 'names', []);
+  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
+  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
+  var mappings = util.getArg(sourceMap, 'mappings');
+  var file = util.getArg(sourceMap, 'file', null);
+
+  // Once again, Sass deviates from the spec and supplies the version as a
+  // string rather than a number, so we use loose equality checking here.
+  if (version != this._version) {
+    throw new Error('Unsupported version: ' + version);
+  }
+
+  if (sourceRoot) {
+    sourceRoot = util.normalize(sourceRoot);
+  }
+
+  sources = sources
+    .map(String)
+    // Some source maps produce relative source paths like "./foo.js" instead of
+    // "foo.js".  Normalize these first so that future comparisons will succeed.
+    // See bugzil.la/1090768.
+    .map(util.normalize)
+    // Always ensure that absolute sources are internally stored relative to
+    // the source root, if the source root is absolute. Not doing this would
+    // be particularly problematic when the source root is a prefix of the
+    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
+    .map(function (source) {
+      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
+        ? util.relative(sourceRoot, source)
+        : source;
+    });
+
+  // Pass `true` below to allow duplicate names and sources. While source maps
+  // are intended to be compressed and deduplicated, the TypeScript compiler
+  // sometimes generates source maps with duplicates in them. See Github issue
+  // #72 and bugzil.la/889492.
+  this._names = ArraySet.fromArray(names.map(String), true);
+  this._sources = ArraySet.fromArray(sources, true);
+
+  this._absoluteSources = this._sources.toArray().map(function (s) {
+    return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+  });
+
+  this.sourceRoot = sourceRoot;
+  this.sourcesContent = sourcesContent;
+  this._mappings = mappings;
+  this._sourceMapURL = aSourceMapURL;
+  this.file = file;
+}
+
+BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+
+/**
+ * Utility function to find the index of a source.  Returns -1 if not
+ * found.
+ */
+BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
+  var relativeSource = aSource;
+  if (this.sourceRoot != null) {
+    relativeSource = util.relative(this.sourceRoot, relativeSource);
+  }
+
+  if (this._sources.has(relativeSource)) {
+    return this._sources.indexOf(relativeSource);
+  }
+
+  // Maybe aSource is an absolute URL as returned by |sources|.  In
+  // this case we can't simply undo the transform.
+  var i;
+  for (i = 0; i < this._absoluteSources.length; ++i) {
+    if (this._absoluteSources[i] == aSource) {
+      return i;
+    }
+  }
+
+  return -1;
+};
+
+/**
+ * Create a BasicSourceMapConsumer from a SourceMapGenerator.
+ *
+ * @param SourceMapGenerator aSourceMap
+ *        The source map that will be consumed.
+ * @param String aSourceMapURL
+ *        The URL at which the source map can be found (optional)
+ * @returns BasicSourceMapConsumer
+ */
+BasicSourceMapConsumer.fromSourceMap =
+  function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
+    var smc = Object.create(BasicSourceMapConsumer.prototype);
+
+    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
+    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
+    smc.sourceRoot = aSourceMap._sourceRoot;
+    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
+                                                            smc.sourceRoot);
+    smc.file = aSourceMap._file;
+    smc._sourceMapURL = aSourceMapURL;
+    smc._absoluteSources = smc._sources.toArray().map(function (s) {
+      return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
+    });
+
+    // Because we are modifying the entries (by converting string sources and
+    // names to indices into the sources and names ArraySets), we have to make
+    // a copy of the entry or else bad things happen. Shared mutable state
+    // strikes again! See github issue #191.
+
+    var generatedMappings = aSourceMap._mappings.toArray().slice();
+    var destGeneratedMappings = smc.__generatedMappings = [];
+    var destOriginalMappings = smc.__originalMappings = [];
+
+    for (var i = 0, length = generatedMappings.length; i < length; i++) {
+      var srcMapping = generatedMappings[i];
+      var destMapping = new Mapping;
+      destMapping.generatedLine = srcMapping.generatedLine;
+      destMapping.generatedColumn = srcMapping.generatedColumn;
+
+      if (srcMapping.source) {
+        destMapping.source = sources.indexOf(srcMapping.source);
+        destMapping.originalLine = srcMapping.originalLine;
+        destMapping.originalColumn = srcMapping.originalColumn;
+
+        if (srcMapping.name) {
+          destMapping.name = names.indexOf(srcMapping.name);
+        }
+
+        destOriginalMappings.push(destMapping);
+      }
+
+      destGeneratedMappings.push(destMapping);
+    }
+
+    quickSort(smc.__originalMappings, util.compareByOriginalPositions);
+
+    return smc;
+  };
+
+/**
+ * The version of the source mapping spec that we are consuming.
+ */
+BasicSourceMapConsumer.prototype._version = 3;
+
+/**
+ * The list of original sources.
+ */
+Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
+  get: function () {
+    return this._absoluteSources.slice();
+  }
+});
+
+/**
+ * Provide the JIT with a nice shape / hidden class.
+ */
+function Mapping() {
+  this.generatedLine = 0;
+  this.generatedColumn = 0;
+  this.source = null;
+  this.originalLine = null;
+  this.originalColumn = null;
+  this.name = null;
+}
+
+/**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (the ordered arrays in the `this.__generatedMappings` and
+ * `this.__originalMappings` properties).
+ */
+
+const compareGenerated = util.compareByGeneratedPositionsDeflatedNoLine;
+function sortGenerated(array, start) {
+  let l = array.length;
+  let n = array.length - start;
+  if (n <= 1) {
+    return;
+  } else if (n == 2) {
+    let a = array[start];
+    let b = array[start + 1];
+    if (compareGenerated(a, b) > 0) {
+      array[start] = b;
+      array[start + 1] = a;
+    }
+  } else if (n < 20) {
+    for (let i = start; i < l; i++) {
+      for (let j = i; j > start; j--) {
+        let a = array[j - 1];
+        let b = array[j];
+        if (compareGenerated(a, b) <= 0) {
+          break;
+        }
+        array[j - 1] = b;
+        array[j] = a;
+      }
+    }
+  } else {
+    quickSort(array, compareGenerated, start);
+  }
+}
+BasicSourceMapConsumer.prototype._parseMappings =
+  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    var generatedLine = 1;
+    var previousGeneratedColumn = 0;
+    var previousOriginalLine = 0;
+    var previousOriginalColumn = 0;
+    var previousSource = 0;
+    var previousName = 0;
+    var length = aStr.length;
+    var index = 0;
+    var cachedSegments = {};
+    var temp = {};
+    var originalMappings = [];
+    var generatedMappings = [];
+    var mapping, str, segment, end, value;
+
+    let subarrayStart = 0;
+    while (index < length) {
+      if (aStr.charAt(index) === ';') {
+        generatedLine++;
+        index++;
+        previousGeneratedColumn = 0;
+
+        sortGenerated(generatedMappings, subarrayStart);
+        subarrayStart = generatedMappings.length;
+      }
+      else if (aStr.charAt(index) === ',') {
+        index++;
+      }
+      else {
+        mapping = new Mapping();
+        mapping.generatedLine = generatedLine;
+
+        for (end = index; end < length; end++) {
+          if (this._charIsMappingSeparator(aStr, end)) {
+            break;
+          }
+        }
+        str = aStr.slice(index, end);
+
+        segment = [];
+        while (index < end) {
+          base64VLQ.decode(aStr, index, temp);
+          value = temp.value;
+          index = temp.rest;
+          segment.push(value);
+        }
+
+        if (segment.length === 2) {
+          throw new Error('Found a source, but no line and column');
+        }
+
+        if (segment.length === 3) {
+          throw new Error('Found a source and line, but no column');
+        }
+
+        // Generated column.
+        mapping.generatedColumn = previousGeneratedColumn + segment[0];
+        previousGeneratedColumn = mapping.generatedColumn;
+
+        if (segment.length > 1) {
+          // Original source.
+          mapping.source = previousSource + segment[1];
+          previousSource += segment[1];
+
+          // Original line.
+          mapping.originalLine = previousOriginalLine + segment[2];
+          previousOriginalLine = mapping.originalLine;
+          // Lines are stored 0-based
+          mapping.originalLine += 1;
+
+          // Original column.
+          mapping.originalColumn = previousOriginalColumn + segment[3];
+          previousOriginalColumn = mapping.originalColumn;
+
+          if (segment.length > 4) {
+            // Original name.
+            mapping.name = previousName + segment[4];
+            previousName += segment[4];
+          }
+        }
+
+        generatedMappings.push(mapping);
+        if (typeof mapping.originalLine === 'number') {
+          let currentSource = mapping.source;
+          while (originalMappings.length <= currentSource) {
+            originalMappings.push(null);
+          }
+          if (originalMappings[currentSource] === null) {
+            originalMappings[currentSource] = [];
+          }
+          originalMappings[currentSource].push(mapping);
+        }
+      }
+    }
+
+    sortGenerated(generatedMappings, subarrayStart);
+    this.__generatedMappings = generatedMappings;
+
+    for (var i = 0; i < originalMappings.length; i++) {
+      if (originalMappings[i] != null) {
+        quickSort(originalMappings[i], util.compareByOriginalPositionsNoSource);
+      }
+    }
+    this.__originalMappings = [].concat(...originalMappings);
+  };
+
+/**
+ * Find the mapping that best matches the hypothetical "needle" mapping that
+ * we are searching for in the given "haystack" of mappings.
+ */
+BasicSourceMapConsumer.prototype._findMapping =
+  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
+                                         aColumnName, aComparator, aBias) {
+    // To return the position we are searching for, we must first find the
+    // mapping for the given position and then return the opposite position it
+    // points to. Because the mappings are sorted, we can use binary search to
+    // find the best mapping.
+
+    if (aNeedle[aLineName] <= 0) {
+      throw new TypeError('Line must be greater than or equal to 1, got '
+                          + aNeedle[aLineName]);
+    }
+    if (aNeedle[aColumnName] < 0) {
+      throw new TypeError('Column must be greater than or equal to 0, got '
+                          + aNeedle[aColumnName]);
+    }
+
+    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
+  };
+
+/**
+ * Compute the last column for each generated mapping. The last column is
+ * inclusive.
+ */
+BasicSourceMapConsumer.prototype.computeColumnSpans =
+  function SourceMapConsumer_computeColumnSpans() {
+    for (var index = 0; index < this._generatedMappings.length; ++index) {
+      var mapping = this._generatedMappings[index];
+
+      // Mappings do not contain a field for the last generated columnt. We
+      // can come up with an optimistic estimate, however, by assuming that
+      // mappings are contiguous (i.e. given two consecutive mappings, the
+      // first mapping ends where the second one starts).
+      if (index + 1 < this._generatedMappings.length) {
+        var nextMapping = this._generatedMappings[index + 1];
+
+        if (mapping.generatedLine === nextMapping.generatedLine) {
+          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
+          continue;
+        }
+      }
+
+      // The last mapping for each line spans the entire line.
+      mapping.lastGeneratedColumn = Infinity;
+    }
+  };
+
+/**
+ * Returns the original source, line, and column information for the generated
+ * source's line and column positions provided. The only argument is an object
+ * with the following properties:
+ *
+ *   - line: The line number in the generated source.  The line number
+ *     is 1-based.
+ *   - column: The column number in the generated source.  The column
+ *     number is 0-based.
+ *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+ *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+ *     closest element that is smaller than or greater than the one we are
+ *     searching for, respectively, if the exact element cannot be found.
+ *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+ *
+ * and an object is returned with the following properties:
+ *
+ *   - source: The original source file, or null.
+ *   - line: The line number in the original source, or null.  The
+ *     line number is 1-based.
+ *   - column: The column number in the original source, or null.  The
+ *     column number is 0-based.
+ *   - name: The original identifier, or null.
+ */
+BasicSourceMapConsumer.prototype.originalPositionFor =
+  function SourceMapConsumer_originalPositionFor(aArgs) {
+    var needle = {
+      generatedLine: util.getArg(aArgs, 'line'),
+      generatedColumn: util.getArg(aArgs, 'column')
+    };
+
+    var index = this._findMapping(
+      needle,
+      this._generatedMappings,
+      "generatedLine",
+      "generatedColumn",
+      util.compareByGeneratedPositionsDeflated,
+      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
+    );
+
+    if (index >= 0) {
+      var mapping = this._generatedMappings[index];
+
+      if (mapping.generatedLine === needle.generatedLine) {
+        var source = util.getArg(mapping, 'source', null);
+        if (source !== null) {
+          source = this._sources.at(source);
+          source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
+        }
+        var name = util.getArg(mapping, 'name', null);
+        if (name !== null) {
+          name = this._names.at(name);
+        }
+        return {
+          source: source,
+          line: util.getArg(mapping, 'originalLine', null),
+          column: util.getArg(mapping, 'originalColumn', null),
+          name: name
+        };
+      }
+    }
+
+    return {
+      source: null,
+      line: null,
+      column: null,
+      name: null
+    };
+  };
+
+/**
+ * Return true if we have the source content for every source in the source
+ * map, false otherwise.
+ */
+BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
+  function BasicSourceMapConsumer_hasContentsOfAllSources() {
+    if (!this.sourcesContent) {
+      return false;
+    }
+    return this.sourcesContent.length >= this._sources.size() &&
+      !this.sourcesContent.some(function (sc) { return sc == null; });
+  };
+
+/**
+ * Returns the original source content. The only argument is the url of the
+ * original source file. Returns null if no original source content is
+ * available.
+ */
+BasicSourceMapConsumer.prototype.sourceContentFor =
+  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+    if (!this.sourcesContent) {
+      return null;
+    }
+
+    var index = this._findSourceIndex(aSource);
+    if (index >= 0) {
+      return this.sourcesContent[index];
+    }
+
+    var relativeSource = aSource;
+    if (this.sourceRoot != null) {
+      relativeSource = util.relative(this.sourceRoot, relativeSource);
+    }
+
+    var url;
+    if (this.sourceRoot != null
+        && (url = util.urlParse(this.sourceRoot))) {
+      // XXX: file:// URIs and absolute paths lead to unexpected behavior for
+      // many users. We can help them out when they expect file:// URIs to
+      // behave like it would if they were running a local HTTP server. See
+      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
+      var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
+      if (url.scheme == "file"
+          && this._sources.has(fileUriAbsPath)) {
+        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
+      }
+
+      if ((!url.path || url.path == "/")
+          && this._sources.has("/" + relativeSource)) {
+        return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
+      }
+    }
+
+    // This function is used recursively from
+    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
+    // don't want to throw if we can't find the source - we just want to
+    // return null, so we provide a flag to exit gracefully.
+    if (nullOnMissing) {
+      return null;
+    }
+    else {
+      throw new Error('"' + relativeSource + '" is not in the SourceMap.');
+    }
+  };
+
+/**
+ * Returns the generated line and column information for the original source,
+ * line, and column positions provided. The only argument is an object with
+ * the following properties:
+ *
+ *   - source: The filename of the original source.
+ *   - line: The line number in the original source.  The line number
+ *     is 1-based.
+ *   - column: The column number in the original source.  The column
+ *     number is 0-based.
+ *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+ *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+ *     closest element that is smaller than or greater than the one we are
+ *     searching for, respectively, if the exact element cannot be found.
+ *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+ *
+ * and an object is returned with the following properties:
+ *
+ *   - line: The line number in the generated source, or null.  The
+ *     line number is 1-based.
+ *   - column: The column number in the generated source, or null.
+ *     The column number is 0-based.
+ */
+BasicSourceMapConsumer.prototype.generatedPositionFor =
+  function SourceMapConsumer_generatedPositionFor(aArgs) {
+    var source = util.getArg(aArgs, 'source');
+    source = this._findSourceIndex(source);
+    if (source < 0) {
+      return {
+        line: null,
+        column: null,
+        lastColumn: null
+      };
+    }
+
+    var needle = {
+      source: source,
+      originalLine: util.getArg(aArgs, 'line'),
+      originalColumn: util.getArg(aArgs, 'column')
+    };
+
+    var index = this._findMapping(
+      needle,
+      this._originalMappings,
+      "originalLine",
+      "originalColumn",
+      util.compareByOriginalPositions,
+      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
+    );
+
+    if (index >= 0) {
+      var mapping = this._originalMappings[index];
+
+      if (mapping.source === needle.source) {
+        return {
+          line: util.getArg(mapping, 'generatedLine', null),
+          column: util.getArg(mapping, 'generatedColumn', null),
+          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+        };
+      }
+    }
+
+    return {
+      line: null,
+      column: null,
+      lastColumn: null
+    };
+  };
+
+exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
+
+/**
+ * An IndexedSourceMapConsumer instance represents a parsed source map which
+ * we can query for information. It differs from BasicSourceMapConsumer in
+ * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
+ * input.
+ *
+ * The first parameter is a raw source map (either as a JSON string, or already
+ * parsed to an object). According to the spec for indexed source maps, they
+ * have the following attributes:
+ *
+ *   - version: Which version of the source map spec this map is following.
+ *   - file: Optional. The generated file this source map is associated with.
+ *   - sections: A list of section definitions.
+ *
+ * Each value under the "sections" field has two fields:
+ *   - offset: The offset into the original specified at which this section
+ *       begins to apply, defined as an object with a "line" and "column"
+ *       field.
+ *   - map: A source map definition. This source map could also be indexed,
+ *       but doesn't have to be.
+ *
+ * Instead of the "map" field, it's also possible to have a "url" field
+ * specifying a URL to retrieve a source map from, but that's currently
+ * unsupported.
+ *
+ * Here's an example source map, taken from the source map spec[0], but
+ * modified to omit a section which uses the "url" field.
+ *
+ *  {
+ *    version : 3,
+ *    file: "app.js",
+ *    sections: [{
+ *      offset: {line:100, column:10},
+ *      map: {
+ *        version : 3,
+ *        file: "section.js",
+ *        sources: ["foo.js", "bar.js"],
+ *        names: ["src", "maps", "are", "fun"],
+ *        mappings: "AAAA,E;;ABCDE;"
+ *      }
+ *    }],
+ *  }
+ *
+ * The second parameter, if given, is a string whose value is the URL
+ * at which the source map was found.  This URL is used to compute the
+ * sources array.
+ *
+ * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
+ */
+function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
+  var sourceMap = aSourceMap;
+  if (typeof aSourceMap === 'string') {
+    sourceMap = util.parseSourceMapInput(aSourceMap);
+  }
+
+  var version = util.getArg(sourceMap, 'version');
+  var sections = util.getArg(sourceMap, 'sections');
+
+  if (version != this._version) {
+    throw new Error('Unsupported version: ' + version);
+  }
+
+  this._sources = new ArraySet();
+  this._names = new ArraySet();
+
+  var lastOffset = {
+    line: -1,
+    column: 0
+  };
+  this._sections = sections.map(function (s) {
+    if (s.url) {
+      // The url field will require support for asynchronicity.
+      // See https://github.com/mozilla/source-map/issues/16
+      throw new Error('Support for url field in sections not implemented.');
+    }
+    var offset = util.getArg(s, 'offset');
+    var offsetLine = util.getArg(offset, 'line');
+    var offsetColumn = util.getArg(offset, 'column');
+
+    if (offsetLine < lastOffset.line ||
+        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
+      throw new Error('Section offsets must be ordered and non-overlapping.');
+    }
+    lastOffset = offset;
+
+    return {
+      generatedOffset: {
+        // The offset fields are 0-based, but we use 1-based indices when
+        // encoding/decoding from VLQ.
+        generatedLine: offsetLine + 1,
+        generatedColumn: offsetColumn + 1
+      },
+      consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)
+    }
+  });
+}
+
+IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
+
+/**
+ * The version of the source mapping spec that we are consuming.
+ */
+IndexedSourceMapConsumer.prototype._version = 3;
+
+/**
+ * The list of original sources.
+ */
+Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
+  get: function () {
+    var sources = [];
+    for (var i = 0; i < this._sections.length; i++) {
+      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
+        sources.push(this._sections[i].consumer.sources[j]);
+      }
+    }
+    return sources;
+  }
+});
+
+/**
+ * Returns the original source, line, and column information for the generated
+ * source's line and column positions provided. The only argument is an object
+ * with the following properties:
+ *
+ *   - line: The line number in the generated source.  The line number
+ *     is 1-based.
+ *   - column: The column number in the generated source.  The column
+ *     number is 0-based.
+ *
+ * and an object is returned with the following properties:
+ *
+ *   - source: The original source file, or null.
+ *   - line: The line number in the original source, or null.  The
+ *     line number is 1-based.
+ *   - column: The column number in the original source, or null.  The
+ *     column number is 0-based.
+ *   - name: The original identifier, or null.
+ */
+IndexedSourceMapConsumer.prototype.originalPositionFor =
+  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
+    var needle = {
+      generatedLine: util.getArg(aArgs, 'line'),
+      generatedColumn: util.getArg(aArgs, 'column')
+    };
+
+    // Find the section containing the generated position we're trying to map
+    // to an original position.
+    var sectionIndex = binarySearch.search(needle, this._sections,
+      function(needle, section) {
+        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
+        if (cmp) {
+          return cmp;
+        }
+
+        return (needle.generatedColumn -
+                section.generatedOffset.generatedColumn);
+      });
+    var section = this._sections[sectionIndex];
+
+    if (!section) {
+      return {
+        source: null,
+        line: null,
+        column: null,
+        name: null
+      };
+    }
+
+    return section.consumer.originalPositionFor({
+      line: needle.generatedLine -
+        (section.generatedOffset.generatedLine - 1),
+      column: needle.generatedColumn -
+        (section.generatedOffset.generatedLine === needle.generatedLine
+         ? section.generatedOffset.generatedColumn - 1
+         : 0),
+      bias: aArgs.bias
+    });
+  };
+
+/**
+ * Return true if we have the source content for every source in the source
+ * map, false otherwise.
+ */
+IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
+  function IndexedSourceMapConsumer_hasContentsOfAllSources() {
+    return this._sections.every(function (s) {
+      return s.consumer.hasContentsOfAllSources();
+    });
+  };
+
+/**
+ * Returns the original source content. The only argument is the url of the
+ * original source file. Returns null if no original source content is
+ * available.
+ */
+IndexedSourceMapConsumer.prototype.sourceContentFor =
+  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+    for (var i = 0; i < this._sections.length; i++) {
+      var section = this._sections[i];
+
+      var content = section.consumer.sourceContentFor(aSource, true);
+      if (content || content === '') {
+        return content;
+      }
+    }
+    if (nullOnMissing) {
+      return null;
+    }
+    else {
+      throw new Error('"' + aSource + '" is not in the SourceMap.');
+    }
+  };
+
+/**
+ * Returns the generated line and column information for the original source,
+ * line, and column positions provided. The only argument is an object with
+ * the following properties:
+ *
+ *   - source: The filename of the original source.
+ *   - line: The line number in the original source.  The line number
+ *     is 1-based.
+ *   - column: The column number in the original source.  The column
+ *     number is 0-based.
+ *
+ * and an object is returned with the following properties:
+ *
+ *   - line: The line number in the generated source, or null.  The
+ *     line number is 1-based. 
+ *   - column: The column number in the generated source, or null.
+ *     The column number is 0-based.
+ */
+IndexedSourceMapConsumer.prototype.generatedPositionFor =
+  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
+    for (var i = 0; i < this._sections.length; i++) {
+      var section = this._sections[i];
+
+      // Only consider this section if the requested source is in the list of
+      // sources of the consumer.
+      if (section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1) {
+        continue;
+      }
+      var generatedPosition = section.consumer.generatedPositionFor(aArgs);
+      if (generatedPosition) {
+        var ret = {
+          line: generatedPosition.line +
+            (section.generatedOffset.generatedLine - 1),
+          column: generatedPosition.column +
+            (section.generatedOffset.generatedLine === generatedPosition.line
+             ? section.generatedOffset.generatedColumn - 1
+             : 0)
+        };
+        return ret;
+      }
+    }
+
+    return {
+      line: null,
+      column: null
+    };
+  };
+
+/**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (the ordered arrays in the `this.__generatedMappings` and
+ * `this.__originalMappings` properties).
+ */
+IndexedSourceMapConsumer.prototype._parseMappings =
+  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    this.__generatedMappings = [];
+    this.__originalMappings = [];
+    for (var i = 0; i < this._sections.length; i++) {
+      var section = this._sections[i];
+      var sectionMappings = section.consumer._generatedMappings;
+      for (var j = 0; j < sectionMappings.length; j++) {
+        var mapping = sectionMappings[j];
+
+        var source = section.consumer._sources.at(mapping.source);
+        if(source !== null) {
+          source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
+        }
+        this._sources.add(source);
+        source = this._sources.indexOf(source);
+
+        var name = null;
+        if (mapping.name) {
+          name = section.consumer._names.at(mapping.name);
+          this._names.add(name);
+          name = this._names.indexOf(name);
+        }
+
+        // The mappings coming from the consumer for the section have
+        // generated positions relative to the start of the section, so we
+        // need to offset them to be relative to the start of the concatenated
+        // generated file.
+        var adjustedMapping = {
+          source: source,
+          generatedLine: mapping.generatedLine +
+            (section.generatedOffset.generatedLine - 1),
+          generatedColumn: mapping.generatedColumn +
+            (section.generatedOffset.generatedLine === mapping.generatedLine
+            ? section.generatedOffset.generatedColumn - 1
+            : 0),
+          originalLine: mapping.originalLine,
+          originalColumn: mapping.originalColumn,
+          name: name
+        };
+
+        this.__generatedMappings.push(adjustedMapping);
+        if (typeof adjustedMapping.originalLine === 'number') {
+          this.__originalMappings.push(adjustedMapping);
+        }
+      }
+    }
+
+    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
+    quickSort(this.__originalMappings, util.compareByOriginalPositions);
+  };
+
+exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-generator.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-generator.d.ts
new file mode 100644
index 0000000..f59d70a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-generator.d.ts
@@ -0,0 +1 @@
+export { SourceMapGenerator } from '..';
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-generator.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-generator.js
new file mode 100644
index 0000000..bab04ff
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-map-generator.js
@@ -0,0 +1,444 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var base64VLQ = require('./base64-vlq');
+var util = require('./util');
+var ArraySet = require('./array-set').ArraySet;
+var MappingList = require('./mapping-list').MappingList;
+
+/**
+ * An instance of the SourceMapGenerator represents a source map which is
+ * being built incrementally. You may pass an object with the following
+ * properties:
+ *
+ *   - file: The filename of the generated source.
+ *   - sourceRoot: A root for all relative URLs in this source map.
+ */
+function SourceMapGenerator(aArgs) {
+  if (!aArgs) {
+    aArgs = {};
+  }
+  this._file = util.getArg(aArgs, 'file', null);
+  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
+  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
+  this._ignoreInvalidMapping = util.getArg(aArgs, 'ignoreInvalidMapping', false);
+  this._sources = new ArraySet();
+  this._names = new ArraySet();
+  this._mappings = new MappingList();
+  this._sourcesContents = null;
+}
+
+SourceMapGenerator.prototype._version = 3;
+
+/**
+ * Creates a new SourceMapGenerator based on a SourceMapConsumer
+ *
+ * @param aSourceMapConsumer The SourceMap.
+ */
+SourceMapGenerator.fromSourceMap =
+  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer, generatorOps) {
+    var sourceRoot = aSourceMapConsumer.sourceRoot;
+    var generator = new SourceMapGenerator(Object.assign(generatorOps || {}, {
+      file: aSourceMapConsumer.file,
+      sourceRoot: sourceRoot
+    }));
+    aSourceMapConsumer.eachMapping(function (mapping) {
+      var newMapping = {
+        generated: {
+          line: mapping.generatedLine,
+          column: mapping.generatedColumn
+        }
+      };
+
+      if (mapping.source != null) {
+        newMapping.source = mapping.source;
+        if (sourceRoot != null) {
+          newMapping.source = util.relative(sourceRoot, newMapping.source);
+        }
+
+        newMapping.original = {
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        };
+
+        if (mapping.name != null) {
+          newMapping.name = mapping.name;
+        }
+      }
+
+      generator.addMapping(newMapping);
+    });
+    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+      var sourceRelative = sourceFile;
+      if (sourceRoot !== null) {
+        sourceRelative = util.relative(sourceRoot, sourceFile);
+      }
+
+      if (!generator._sources.has(sourceRelative)) {
+        generator._sources.add(sourceRelative);
+      }
+
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        generator.setSourceContent(sourceFile, content);
+      }
+    });
+    return generator;
+  };
+
+/**
+ * Add a single mapping from original source line and column to the generated
+ * source's line and column for this source map being created. The mapping
+ * object should have the following properties:
+ *
+ *   - generated: An object with the generated line and column positions.
+ *   - original: An object with the original line and column positions.
+ *   - source: The original source file (relative to the sourceRoot).
+ *   - name: An optional original token name for this mapping.
+ */
+SourceMapGenerator.prototype.addMapping =
+  function SourceMapGenerator_addMapping(aArgs) {
+    var generated = util.getArg(aArgs, 'generated');
+    var original = util.getArg(aArgs, 'original', null);
+    var source = util.getArg(aArgs, 'source', null);
+    var name = util.getArg(aArgs, 'name', null);
+
+    if (!this._skipValidation) {
+      if (this._validateMapping(generated, original, source, name) === false) {
+        return;
+      }
+    }
+
+    if (source != null) {
+      source = String(source);
+      if (!this._sources.has(source)) {
+        this._sources.add(source);
+      }
+    }
+
+    if (name != null) {
+      name = String(name);
+      if (!this._names.has(name)) {
+        this._names.add(name);
+      }
+    }
+
+    this._mappings.add({
+      generatedLine: generated.line,
+      generatedColumn: generated.column,
+      originalLine: original != null && original.line,
+      originalColumn: original != null && original.column,
+      source: source,
+      name: name
+    });
+  };
+
+/**
+ * Set the source content for a source file.
+ */
+SourceMapGenerator.prototype.setSourceContent =
+  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+    var source = aSourceFile;
+    if (this._sourceRoot != null) {
+      source = util.relative(this._sourceRoot, source);
+    }
+
+    if (aSourceContent != null) {
+      // Add the source content to the _sourcesContents map.
+      // Create a new _sourcesContents map if the property is null.
+      if (!this._sourcesContents) {
+        this._sourcesContents = Object.create(null);
+      }
+      this._sourcesContents[util.toSetString(source)] = aSourceContent;
+    } else if (this._sourcesContents) {
+      // Remove the source file from the _sourcesContents map.
+      // If the _sourcesContents map is empty, set the property to null.
+      delete this._sourcesContents[util.toSetString(source)];
+      if (Object.keys(this._sourcesContents).length === 0) {
+        this._sourcesContents = null;
+      }
+    }
+  };
+
+/**
+ * Applies the mappings of a sub-source-map for a specific source file to the
+ * source map being generated. Each mapping to the supplied source file is
+ * rewritten using the supplied source map. Note: The resolution for the
+ * resulting mappings is the minimium of this map and the supplied map.
+ *
+ * @param aSourceMapConsumer The source map to be applied.
+ * @param aSourceFile Optional. The filename of the source file.
+ *        If omitted, SourceMapConsumer's file property will be used.
+ * @param aSourceMapPath Optional. The dirname of the path to the source map
+ *        to be applied. If relative, it is relative to the SourceMapConsumer.
+ *        This parameter is needed when the two source maps aren't in the same
+ *        directory, and the source map to be applied contains relative source
+ *        paths. If so, those relative source paths need to be rewritten
+ *        relative to the SourceMapGenerator.
+ */
+SourceMapGenerator.prototype.applySourceMap =
+  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+    var sourceFile = aSourceFile;
+    // If aSourceFile is omitted, we will use the file property of the SourceMap
+    if (aSourceFile == null) {
+      if (aSourceMapConsumer.file == null) {
+        throw new Error(
+          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
+          'or the source map\'s "file" property. Both were omitted.'
+        );
+      }
+      sourceFile = aSourceMapConsumer.file;
+    }
+    var sourceRoot = this._sourceRoot;
+    // Make "sourceFile" relative if an absolute Url is passed.
+    if (sourceRoot != null) {
+      sourceFile = util.relative(sourceRoot, sourceFile);
+    }
+    // Applying the SourceMap can add and remove items from the sources and
+    // the names array.
+    var newSources = new ArraySet();
+    var newNames = new ArraySet();
+
+    // Find mappings for the "sourceFile"
+    this._mappings.unsortedForEach(function (mapping) {
+      if (mapping.source === sourceFile && mapping.originalLine != null) {
+        // Check if it can be mapped by the source map, then update the mapping.
+        var original = aSourceMapConsumer.originalPositionFor({
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        });
+        if (original.source != null) {
+          // Copy mapping
+          mapping.source = original.source;
+          if (aSourceMapPath != null) {
+            mapping.source = util.join(aSourceMapPath, mapping.source)
+          }
+          if (sourceRoot != null) {
+            mapping.source = util.relative(sourceRoot, mapping.source);
+          }
+          mapping.originalLine = original.line;
+          mapping.originalColumn = original.column;
+          if (original.name != null) {
+            mapping.name = original.name;
+          }
+        }
+      }
+
+      var source = mapping.source;
+      if (source != null && !newSources.has(source)) {
+        newSources.add(source);
+      }
+
+      var name = mapping.name;
+      if (name != null && !newNames.has(name)) {
+        newNames.add(name);
+      }
+
+    }, this);
+    this._sources = newSources;
+    this._names = newNames;
+
+    // Copy sourcesContents of applied map.
+    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        if (aSourceMapPath != null) {
+          sourceFile = util.join(aSourceMapPath, sourceFile);
+        }
+        if (sourceRoot != null) {
+          sourceFile = util.relative(sourceRoot, sourceFile);
+        }
+        this.setSourceContent(sourceFile, content);
+      }
+    }, this);
+  };
+
+/**
+ * A mapping can have one of the three levels of data:
+ *
+ *   1. Just the generated position.
+ *   2. The Generated position, original position, and original source.
+ *   3. Generated and original position, original source, as well as a name
+ *      token.
+ *
+ * To maintain consistency, we validate that any new mapping being added falls
+ * in to one of these categories.
+ */
+SourceMapGenerator.prototype._validateMapping =
+  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
+                                              aName) {
+    // When aOriginal is truthy but has empty values for .line and .column,
+    // it is most likely a programmer error. In this case we throw a very
+    // specific error message to try to guide them the right way.
+    // For example: https://github.com/Polymer/polymer-bundler/pull/519
+    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+      var message = 'original.line and original.column are not numbers -- you probably meant to omit ' +
+      'the original mapping entirely and only map the generated position. If so, pass ' +
+      'null for the original mapping instead of an object with empty or null values.'
+
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== 'undefined' && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message);
+      }
+    }
+
+    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+        && aGenerated.line > 0 && aGenerated.column >= 0
+        && !aOriginal && !aSource && !aName) {
+      // Case 1.
+      return;
+    }
+    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+             && aOriginal && 'line' in aOriginal && 'column' in aOriginal
+             && aGenerated.line > 0 && aGenerated.column >= 0
+             && aOriginal.line > 0 && aOriginal.column >= 0
+             && aSource) {
+      // Cases 2 and 3.
+      return;
+    }
+    else {
+      var message = 'Invalid mapping: ' + JSON.stringify({
+        generated: aGenerated,
+        source: aSource,
+        original: aOriginal,
+        name: aName
+      });
+
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== 'undefined' && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message)
+      }
+    }
+  };
+
+/**
+ * Serialize the accumulated mappings in to the stream of base 64 VLQs
+ * specified by the source map format.
+ */
+SourceMapGenerator.prototype._serializeMappings =
+  function SourceMapGenerator_serializeMappings() {
+    var previousGeneratedColumn = 0;
+    var previousGeneratedLine = 1;
+    var previousOriginalColumn = 0;
+    var previousOriginalLine = 0;
+    var previousName = 0;
+    var previousSource = 0;
+    var result = '';
+    var next;
+    var mapping;
+    var nameIdx;
+    var sourceIdx;
+
+    var mappings = this._mappings.toArray();
+    for (var i = 0, len = mappings.length; i < len; i++) {
+      mapping = mappings[i];
+      next = ''
+
+      if (mapping.generatedLine !== previousGeneratedLine) {
+        previousGeneratedColumn = 0;
+        while (mapping.generatedLine !== previousGeneratedLine) {
+          next += ';';
+          previousGeneratedLine++;
+        }
+      }
+      else {
+        if (i > 0) {
+          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+            continue;
+          }
+          next += ',';
+        }
+      }
+
+      next += base64VLQ.encode(mapping.generatedColumn
+                                 - previousGeneratedColumn);
+      previousGeneratedColumn = mapping.generatedColumn;
+
+      if (mapping.source != null) {
+        sourceIdx = this._sources.indexOf(mapping.source);
+        next += base64VLQ.encode(sourceIdx - previousSource);
+        previousSource = sourceIdx;
+
+        // lines are stored 0-based in SourceMap spec version 3
+        next += base64VLQ.encode(mapping.originalLine - 1
+                                   - previousOriginalLine);
+        previousOriginalLine = mapping.originalLine - 1;
+
+        next += base64VLQ.encode(mapping.originalColumn
+                                   - previousOriginalColumn);
+        previousOriginalColumn = mapping.originalColumn;
+
+        if (mapping.name != null) {
+          nameIdx = this._names.indexOf(mapping.name);
+          next += base64VLQ.encode(nameIdx - previousName);
+          previousName = nameIdx;
+        }
+      }
+
+      result += next;
+    }
+
+    return result;
+  };
+
+SourceMapGenerator.prototype._generateSourcesContent =
+  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
+    return aSources.map(function (source) {
+      if (!this._sourcesContents) {
+        return null;
+      }
+      if (aSourceRoot != null) {
+        source = util.relative(aSourceRoot, source);
+      }
+      var key = util.toSetString(source);
+      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
+        ? this._sourcesContents[key]
+        : null;
+    }, this);
+  };
+
+/**
+ * Externalize the source map.
+ */
+SourceMapGenerator.prototype.toJSON =
+  function SourceMapGenerator_toJSON() {
+    var map = {
+      version: this._version,
+      sources: this._sources.toArray(),
+      names: this._names.toArray(),
+      mappings: this._serializeMappings()
+    };
+    if (this._file != null) {
+      map.file = this._file;
+    }
+    if (this._sourceRoot != null) {
+      map.sourceRoot = this._sourceRoot;
+    }
+    if (this._sourcesContents) {
+      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+    }
+
+    return map;
+  };
+
+/**
+ * Render the source map being generated to a string.
+ */
+SourceMapGenerator.prototype.toString =
+  function SourceMapGenerator_toString() {
+    return JSON.stringify(this.toJSON());
+  };
+
+exports.SourceMapGenerator = SourceMapGenerator;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-node.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-node.d.ts
new file mode 100644
index 0000000..4df6a1a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-node.d.ts
@@ -0,0 +1 @@
+export { SourceNode } from '..';
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-node.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-node.js
new file mode 100644
index 0000000..8bcdbe3
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/source-node.js
@@ -0,0 +1,413 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
+var util = require('./util');
+
+// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
+// operating systems these days (capturing the result).
+var REGEX_NEWLINE = /(\r?\n)/;
+
+// Newline character code for charCodeAt() comparisons
+var NEWLINE_CODE = 10;
+
+// Private symbol for identifying `SourceNode`s when multiple versions of
+// the source-map library are loaded. This MUST NOT CHANGE across
+// versions!
+var isSourceNode = "$$$isSourceNode$$$";
+
+/**
+ * SourceNodes provide a way to abstract over interpolating/concatenating
+ * snippets of generated JavaScript source code while maintaining the line and
+ * column information associated with the original source code.
+ *
+ * @param aLine The original line number.
+ * @param aColumn The original column number.
+ * @param aSource The original source's filename.
+ * @param aChunks Optional. An array of strings which are snippets of
+ *        generated JS, or other SourceNodes.
+ * @param aName The original identifier.
+ */
+function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+  this.children = [];
+  this.sourceContents = {};
+  this.line = aLine == null ? null : aLine;
+  this.column = aColumn == null ? null : aColumn;
+  this.source = aSource == null ? null : aSource;
+  this.name = aName == null ? null : aName;
+  this[isSourceNode] = true;
+  if (aChunks != null) this.add(aChunks);
+}
+
+/**
+ * Creates a SourceNode from generated code and a SourceMapConsumer.
+ *
+ * @param aGeneratedCode The generated code
+ * @param aSourceMapConsumer The SourceMap for the generated code
+ * @param aRelativePath Optional. The path that relative sources in the
+ *        SourceMapConsumer should be relative to.
+ */
+SourceNode.fromStringWithSourceMap =
+  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
+    // The SourceNode we want to fill with the generated code
+    // and the SourceMap
+    var node = new SourceNode();
+
+    // All even indices of this array are one line of the generated code,
+    // while all odd indices are the newlines between two adjacent lines
+    // (since `REGEX_NEWLINE` captures its match).
+    // Processed fragments are accessed by calling `shiftNextLine`.
+    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+    var remainingLinesIndex = 0;
+    var shiftNextLine = function() {
+      var lineContents = getNextLine();
+      // The last line of a file might not have a newline.
+      var newLine = getNextLine() || "";
+      return lineContents + newLine;
+
+      function getNextLine() {
+        return remainingLinesIndex < remainingLines.length ?
+            remainingLines[remainingLinesIndex++] : undefined;
+      }
+    };
+
+    // We need to remember the position of "remainingLines"
+    var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+
+    // The generate SourceNodes we need a code range.
+    // To extract it current and last mapping is used.
+    // Here we store the last mapping.
+    var lastMapping = null;
+
+    aSourceMapConsumer.eachMapping(function (mapping) {
+      if (lastMapping !== null) {
+        // We add the code from "lastMapping" to "mapping":
+        // First check if there is a new line in between.
+        if (lastGeneratedLine < mapping.generatedLine) {
+          // Associate first line with "lastMapping"
+          addMappingWithCode(lastMapping, shiftNextLine());
+          lastGeneratedLine++;
+          lastGeneratedColumn = 0;
+          // The remaining code is added without mapping
+        } else {
+          // There is no new line in between.
+          // Associate the code between "lastGeneratedColumn" and
+          // "mapping.generatedColumn" with "lastMapping"
+          var nextLine = remainingLines[remainingLinesIndex] || '';
+          var code = nextLine.substr(0, mapping.generatedColumn -
+                                        lastGeneratedColumn);
+          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
+                                              lastGeneratedColumn);
+          lastGeneratedColumn = mapping.generatedColumn;
+          addMappingWithCode(lastMapping, code);
+          // No more remaining code, continue
+          lastMapping = mapping;
+          return;
+        }
+      }
+      // We add the generated code until the first mapping
+      // to the SourceNode without any mapping.
+      // Each line is added as separate string.
+      while (lastGeneratedLine < mapping.generatedLine) {
+        node.add(shiftNextLine());
+        lastGeneratedLine++;
+      }
+      if (lastGeneratedColumn < mapping.generatedColumn) {
+        var nextLine = remainingLines[remainingLinesIndex] || '';
+        node.add(nextLine.substr(0, mapping.generatedColumn));
+        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+        lastGeneratedColumn = mapping.generatedColumn;
+      }
+      lastMapping = mapping;
+    }, this);
+    // We have processed all mappings.
+    if (remainingLinesIndex < remainingLines.length) {
+      if (lastMapping) {
+        // Associate the remaining code in the current line with "lastMapping"
+        addMappingWithCode(lastMapping, shiftNextLine());
+      }
+      // and add the remaining lines without any mapping
+      node.add(remainingLines.splice(remainingLinesIndex).join(""));
+    }
+
+    // Copy sourcesContent into SourceNode
+    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        if (aRelativePath != null) {
+          sourceFile = util.join(aRelativePath, sourceFile);
+        }
+        node.setSourceContent(sourceFile, content);
+      }
+    });
+
+    return node;
+
+    function addMappingWithCode(mapping, code) {
+      if (mapping === null || mapping.source === undefined) {
+        node.add(code);
+      } else {
+        var source = aRelativePath
+          ? util.join(aRelativePath, mapping.source)
+          : mapping.source;
+        node.add(new SourceNode(mapping.originalLine,
+                                mapping.originalColumn,
+                                source,
+                                code,
+                                mapping.name));
+      }
+    }
+  };
+
+/**
+ * Add a chunk of generated JS to this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ *        SourceNode, or an array where each member is one of those things.
+ */
+SourceNode.prototype.add = function SourceNode_add(aChunk) {
+  if (Array.isArray(aChunk)) {
+    aChunk.forEach(function (chunk) {
+      this.add(chunk);
+    }, this);
+  }
+  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+    if (aChunk) {
+      this.children.push(aChunk);
+    }
+  }
+  else {
+    throw new TypeError(
+      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+    );
+  }
+  return this;
+};
+
+/**
+ * Add a chunk of generated JS to the beginning of this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ *        SourceNode, or an array where each member is one of those things.
+ */
+SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+  if (Array.isArray(aChunk)) {
+    for (var i = aChunk.length-1; i >= 0; i--) {
+      this.prepend(aChunk[i]);
+    }
+  }
+  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+    this.children.unshift(aChunk);
+  }
+  else {
+    throw new TypeError(
+      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+    );
+  }
+  return this;
+};
+
+/**
+ * Walk over the tree of JS snippets in this node and its children. The
+ * walking function is called once for each snippet of JS and is passed that
+ * snippet and the its original associated source's line/column location.
+ *
+ * @param aFn The traversal function.
+ */
+SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+  var chunk;
+  for (var i = 0, len = this.children.length; i < len; i++) {
+    chunk = this.children[i];
+    if (chunk[isSourceNode]) {
+      chunk.walk(aFn);
+    }
+    else {
+      if (chunk !== '') {
+        aFn(chunk, { source: this.source,
+                     line: this.line,
+                     column: this.column,
+                     name: this.name });
+      }
+    }
+  }
+};
+
+/**
+ * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+ * each of `this.children`.
+ *
+ * @param aSep The separator.
+ */
+SourceNode.prototype.join = function SourceNode_join(aSep) {
+  var newChildren;
+  var i;
+  var len = this.children.length;
+  if (len > 0) {
+    newChildren = [];
+    for (i = 0; i < len-1; i++) {
+      newChildren.push(this.children[i]);
+      newChildren.push(aSep);
+    }
+    newChildren.push(this.children[i]);
+    this.children = newChildren;
+  }
+  return this;
+};
+
+/**
+ * Call String.prototype.replace on the very right-most source snippet. Useful
+ * for trimming whitespace from the end of a source node, etc.
+ *
+ * @param aPattern The pattern to replace.
+ * @param aReplacement The thing to replace the pattern with.
+ */
+SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+  var lastChild = this.children[this.children.length - 1];
+  if (lastChild[isSourceNode]) {
+    lastChild.replaceRight(aPattern, aReplacement);
+  }
+  else if (typeof lastChild === 'string') {
+    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+  }
+  else {
+    this.children.push(''.replace(aPattern, aReplacement));
+  }
+  return this;
+};
+
+/**
+ * Set the source content for a source file. This will be added to the SourceMapGenerator
+ * in the sourcesContent field.
+ *
+ * @param aSourceFile The filename of the source file
+ * @param aSourceContent The content of the source file
+ */
+SourceNode.prototype.setSourceContent =
+  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+  };
+
+/**
+ * Walk over the tree of SourceNodes. The walking function is called for each
+ * source file content and is passed the filename and source content.
+ *
+ * @param aFn The traversal function.
+ */
+SourceNode.prototype.walkSourceContents =
+  function SourceNode_walkSourceContents(aFn) {
+    for (var i = 0, len = this.children.length; i < len; i++) {
+      if (this.children[i][isSourceNode]) {
+        this.children[i].walkSourceContents(aFn);
+      }
+    }
+
+    var sources = Object.keys(this.sourceContents);
+    for (var i = 0, len = sources.length; i < len; i++) {
+      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+    }
+  };
+
+/**
+ * Return the string representation of this source node. Walks over the tree
+ * and concatenates all the various snippets together to one string.
+ */
+SourceNode.prototype.toString = function SourceNode_toString() {
+  var str = "";
+  this.walk(function (chunk) {
+    str += chunk;
+  });
+  return str;
+};
+
+/**
+ * Returns the string representation of this source node along with a source
+ * map.
+ */
+SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+  var generated = {
+    code: "",
+    line: 1,
+    column: 0
+  };
+  var map = new SourceMapGenerator(aArgs);
+  var sourceMappingActive = false;
+  var lastOriginalSource = null;
+  var lastOriginalLine = null;
+  var lastOriginalColumn = null;
+  var lastOriginalName = null;
+  this.walk(function (chunk, original) {
+    generated.code += chunk;
+    if (original.source !== null
+        && original.line !== null
+        && original.column !== null) {
+      if(lastOriginalSource !== original.source
+         || lastOriginalLine !== original.line
+         || lastOriginalColumn !== original.column
+         || lastOriginalName !== original.name) {
+        map.addMapping({
+          source: original.source,
+          original: {
+            line: original.line,
+            column: original.column
+          },
+          generated: {
+            line: generated.line,
+            column: generated.column
+          },
+          name: original.name
+        });
+      }
+      lastOriginalSource = original.source;
+      lastOriginalLine = original.line;
+      lastOriginalColumn = original.column;
+      lastOriginalName = original.name;
+      sourceMappingActive = true;
+    } else if (sourceMappingActive) {
+      map.addMapping({
+        generated: {
+          line: generated.line,
+          column: generated.column
+        }
+      });
+      lastOriginalSource = null;
+      sourceMappingActive = false;
+    }
+    for (var idx = 0, length = chunk.length; idx < length; idx++) {
+      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+        generated.line++;
+        generated.column = 0;
+        // Mappings end at eol
+        if (idx + 1 === length) {
+          lastOriginalSource = null;
+          sourceMappingActive = false;
+        } else if (sourceMappingActive) {
+          map.addMapping({
+            source: original.source,
+            original: {
+              line: original.line,
+              column: original.column
+            },
+            generated: {
+              line: generated.line,
+              column: generated.column
+            },
+            name: original.name
+          });
+        }
+      } else {
+        generated.column++;
+      }
+    }
+  });
+  this.walkSourceContents(function (sourceFile, sourceContent) {
+    map.setSourceContent(sourceFile, sourceContent);
+  });
+
+  return { code: generated.code, map: map };
+};
+
+exports.SourceNode = SourceNode;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/util.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/util.js
new file mode 100644
index 0000000..430e2d0
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/lib/util.js
@@ -0,0 +1,594 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+/**
+ * This is a helper function for getting values from parameter/options
+ * objects.
+ *
+ * @param args The object we are extracting values from
+ * @param name The name of the property we are getting.
+ * @param defaultValue An optional value to return if the property is missing
+ * from the object. If this is not specified and the property is missing, an
+ * error will be thrown.
+ */
+function getArg(aArgs, aName, aDefaultValue) {
+  if (aName in aArgs) {
+    return aArgs[aName];
+  } else if (arguments.length === 3) {
+    return aDefaultValue;
+  } else {
+    throw new Error('"' + aName + '" is a required argument.');
+  }
+}
+exports.getArg = getArg;
+
+var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
+var dataUrlRegexp = /^data:.+\,.+$/;
+
+function urlParse(aUrl) {
+  var match = aUrl.match(urlRegexp);
+  if (!match) {
+    return null;
+  }
+  return {
+    scheme: match[1],
+    auth: match[2],
+    host: match[3],
+    port: match[4],
+    path: match[5]
+  };
+}
+exports.urlParse = urlParse;
+
+function urlGenerate(aParsedUrl) {
+  var url = '';
+  if (aParsedUrl.scheme) {
+    url += aParsedUrl.scheme + ':';
+  }
+  url += '//';
+  if (aParsedUrl.auth) {
+    url += aParsedUrl.auth + '@';
+  }
+  if (aParsedUrl.host) {
+    url += aParsedUrl.host;
+  }
+  if (aParsedUrl.port) {
+    url += ":" + aParsedUrl.port
+  }
+  if (aParsedUrl.path) {
+    url += aParsedUrl.path;
+  }
+  return url;
+}
+exports.urlGenerate = urlGenerate;
+
+var MAX_CACHED_INPUTS = 32;
+
+/**
+ * Takes some function `f(input) -> result` and returns a memoized version of
+ * `f`.
+ *
+ * We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
+ * memoization is a dumb-simple, linear least-recently-used cache.
+ */
+function lruMemoize(f) {
+  var cache = [];
+
+  return function(input) {
+    for (var i = 0; i < cache.length; i++) {
+      if (cache[i].input === input) {
+        var temp = cache[0];
+        cache[0] = cache[i];
+        cache[i] = temp;
+        return cache[0].result;
+      }
+    }
+
+    var result = f(input);
+
+    cache.unshift({
+      input,
+      result,
+    });
+
+    if (cache.length > MAX_CACHED_INPUTS) {
+      cache.pop();
+    }
+
+    return result;
+  };
+}
+
+/**
+ * Normalizes a path, or the path portion of a URL:
+ *
+ * - Replaces consecutive slashes with one slash.
+ * - Removes unnecessary '.' parts.
+ * - Removes unnecessary '<dir>/..' parts.
+ *
+ * Based on code in the Node.js 'path' core module.
+ *
+ * @param aPath The path or url to normalize.
+ */
+var normalize = lruMemoize(function normalize(aPath) {
+  var path = aPath;
+  var url = urlParse(aPath);
+  if (url) {
+    if (!url.path) {
+      return aPath;
+    }
+    path = url.path;
+  }
+  var isAbsolute = exports.isAbsolute(path);
+  // Split the path into parts between `/` characters. This is much faster than
+  // using `.split(/\/+/g)`.
+  var parts = [];
+  var start = 0;
+  var i = 0;
+  while (true) {
+    start = i;
+    i = path.indexOf("/", start);
+    if (i === -1) {
+      parts.push(path.slice(start));
+      break;
+    } else {
+      parts.push(path.slice(start, i));
+      while (i < path.length && path[i] === "/") {
+        i++;
+      }
+    }
+  }
+
+  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
+    part = parts[i];
+    if (part === '.') {
+      parts.splice(i, 1);
+    } else if (part === '..') {
+      up++;
+    } else if (up > 0) {
+      if (part === '') {
+        // The first part is blank if the path is absolute. Trying to go
+        // above the root is a no-op. Therefore we can remove all '..' parts
+        // directly after the root.
+        parts.splice(i + 1, up);
+        up = 0;
+      } else {
+        parts.splice(i, 2);
+        up--;
+      }
+    }
+  }
+  path = parts.join('/');
+
+  if (path === '') {
+    path = isAbsolute ? '/' : '.';
+  }
+
+  if (url) {
+    url.path = path;
+    return urlGenerate(url);
+  }
+  return path;
+});
+exports.normalize = normalize;
+
+/**
+ * Joins two paths/URLs.
+ *
+ * @param aRoot The root path or URL.
+ * @param aPath The path or URL to be joined with the root.
+ *
+ * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
+ *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
+ *   first.
+ * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
+ *   is updated with the result and aRoot is returned. Otherwise the result
+ *   is returned.
+ *   - If aPath is absolute, the result is aPath.
+ *   - Otherwise the two paths are joined with a slash.
+ * - Joining for example 'http://' and 'www.example.com' is also supported.
+ */
+function join(aRoot, aPath) {
+  if (aRoot === "") {
+    aRoot = ".";
+  }
+  if (aPath === "") {
+    aPath = ".";
+  }
+  var aPathUrl = urlParse(aPath);
+  var aRootUrl = urlParse(aRoot);
+  if (aRootUrl) {
+    aRoot = aRootUrl.path || '/';
+  }
+
+  // `join(foo, '//www.example.org')`
+  if (aPathUrl && !aPathUrl.scheme) {
+    if (aRootUrl) {
+      aPathUrl.scheme = aRootUrl.scheme;
+    }
+    return urlGenerate(aPathUrl);
+  }
+
+  if (aPathUrl || aPath.match(dataUrlRegexp)) {
+    return aPath;
+  }
+
+  // `join('http://', 'www.example.com')`
+  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+    aRootUrl.host = aPath;
+    return urlGenerate(aRootUrl);
+  }
+
+  var joined = aPath.charAt(0) === '/'
+    ? aPath
+    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
+
+  if (aRootUrl) {
+    aRootUrl.path = joined;
+    return urlGenerate(aRootUrl);
+  }
+  return joined;
+}
+exports.join = join;
+
+exports.isAbsolute = function (aPath) {
+  return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
+};
+
+/**
+ * Make a path relative to a URL or another path.
+ *
+ * @param aRoot The root path or URL.
+ * @param aPath The path or URL to be made relative to aRoot.
+ */
+function relative(aRoot, aPath) {
+  if (aRoot === "") {
+    aRoot = ".";
+  }
+
+  aRoot = aRoot.replace(/\/$/, '');
+
+  // It is possible for the path to be above the root. In this case, simply
+  // checking whether the root is a prefix of the path won't work. Instead, we
+  // need to remove components from the root one by one, until either we find
+  // a prefix that fits, or we run out of components to remove.
+  var level = 0;
+  while (aPath.indexOf(aRoot + '/') !== 0) {
+    var index = aRoot.lastIndexOf("/");
+    if (index < 0) {
+      return aPath;
+    }
+
+    // If the only part of the root that is left is the scheme (i.e. http://,
+    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
+    // have exhausted all components, so the path is not relative to the root.
+    aRoot = aRoot.slice(0, index);
+    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+      return aPath;
+    }
+
+    ++level;
+  }
+
+  // Make sure we add a "../" for each component we removed from the root.
+  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
+}
+exports.relative = relative;
+
+var supportsNullProto = (function () {
+  var obj = Object.create(null);
+  return !('__proto__' in obj);
+}());
+
+function identity (s) {
+  return s;
+}
+
+/**
+ * Because behavior goes wacky when you set `__proto__` on objects, we
+ * have to prefix all the strings in our set with an arbitrary character.
+ *
+ * See https://github.com/mozilla/source-map/pull/31 and
+ * https://github.com/mozilla/source-map/issues/30
+ *
+ * @param String aStr
+ */
+function toSetString(aStr) {
+  if (isProtoString(aStr)) {
+    return '$' + aStr;
+  }
+
+  return aStr;
+}
+exports.toSetString = supportsNullProto ? identity : toSetString;
+
+function fromSetString(aStr) {
+  if (isProtoString(aStr)) {
+    return aStr.slice(1);
+  }
+
+  return aStr;
+}
+exports.fromSetString = supportsNullProto ? identity : fromSetString;
+
+function isProtoString(s) {
+  if (!s) {
+    return false;
+  }
+
+  var length = s.length;
+
+  if (length < 9 /* "__proto__".length */) {
+    return false;
+  }
+
+  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
+      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
+      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
+      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
+      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
+      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
+      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
+      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
+      s.charCodeAt(length - 9) !== 95  /* '_' */) {
+    return false;
+  }
+
+  for (var i = length - 10; i >= 0; i--) {
+    if (s.charCodeAt(i) !== 36 /* '$' */) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Comparator between two mappings where the original positions are compared.
+ *
+ * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+ * mappings with the same original source/line/column, but different generated
+ * line and column the same. Useful when searching for a mapping with a
+ * stubbed out mapping.
+ */
+function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+  var cmp = strcmp(mappingA.source, mappingB.source);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0 || onlyCompareOriginal) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedLine - mappingB.generatedLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByOriginalPositions = compareByOriginalPositions;
+
+function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {
+  var cmp
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0 || onlyCompareOriginal) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedLine - mappingB.generatedLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;
+
+/**
+ * Comparator between two mappings with deflated source and name indices where
+ * the generated positions are compared.
+ *
+ * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+ * mappings with the same generated line and column, but different
+ * source/name/original line and column the same. Useful when searching for a
+ * mapping with a stubbed out mapping.
+ */
+function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
+  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0 || onlyCompareGenerated) {
+    return cmp;
+  }
+
+  cmp = strcmp(mappingA.source, mappingB.source);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
+
+function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {
+  var cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0 || onlyCompareGenerated) {
+    return cmp;
+  }
+
+  cmp = strcmp(mappingA.source, mappingB.source);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;
+
+function strcmp(aStr1, aStr2) {
+  if (aStr1 === aStr2) {
+    return 0;
+  }
+
+  if (aStr1 === null) {
+    return 1; // aStr2 !== null
+  }
+
+  if (aStr2 === null) {
+    return -1; // aStr1 !== null
+  }
+
+  if (aStr1 > aStr2) {
+    return 1;
+  }
+
+  return -1;
+}
+
+/**
+ * Comparator between two mappings with inflated source and name strings where
+ * the generated positions are compared.
+ */
+function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = strcmp(mappingA.source, mappingB.source);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+
+/**
+ * Strip any JSON XSSI avoidance prefix from the string (as documented
+ * in the source maps specification), and then parse the string as
+ * JSON.
+ */
+function parseSourceMapInput(str) {
+  return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
+}
+exports.parseSourceMapInput = parseSourceMapInput;
+
+/**
+ * Compute the URL of a source given the the source root, the source's
+ * URL, and the source map's URL.
+ */
+function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+  sourceURL = sourceURL || '';
+
+  if (sourceRoot) {
+    // This follows what Chrome does.
+    if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
+      sourceRoot += '/';
+    }
+    // The spec says:
+    //   Line 4: An optional source root, useful for relocating source
+    //   files on a server or removing repeated values in the
+    //   “sources” entry.  This value is prepended to the individual
+    //   entries in the “source” field.
+    sourceURL = sourceRoot + sourceURL;
+  }
+
+  // Historically, SourceMapConsumer did not take the sourceMapURL as
+  // a parameter.  This mode is still somewhat supported, which is why
+  // this code block is conditional.  However, it's preferable to pass
+  // the source map URL to SourceMapConsumer, so that this function
+  // can implement the source URL resolution algorithm as outlined in
+  // the spec.  This block is basically the equivalent of:
+  //    new URL(sourceURL, sourceMapURL).toString()
+  // ... except it avoids using URL, which wasn't available in the
+  // older releases of node still supported by this library.
+  //
+  // The spec says:
+  //   If the sources are not absolute URLs after prepending of the
+  //   “sourceRoot”, the sources are resolved relative to the
+  //   SourceMap (like resolving script src in a html document).
+  if (sourceMapURL) {
+    var parsed = urlParse(sourceMapURL);
+    if (!parsed) {
+      throw new Error("sourceMapURL could not be parsed");
+    }
+    if (parsed.path) {
+      // Strip the last path component, but keep the "/".
+      var index = parsed.path.lastIndexOf('/');
+      if (index >= 0) {
+        parsed.path = parsed.path.substring(0, index + 1);
+      }
+    }
+    sourceURL = join(urlGenerate(parsed), sourceURL);
+  }
+
+  return normalize(sourceURL);
+}
+exports.computeSourceURL = computeSourceURL;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/package.json
new file mode 100644
index 0000000..f58dbeb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/package.json
@@ -0,0 +1,71 @@
+{
+  "name": "source-map-js",
+  "description": "Generates and consumes source maps",
+  "version": "1.2.1",
+  "homepage": "https://github.com/7rulnik/source-map-js",
+  "author": "Valentin 7rulnik Semirulnik <v7rulnik@gmail.com>",
+  "contributors": [
+    "Nick Fitzgerald <nfitzgerald@mozilla.com>",
+    "Tobias Koppers <tobias.koppers@googlemail.com>",
+    "Duncan Beevers <duncan@dweebd.com>",
+    "Stephen Crane <scrane@mozilla.com>",
+    "Ryan Seddon <seddon.ryan@gmail.com>",
+    "Miles Elam <miles.elam@deem.com>",
+    "Mihai Bazon <mihai.bazon@gmail.com>",
+    "Michael Ficarra <github.public.email@michael.ficarra.me>",
+    "Todd Wolfson <todd@twolfson.com>",
+    "Alexander Solovyov <alexander@solovyov.net>",
+    "Felix Gnass <fgnass@gmail.com>",
+    "Conrad Irwin <conrad.irwin@gmail.com>",
+    "usrbincc <usrbincc@yahoo.com>",
+    "David Glasser <glasser@davidglasser.net>",
+    "Chase Douglas <chase@newrelic.com>",
+    "Evan Wallace <evan.exe@gmail.com>",
+    "Heather Arthur <fayearthur@gmail.com>",
+    "Hugh Kennedy <hughskennedy@gmail.com>",
+    "David Glasser <glasser@davidglasser.net>",
+    "Simon Lydell <simon.lydell@gmail.com>",
+    "Jmeas Smith <jellyes2@gmail.com>",
+    "Michael Z Goddard <mzgoddard@gmail.com>",
+    "azu <azu@users.noreply.github.com>",
+    "John Gozde <john@gozde.ca>",
+    "Adam Kirkton <akirkton@truefitinnovation.com>",
+    "Chris Montgomery <christopher.montgomery@dowjones.com>",
+    "J. Ryan Stinnett <jryans@gmail.com>",
+    "Jack Herrington <jherrington@walmartlabs.com>",
+    "Chris Truter <jeffpalentine@gmail.com>",
+    "Daniel Espeset <daniel@danielespeset.com>",
+    "Jamie Wong <jamie.lf.wong@gmail.com>",
+    "Eddy Bruël <ejpbruel@mozilla.com>",
+    "Hawken Rives <hawkrives@gmail.com>",
+    "Gilad Peleg <giladp007@gmail.com>",
+    "djchie <djchie.dev@gmail.com>",
+    "Gary Ye <garysye@gmail.com>",
+    "Nicolas Lalevée <nicolas.lalevee@hibnet.org>"
+  ],
+  "repository": "7rulnik/source-map-js",
+  "main": "./source-map.js",
+  "files": [
+    "source-map.js",
+    "source-map.d.ts",
+    "lib/"
+  ],
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "license": "BSD-3-Clause",
+  "scripts": {
+    "test": "npm run build && node test/run-tests.js",
+    "build": "webpack --color",
+    "toc": "doctoc --title '## Table of Contents' README.md && doctoc --title '## Table of Contents' CONTRIBUTING.md"
+  },
+  "devDependencies": {
+    "clean-publish": "^3.1.0",
+    "doctoc": "^0.15.0",
+    "webpack": "^1.12.0"
+  },
+  "clean-publish": {
+    "cleanDocs": true
+  },
+  "typings": "source-map.d.ts"
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/source-map.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/source-map.d.ts
new file mode 100644
index 0000000..ec8892f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/source-map.d.ts
@@ -0,0 +1,104 @@
+export interface StartOfSourceMap {
+    file?: string;
+    sourceRoot?: string;
+}
+
+export interface RawSourceMap extends StartOfSourceMap {
+    version: string;
+    sources: string[];
+    names: string[];
+    sourcesContent?: string[];
+    mappings: string;
+}
+
+export interface Position {
+    line: number;
+    column: number;
+}
+
+export interface LineRange extends Position {
+    lastColumn: number;
+}
+
+export interface FindPosition extends Position {
+    // SourceMapConsumer.GREATEST_LOWER_BOUND or SourceMapConsumer.LEAST_UPPER_BOUND
+    bias?: number;
+}
+
+export interface SourceFindPosition extends FindPosition {
+    source: string;
+}
+
+export interface MappedPosition extends Position {
+    source: string;
+    name?: string;
+}
+
+export interface MappingItem {
+    source: string | null;
+    generatedLine: number;
+    generatedColumn: number;
+    originalLine: number | null;
+    originalColumn: number | null;
+    name: string | null;
+}
+
+export class SourceMapConsumer {
+    static GENERATED_ORDER: number;
+    static ORIGINAL_ORDER: number;
+
+    static GREATEST_LOWER_BOUND: number;
+    static LEAST_UPPER_BOUND: number;
+
+    constructor(rawSourceMap: RawSourceMap);
+    readonly file: string | undefined | null;
+    readonly sourceRoot: string | undefined | null;
+    readonly sourcesContent: readonly string[] | null | undefined;
+    readonly sources: readonly string[]
+
+    computeColumnSpans(): void;
+    originalPositionFor(generatedPosition: FindPosition): MappedPosition;
+    generatedPositionFor(originalPosition: SourceFindPosition): LineRange;
+    allGeneratedPositionsFor(originalPosition: MappedPosition): Position[];
+    hasContentsOfAllSources(): boolean;
+    sourceContentFor(source: string, returnNullOnMissing?: boolean): string | null;
+    eachMapping(callback: (mapping: MappingItem) => void, context?: any, order?: number): void;
+}
+
+export interface Mapping {
+    generated: Position;
+    original?: Position | null;
+    source?: string | null;
+    name?: string | null;
+}
+
+export class SourceMapGenerator {
+    constructor(startOfSourceMap?: StartOfSourceMap);
+    static fromSourceMap(sourceMapConsumer: SourceMapConsumer, startOfSourceMap?: StartOfSourceMap): SourceMapGenerator;
+    addMapping(mapping: Mapping): void;
+    setSourceContent(sourceFile: string, sourceContent: string | null | undefined): void;
+    applySourceMap(sourceMapConsumer: SourceMapConsumer, sourceFile?: string, sourceMapPath?: string): void;
+    toString(): string;
+    toJSON(): RawSourceMap;
+}
+
+export interface CodeWithSourceMap {
+    code: string;
+    map: SourceMapGenerator;
+}
+
+export class SourceNode {
+    constructor();
+    constructor(line: number, column: number, source: string);
+    constructor(line: number, column: number, source: string, chunk?: string, name?: string);
+    static fromStringWithSourceMap(code: string, sourceMapConsumer: SourceMapConsumer, relativePath?: string): SourceNode;
+    add(chunk: string): void;
+    prepend(chunk: string): void;
+    setSourceContent(sourceFile: string, sourceContent: string): void;
+    walk(fn: (chunk: string, mapping: MappedPosition) => void): void;
+    walkSourceContents(fn: (file: string, content: string) => void): void;
+    join(sep: string): SourceNode;
+    replaceRight(pattern: string, replacement: string): SourceNode;
+    toString(): string;
+    toStringWithSourceMap(startOfSourceMap?: StartOfSourceMap): CodeWithSourceMap;
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/source-map.js b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/source-map.js
new file mode 100644
index 0000000..bc88fe8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/source-map-js/source-map.js
@@ -0,0 +1,8 @@
+/*
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+exports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;
+exports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;
+exports.SourceNode = require('./lib/source-node').SourceNode;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/LICENSE b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/LICENSE
new file mode 100644
index 0000000..8657364
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Madeline Gurriarán
+
+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.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/README.md
new file mode 100644
index 0000000..f10b459
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/README.md
@@ -0,0 +1,25 @@
+# tinyglobby
+
+[![npm version](https://img.shields.io/npm/v/tinyglobby.svg?maxAge=3600)](https://npmjs.com/package/tinyglobby)
+[![monthly downloads](https://img.shields.io/npm/dm/tinyglobby.svg?maxAge=3600)](https://npmjs.com/package/tinyglobby)
+
+A fast and minimal alternative to globby and fast-glob, meant to behave the same way.
+
+Both globby and fast-glob present some behavior no other globbing lib has,
+which makes it hard to manually replace with something smaller and better.
+
+This library uses only two subdependencies, compared to `globby`'s [23](https://npmgraph.js.org/?q=globby@16.2.0)
+and `fast-glob`'s [17](https://npmgraph.js.org/?q=fast-glob@3.3.3).
+
+## Usage
+
+```js
+import { glob, globSync } from 'tinyglobby';
+
+await glob(['files/*.ts', '!**/*.d.ts'], { cwd: 'src' });
+globSync('src/**/*.ts', { ignore: '**/*.d.ts' });
+```
+
+## Documentation
+
+Visit https://superchupu.dev/tinyglobby to read the full documentation.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.cjs b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.cjs
new file mode 100644
index 0000000..5badacb
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.cjs
@@ -0,0 +1,334 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let fs = require("fs");
+let path = require("path");
+let url = require("url");
+let fdir = require("fdir");
+let picomatch = require("picomatch");
+picomatch = __toESM(picomatch);
+//#region src/utils.ts
+const isReadonlyArray = Array.isArray;
+const BACKSLASHES = /\\/g;
+const isWin = process.platform === "win32";
+const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options = {}) {
+	const patternsCount = patterns.length;
+	const patternsParts = Array(patternsCount);
+	const matchers = Array(patternsCount);
+	let i, j;
+	for (i = 0; i < patternsCount; i++) {
+		const parts = splitPattern(patterns[i]);
+		patternsParts[i] = parts;
+		const partsCount = parts.length;
+		const partMatchers = Array(partsCount);
+		for (j = 0; j < partsCount; j++) partMatchers[j] = (0, picomatch.default)(parts[j], options);
+		matchers[i] = partMatchers;
+	}
+	return (input) => {
+		const inputParts = input.split("/");
+		if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+		for (i = 0; i < patternsCount; i++) {
+			const patternParts = patternsParts[i];
+			const matcher = matchers[i];
+			const inputPatternCount = inputParts.length;
+			const minParts = Math.min(inputPatternCount, patternParts.length);
+			j = 0;
+			while (j < minParts) {
+				const part = patternParts[j];
+				if (part.includes("/")) return true;
+				if (!matcher[j](inputParts[j])) break;
+				if (!options.noglobstar && part === "**") return true;
+				j++;
+			}
+			if (j === inputPatternCount) return true;
+		}
+		return false;
+	};
+}
+/* node:coverage ignore next 2 */
+const WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
+const isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
+function buildFormat(cwd, root, absolute) {
+	if (cwd === root || root.startsWith(`${cwd}/`)) {
+		if (absolute) {
+			const start = cwd.length + +!isRoot(cwd);
+			return (p, isDir) => p.slice(start, isDir ? -1 : void 0) || ".";
+		}
+		const prefix = root.slice(cwd.length + 1);
+		if (prefix) return (p, isDir) => {
+			if (p === ".") return prefix;
+			const result = `${prefix}/${p}`;
+			return isDir ? result.slice(0, -1) : result;
+		};
+		return (p, isDir) => isDir && p !== "." ? p.slice(0, -1) : p;
+	}
+	if (absolute) return (p) => path.posix.relative(cwd, p) || ".";
+	return (p) => path.posix.relative(cwd, `${root}/${p}`) || ".";
+}
+function buildRelative(cwd, root) {
+	if (root.startsWith(`${cwd}/`)) {
+		const prefix = root.slice(cwd.length + 1);
+		return (p) => `${prefix}/${p}`;
+	}
+	return (p) => {
+		const result = path.posix.relative(cwd, `${root}/${p}`);
+		return p[p.length - 1] === "/" && result !== "" ? `${result}/` : result || ".";
+	};
+}
+const splitPatternOptions = { parts: true };
+function splitPattern(path$1) {
+	var _result$parts;
+	const result = picomatch.default.scan(path$1, splitPatternOptions);
+	return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path$1];
+}
+const ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
+function convertPosixPathToPattern(path$2) {
+	return escapePosixPath(path$2);
+}
+function convertWin32PathToPattern(path$3) {
+	return escapeWin32Path(path$3).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+}
+/**
+* Converts a path to a pattern depending on the platform.
+* Identical to {@link escapePath} on POSIX systems.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#convertPathToPattern}
+*/
+/* node:coverage ignore next 3 */
+const convertPathToPattern = isWin ? convertWin32PathToPattern : convertPosixPathToPattern;
+const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+const escapePosixPath = (path$4) => path$4.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path$5) => path$5.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+/**
+* Escapes a path's special characters depending on the platform.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#escapePath}
+*/
+/* node:coverage ignore next */
+const escapePath = isWin ? escapeWin32Path : escapePosixPath;
+/**
+* Checks if a pattern has dynamic parts.
+*
+* Has a few minor differences with [`fast-glob`](https://github.com/mrmlnc/fast-glob) for better accuracy:
+*
+* - Doesn't necessarily return `false` on patterns that include `\`.
+* - Returns `true` if the pattern includes parentheses, regardless of them representing one single pattern or not.
+* - Returns `true` for unfinished glob extensions i.e. `(h`, `+(h`.
+* - Returns `true` for unfinished brace expansions as long as they include `,` or `..`.
+*
+* @see {@link https://superchupu.dev/tinyglobby/documentation#isDynamicPattern}
+*/
+function isDynamicPattern(pattern, options) {
+	if ((options === null || options === void 0 ? void 0 : options.caseSensitiveMatch) === false) return true;
+	const scan = picomatch.default.scan(pattern);
+	return scan.isGlob || scan.negated;
+}
+function log(...tasks) {
+	console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...tasks);
+}
+function ensureStringArray(value) {
+	return typeof value === "string" ? [value] : value !== null && value !== void 0 ? value : [];
+}
+//#endregion
+//#region src/patterns.ts
+const PARENT_DIRECTORY = /^(\/?\.\.)+/;
+const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+function normalizePattern(pattern, opts, props, isIgnore) {
+	var _PARENT_DIRECTORY$exe;
+	const cwd = opts.cwd;
+	let result = pattern;
+	if (pattern[pattern.length - 1] === "/") result = pattern.slice(0, -1);
+	if (result[result.length - 1] !== "*" && opts.expandDirectories) result += "/**";
+	const escapedCwd = escapePath(cwd);
+	result = (0, path.isAbsolute)(result.replace(ESCAPING_BACKSLASHES, "")) ? path.posix.relative(escapedCwd, result) : path.posix.normalize(result);
+	const parentDir = (_PARENT_DIRECTORY$exe = PARENT_DIRECTORY.exec(result)) === null || _PARENT_DIRECTORY$exe === void 0 ? void 0 : _PARENT_DIRECTORY$exe[0];
+	const parts = splitPattern(result);
+	if (parentDir) {
+		const n = (parentDir.length + 1) / 3;
+		let i = 0;
+		const cwdParts = escapedCwd.split("/");
+		while (i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]) {
+			result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
+			i++;
+		}
+		const potentialRoot = path.posix.join(cwd, parentDir.slice(i * 3));
+		if (potentialRoot[0] !== "." && props.root.length > potentialRoot.length) {
+			props.root = potentialRoot;
+			props.depthOffset = -n + i;
+		}
+	}
+	if (!isIgnore && props.depthOffset >= 0) {
+		var _props$commonPath;
+		(_props$commonPath = props.commonPath) !== null && _props$commonPath !== void 0 || (props.commonPath = parts);
+		const newCommonPath = [];
+		const length = Math.min(props.commonPath.length, parts.length);
+		for (let i = 0; i < length; i++) {
+			const part = parts[i];
+			if (part === "**" && !parts[i + 1]) {
+				newCommonPath.pop();
+				break;
+			}
+			if (i === parts.length - 1 || part !== props.commonPath[i] || isDynamicPattern(part)) break;
+			newCommonPath.push(part);
+		}
+		props.depthOffset = newCommonPath.length;
+		props.commonPath = newCommonPath;
+		props.root = newCommonPath.length > 0 ? path.posix.join(cwd, ...newCommonPath) : cwd;
+	}
+	return result;
+}
+function processPatterns(options, patterns, props) {
+	const matchPatterns = [];
+	const ignorePatterns = [];
+	for (const pattern of options.ignore) {
+		if (!pattern) continue;
+		if (pattern[0] !== "!" || pattern[1] === "(") ignorePatterns.push(normalizePattern(pattern, options, props, true));
+	}
+	for (const pattern of patterns) {
+		if (!pattern) continue;
+		if (pattern[0] !== "!" || pattern[1] === "(") matchPatterns.push(normalizePattern(pattern, options, props, false));
+		else if (pattern[1] !== "!" || pattern[2] === "(") ignorePatterns.push(normalizePattern(pattern.slice(1), options, props, true));
+	}
+	return {
+		match: matchPatterns,
+		ignore: ignorePatterns
+	};
+}
+//#endregion
+//#region src/crawler.ts
+function buildCrawler(options, patterns) {
+	const cwd = options.cwd;
+	const props = {
+		root: cwd,
+		depthOffset: 0
+	};
+	const processed = processPatterns(options, patterns, props);
+	if (options.debug) log("internal processing patterns:", processed);
+	const { absolute, caseSensitiveMatch, debug, dot, followSymbolicLinks, onlyDirectories } = options;
+	const root = props.root.replace(BACKSLASHES, "");
+	const matchOptions = {
+		dot,
+		nobrace: options.braceExpansion === false,
+		nocase: !caseSensitiveMatch,
+		noextglob: options.extglob === false,
+		noglobstar: options.globstar === false,
+		posix: true
+	};
+	const matcher = (0, picomatch.default)(processed.match, matchOptions);
+	const ignore = (0, picomatch.default)(processed.ignore, matchOptions);
+	const partialMatcher = getPartialMatcher(processed.match, matchOptions);
+	const format = buildFormat(cwd, root, absolute);
+	const excludeFormatter = absolute ? format : buildFormat(cwd, root, true);
+	const excludePredicate = (_, p) => {
+		const relativePath = excludeFormatter(p, true);
+		return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+	};
+	let maxDepth;
+	if (options.deep !== void 0) maxDepth = Math.round(options.deep - props.depthOffset);
+	const crawler = new fdir.fdir({
+		filters: [debug ? (p, isDirectory) => {
+			const path = format(p, isDirectory);
+			const matches = matcher(path) && !ignore(path);
+			if (matches) log(`matched ${path}`);
+			return matches;
+		} : (p, isDirectory) => {
+			const path = format(p, isDirectory);
+			return matcher(path) && !ignore(path);
+		}],
+		exclude: debug ? (_, p) => {
+			const skipped = excludePredicate(_, p);
+			log(`${skipped ? "skipped" : "crawling"} ${p}`);
+			return skipped;
+		} : excludePredicate,
+		fs: options.fs,
+		pathSeparator: "/",
+		relativePaths: !absolute,
+		resolvePaths: absolute,
+		includeBasePath: absolute,
+		resolveSymlinks: followSymbolicLinks,
+		excludeSymlinks: !followSymbolicLinks,
+		excludeFiles: onlyDirectories,
+		includeDirs: onlyDirectories || !options.onlyFiles,
+		maxDepth,
+		signal: options.signal
+	}).crawl(root);
+	if (options.debug) log("internal properties:", {
+		...props,
+		root
+	});
+	return [crawler, cwd !== root && !absolute && buildRelative(cwd, root)];
+}
+//#endregion
+//#region src/index.ts
+function formatPaths(paths, mapper) {
+	if (mapper) for (let i = paths.length - 1; i >= 0; i--) paths[i] = mapper(paths[i]);
+	return paths;
+}
+const defaultOptions = {
+	caseSensitiveMatch: true,
+	cwd: process.cwd(),
+	debug: !!process.env.TINYGLOBBY_DEBUG,
+	expandDirectories: true,
+	followSymbolicLinks: true,
+	onlyFiles: true
+};
+function getOptions(options) {
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	opts.cwd = (opts.cwd instanceof URL ? (0, url.fileURLToPath)(opts.cwd) : (0, path.resolve)(opts.cwd)).replace(BACKSLASHES, "/");
+	opts.ignore = ensureStringArray(opts.ignore);
+	opts.fs && (opts.fs = {
+		readdir: opts.fs.readdir || fs.readdir,
+		readdirSync: opts.fs.readdirSync || fs.readdirSync,
+		realpath: opts.fs.realpath || fs.realpath,
+		realpathSync: opts.fs.realpathSync || fs.realpathSync,
+		stat: opts.fs.stat || fs.stat,
+		statSync: opts.fs.statSync || fs.statSync
+	});
+	if (opts.debug) log("globbing with options:", opts);
+	return opts;
+}
+function getCrawler(globInput, inputOptions = {}) {
+	var _ref;
+	if (globInput && (inputOptions === null || inputOptions === void 0 ? void 0 : inputOptions.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+	const isModern = isReadonlyArray(globInput) || typeof globInput === "string";
+	const patterns = ensureStringArray((_ref = isModern ? globInput : globInput.patterns) !== null && _ref !== void 0 ? _ref : "**/*");
+	const options = getOptions(isModern ? inputOptions : globInput);
+	return patterns.length > 0 ? buildCrawler(options, patterns) : [];
+}
+async function glob(globInput, options) {
+	const [crawler, relative] = getCrawler(globInput, options);
+	return crawler ? formatPaths(await crawler.withPromise(), relative) : [];
+}
+function globSync(globInput, options) {
+	const [crawler, relative] = getCrawler(globInput, options);
+	return crawler ? formatPaths(crawler.sync(), relative) : [];
+}
+//#endregion
+exports.convertPathToPattern = convertPathToPattern;
+exports.escapePath = escapePath;
+exports.glob = glob;
+exports.globSync = globSync;
+exports.isDynamicPattern = isDynamicPattern;
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.d.cts b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.d.cts
new file mode 100644
index 0000000..3e8e16a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.d.cts
@@ -0,0 +1,148 @@
+import { FSLike } from "fdir";
+
+//#region src/types.d.ts
+type FileSystemAdapter = Partial<FSLike>;
+interface GlobOptions {
+  /**
+  * Whether to return absolute paths. Disable to have relative paths.
+  * @default false
+  */
+  absolute?: boolean;
+  /**
+  * Enables support for brace expansion syntax, like `{a,b}` or `{1..9}`.
+  * @default true
+  */
+  braceExpansion?: boolean;
+  /**
+  * Whether to match in case-sensitive mode.
+  * @default true
+  */
+  caseSensitiveMatch?: boolean;
+  /**
+  * The working directory in which to search. Results will be returned relative to this directory, unless
+  * {@link absolute} is set.
+  *
+  * It is important to avoid globbing outside this directory when possible, even with absolute paths enabled,
+  * as doing so can harm performance due to having to recalculate relative paths.
+  * @default process.cwd()
+  */
+  cwd?: string | URL;
+  /**
+  * Logs useful debug information. Meant for development purposes. Logs can change at any time.
+  * @default false
+  */
+  debug?: boolean;
+  /**
+  * Maximum directory depth to crawl.
+  * @default Infinity
+  */
+  deep?: number;
+  /**
+  * Whether to return entries that start with a dot, like `.gitignore` or `.prettierrc`.
+  * @default false
+  */
+  dot?: boolean;
+  /**
+  * Whether to automatically expand directory patterns.
+  *
+  * Important to disable if migrating from [`fast-glob`](https://github.com/mrmlnc/fast-glob).
+  * @default true
+  */
+  expandDirectories?: boolean;
+  /**
+  * Enables support for extglobs, like `+(pattern)`.
+  * @default true
+  */
+  extglob?: boolean;
+  /**
+  * Whether to traverse and include symbolic links. Can slightly affect performance.
+  * @default true
+  */
+  followSymbolicLinks?: boolean;
+  /**
+  * An object that overrides `node:fs` functions.
+  * @default import('node:fs')
+  */
+  fs?: FileSystemAdapter;
+  /**
+  * Enables support for matching nested directories with globstars (`**`).
+  * If `false`, `**` behaves exactly like `*`.
+  * @default true
+  */
+  globstar?: boolean;
+  /**
+  * Glob patterns to exclude from the results.
+  * @default []
+  */
+  ignore?: string | readonly string[];
+  /**
+  * Enable to only return directories.
+  * If `true`, disables {@link onlyFiles}.
+  * @default false
+  */
+  onlyDirectories?: boolean;
+  /**
+  * Enable to only return files.
+  * @default true
+  */
+  onlyFiles?: boolean;
+  /**
+  * @deprecated Provide patterns as the first argument instead.
+  */
+  patterns?: string | readonly string[];
+  /**
+  * An `AbortSignal` to abort crawling the file system.
+  * @default undefined
+  */
+  signal?: AbortSignal;
+}
+//#endregion
+//#region src/utils.d.ts
+/**
+* Converts a path to a pattern depending on the platform.
+* Identical to {@link escapePath} on POSIX systems.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#convertPathToPattern}
+*/
+declare const convertPathToPattern: (path: string) => string;
+/**
+* Escapes a path's special characters depending on the platform.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#escapePath}
+*/
+declare const escapePath: (path: string) => string;
+/**
+* Checks if a pattern has dynamic parts.
+*
+* Has a few minor differences with [`fast-glob`](https://github.com/mrmlnc/fast-glob) for better accuracy:
+*
+* - Doesn't necessarily return `false` on patterns that include `\`.
+* - Returns `true` if the pattern includes parentheses, regardless of them representing one single pattern or not.
+* - Returns `true` for unfinished glob extensions i.e. `(h`, `+(h`.
+* - Returns `true` for unfinished brace expansions as long as they include `,` or `..`.
+*
+* @see {@link https://superchupu.dev/tinyglobby/documentation#isDynamicPattern}
+*/
+declare function isDynamicPattern(pattern: string, options?: {
+  caseSensitiveMatch: boolean;
+}): boolean;
+//#endregion
+//#region src/index.d.ts
+/**
+* Asynchronously match files following a glob pattern.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#glob}
+*/
+declare function glob(patterns: string | readonly string[], options?: Omit<GlobOptions, "patterns">): Promise<string[]>;
+/**
+* @deprecated Provide patterns as the first argument instead.
+*/
+declare function glob(options: GlobOptions): Promise<string[]>;
+/**
+* Synchronously match files following a glob pattern.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#globSync}
+*/
+declare function globSync(patterns: string | readonly string[], options?: Omit<GlobOptions, "patterns">): string[];
+/**
+* @deprecated Provide patterns as the first argument instead.
+*/
+declare function globSync(options: GlobOptions): string[];
+//#endregion
+export { type GlobOptions, convertPathToPattern, escapePath, glob, globSync, isDynamicPattern };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.d.mts b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.d.mts
new file mode 100644
index 0000000..3e8e16a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.d.mts
@@ -0,0 +1,148 @@
+import { FSLike } from "fdir";
+
+//#region src/types.d.ts
+type FileSystemAdapter = Partial<FSLike>;
+interface GlobOptions {
+  /**
+  * Whether to return absolute paths. Disable to have relative paths.
+  * @default false
+  */
+  absolute?: boolean;
+  /**
+  * Enables support for brace expansion syntax, like `{a,b}` or `{1..9}`.
+  * @default true
+  */
+  braceExpansion?: boolean;
+  /**
+  * Whether to match in case-sensitive mode.
+  * @default true
+  */
+  caseSensitiveMatch?: boolean;
+  /**
+  * The working directory in which to search. Results will be returned relative to this directory, unless
+  * {@link absolute} is set.
+  *
+  * It is important to avoid globbing outside this directory when possible, even with absolute paths enabled,
+  * as doing so can harm performance due to having to recalculate relative paths.
+  * @default process.cwd()
+  */
+  cwd?: string | URL;
+  /**
+  * Logs useful debug information. Meant for development purposes. Logs can change at any time.
+  * @default false
+  */
+  debug?: boolean;
+  /**
+  * Maximum directory depth to crawl.
+  * @default Infinity
+  */
+  deep?: number;
+  /**
+  * Whether to return entries that start with a dot, like `.gitignore` or `.prettierrc`.
+  * @default false
+  */
+  dot?: boolean;
+  /**
+  * Whether to automatically expand directory patterns.
+  *
+  * Important to disable if migrating from [`fast-glob`](https://github.com/mrmlnc/fast-glob).
+  * @default true
+  */
+  expandDirectories?: boolean;
+  /**
+  * Enables support for extglobs, like `+(pattern)`.
+  * @default true
+  */
+  extglob?: boolean;
+  /**
+  * Whether to traverse and include symbolic links. Can slightly affect performance.
+  * @default true
+  */
+  followSymbolicLinks?: boolean;
+  /**
+  * An object that overrides `node:fs` functions.
+  * @default import('node:fs')
+  */
+  fs?: FileSystemAdapter;
+  /**
+  * Enables support for matching nested directories with globstars (`**`).
+  * If `false`, `**` behaves exactly like `*`.
+  * @default true
+  */
+  globstar?: boolean;
+  /**
+  * Glob patterns to exclude from the results.
+  * @default []
+  */
+  ignore?: string | readonly string[];
+  /**
+  * Enable to only return directories.
+  * If `true`, disables {@link onlyFiles}.
+  * @default false
+  */
+  onlyDirectories?: boolean;
+  /**
+  * Enable to only return files.
+  * @default true
+  */
+  onlyFiles?: boolean;
+  /**
+  * @deprecated Provide patterns as the first argument instead.
+  */
+  patterns?: string | readonly string[];
+  /**
+  * An `AbortSignal` to abort crawling the file system.
+  * @default undefined
+  */
+  signal?: AbortSignal;
+}
+//#endregion
+//#region src/utils.d.ts
+/**
+* Converts a path to a pattern depending on the platform.
+* Identical to {@link escapePath} on POSIX systems.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#convertPathToPattern}
+*/
+declare const convertPathToPattern: (path: string) => string;
+/**
+* Escapes a path's special characters depending on the platform.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#escapePath}
+*/
+declare const escapePath: (path: string) => string;
+/**
+* Checks if a pattern has dynamic parts.
+*
+* Has a few minor differences with [`fast-glob`](https://github.com/mrmlnc/fast-glob) for better accuracy:
+*
+* - Doesn't necessarily return `false` on patterns that include `\`.
+* - Returns `true` if the pattern includes parentheses, regardless of them representing one single pattern or not.
+* - Returns `true` for unfinished glob extensions i.e. `(h`, `+(h`.
+* - Returns `true` for unfinished brace expansions as long as they include `,` or `..`.
+*
+* @see {@link https://superchupu.dev/tinyglobby/documentation#isDynamicPattern}
+*/
+declare function isDynamicPattern(pattern: string, options?: {
+  caseSensitiveMatch: boolean;
+}): boolean;
+//#endregion
+//#region src/index.d.ts
+/**
+* Asynchronously match files following a glob pattern.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#glob}
+*/
+declare function glob(patterns: string | readonly string[], options?: Omit<GlobOptions, "patterns">): Promise<string[]>;
+/**
+* @deprecated Provide patterns as the first argument instead.
+*/
+declare function glob(options: GlobOptions): Promise<string[]>;
+/**
+* Synchronously match files following a glob pattern.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#globSync}
+*/
+declare function globSync(patterns: string | readonly string[], options?: Omit<GlobOptions, "patterns">): string[];
+/**
+* @deprecated Provide patterns as the first argument instead.
+*/
+declare function globSync(options: GlobOptions): string[];
+//#endregion
+export { type GlobOptions, convertPathToPattern, escapePath, glob, globSync, isDynamicPattern };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.mjs
new file mode 100644
index 0000000..ac043aa
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/dist/index.mjs
@@ -0,0 +1,306 @@
+import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
+import { isAbsolute, posix, resolve } from "path";
+import { fileURLToPath } from "url";
+import { fdir } from "fdir";
+import picomatch from "picomatch";
+//#region src/utils.ts
+const isReadonlyArray = Array.isArray;
+const BACKSLASHES = /\\/g;
+const isWin = process.platform === "win32";
+const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options = {}) {
+	const patternsCount = patterns.length;
+	const patternsParts = Array(patternsCount);
+	const matchers = Array(patternsCount);
+	let i, j;
+	for (i = 0; i < patternsCount; i++) {
+		const parts = splitPattern(patterns[i]);
+		patternsParts[i] = parts;
+		const partsCount = parts.length;
+		const partMatchers = Array(partsCount);
+		for (j = 0; j < partsCount; j++) partMatchers[j] = picomatch(parts[j], options);
+		matchers[i] = partMatchers;
+	}
+	return (input) => {
+		const inputParts = input.split("/");
+		if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+		for (i = 0; i < patternsCount; i++) {
+			const patternParts = patternsParts[i];
+			const matcher = matchers[i];
+			const inputPatternCount = inputParts.length;
+			const minParts = Math.min(inputPatternCount, patternParts.length);
+			j = 0;
+			while (j < minParts) {
+				const part = patternParts[j];
+				if (part.includes("/")) return true;
+				if (!matcher[j](inputParts[j])) break;
+				if (!options.noglobstar && part === "**") return true;
+				j++;
+			}
+			if (j === inputPatternCount) return true;
+		}
+		return false;
+	};
+}
+/* node:coverage ignore next 2 */
+const WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
+const isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
+function buildFormat(cwd, root, absolute) {
+	if (cwd === root || root.startsWith(`${cwd}/`)) {
+		if (absolute) {
+			const start = cwd.length + +!isRoot(cwd);
+			return (p, isDir) => p.slice(start, isDir ? -1 : void 0) || ".";
+		}
+		const prefix = root.slice(cwd.length + 1);
+		if (prefix) return (p, isDir) => {
+			if (p === ".") return prefix;
+			const result = `${prefix}/${p}`;
+			return isDir ? result.slice(0, -1) : result;
+		};
+		return (p, isDir) => isDir && p !== "." ? p.slice(0, -1) : p;
+	}
+	if (absolute) return (p) => posix.relative(cwd, p) || ".";
+	return (p) => posix.relative(cwd, `${root}/${p}`) || ".";
+}
+function buildRelative(cwd, root) {
+	if (root.startsWith(`${cwd}/`)) {
+		const prefix = root.slice(cwd.length + 1);
+		return (p) => `${prefix}/${p}`;
+	}
+	return (p) => {
+		const result = posix.relative(cwd, `${root}/${p}`);
+		return p[p.length - 1] === "/" && result !== "" ? `${result}/` : result || ".";
+	};
+}
+const splitPatternOptions = { parts: true };
+function splitPattern(path) {
+	var _result$parts;
+	const result = picomatch.scan(path, splitPatternOptions);
+	return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path];
+}
+const ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
+function convertPosixPathToPattern(path) {
+	return escapePosixPath(path);
+}
+function convertWin32PathToPattern(path) {
+	return escapeWin32Path(path).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+}
+/**
+* Converts a path to a pattern depending on the platform.
+* Identical to {@link escapePath} on POSIX systems.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#convertPathToPattern}
+*/
+/* node:coverage ignore next 3 */
+const convertPathToPattern = isWin ? convertWin32PathToPattern : convertPosixPathToPattern;
+const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+const escapePosixPath = (path) => path.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path) => path.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+/**
+* Escapes a path's special characters depending on the platform.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#escapePath}
+*/
+/* node:coverage ignore next */
+const escapePath = isWin ? escapeWin32Path : escapePosixPath;
+/**
+* Checks if a pattern has dynamic parts.
+*
+* Has a few minor differences with [`fast-glob`](https://github.com/mrmlnc/fast-glob) for better accuracy:
+*
+* - Doesn't necessarily return `false` on patterns that include `\`.
+* - Returns `true` if the pattern includes parentheses, regardless of them representing one single pattern or not.
+* - Returns `true` for unfinished glob extensions i.e. `(h`, `+(h`.
+* - Returns `true` for unfinished brace expansions as long as they include `,` or `..`.
+*
+* @see {@link https://superchupu.dev/tinyglobby/documentation#isDynamicPattern}
+*/
+function isDynamicPattern(pattern, options) {
+	if ((options === null || options === void 0 ? void 0 : options.caseSensitiveMatch) === false) return true;
+	const scan = picomatch.scan(pattern);
+	return scan.isGlob || scan.negated;
+}
+function log(...tasks) {
+	console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...tasks);
+}
+function ensureStringArray(value) {
+	return typeof value === "string" ? [value] : value !== null && value !== void 0 ? value : [];
+}
+//#endregion
+//#region src/patterns.ts
+const PARENT_DIRECTORY = /^(\/?\.\.)+/;
+const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+function normalizePattern(pattern, opts, props, isIgnore) {
+	var _PARENT_DIRECTORY$exe;
+	const cwd = opts.cwd;
+	let result = pattern;
+	if (pattern[pattern.length - 1] === "/") result = pattern.slice(0, -1);
+	if (result[result.length - 1] !== "*" && opts.expandDirectories) result += "/**";
+	const escapedCwd = escapePath(cwd);
+	result = isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
+	const parentDir = (_PARENT_DIRECTORY$exe = PARENT_DIRECTORY.exec(result)) === null || _PARENT_DIRECTORY$exe === void 0 ? void 0 : _PARENT_DIRECTORY$exe[0];
+	const parts = splitPattern(result);
+	if (parentDir) {
+		const n = (parentDir.length + 1) / 3;
+		let i = 0;
+		const cwdParts = escapedCwd.split("/");
+		while (i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]) {
+			result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
+			i++;
+		}
+		const potentialRoot = posix.join(cwd, parentDir.slice(i * 3));
+		if (potentialRoot[0] !== "." && props.root.length > potentialRoot.length) {
+			props.root = potentialRoot;
+			props.depthOffset = -n + i;
+		}
+	}
+	if (!isIgnore && props.depthOffset >= 0) {
+		var _props$commonPath;
+		(_props$commonPath = props.commonPath) !== null && _props$commonPath !== void 0 || (props.commonPath = parts);
+		const newCommonPath = [];
+		const length = Math.min(props.commonPath.length, parts.length);
+		for (let i = 0; i < length; i++) {
+			const part = parts[i];
+			if (part === "**" && !parts[i + 1]) {
+				newCommonPath.pop();
+				break;
+			}
+			if (i === parts.length - 1 || part !== props.commonPath[i] || isDynamicPattern(part)) break;
+			newCommonPath.push(part);
+		}
+		props.depthOffset = newCommonPath.length;
+		props.commonPath = newCommonPath;
+		props.root = newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd;
+	}
+	return result;
+}
+function processPatterns(options, patterns, props) {
+	const matchPatterns = [];
+	const ignorePatterns = [];
+	for (const pattern of options.ignore) {
+		if (!pattern) continue;
+		if (pattern[0] !== "!" || pattern[1] === "(") ignorePatterns.push(normalizePattern(pattern, options, props, true));
+	}
+	for (const pattern of patterns) {
+		if (!pattern) continue;
+		if (pattern[0] !== "!" || pattern[1] === "(") matchPatterns.push(normalizePattern(pattern, options, props, false));
+		else if (pattern[1] !== "!" || pattern[2] === "(") ignorePatterns.push(normalizePattern(pattern.slice(1), options, props, true));
+	}
+	return {
+		match: matchPatterns,
+		ignore: ignorePatterns
+	};
+}
+//#endregion
+//#region src/crawler.ts
+function buildCrawler(options, patterns) {
+	const cwd = options.cwd;
+	const props = {
+		root: cwd,
+		depthOffset: 0
+	};
+	const processed = processPatterns(options, patterns, props);
+	if (options.debug) log("internal processing patterns:", processed);
+	const { absolute, caseSensitiveMatch, debug, dot, followSymbolicLinks, onlyDirectories } = options;
+	const root = props.root.replace(BACKSLASHES, "");
+	const matchOptions = {
+		dot,
+		nobrace: options.braceExpansion === false,
+		nocase: !caseSensitiveMatch,
+		noextglob: options.extglob === false,
+		noglobstar: options.globstar === false,
+		posix: true
+	};
+	const matcher = picomatch(processed.match, matchOptions);
+	const ignore = picomatch(processed.ignore, matchOptions);
+	const partialMatcher = getPartialMatcher(processed.match, matchOptions);
+	const format = buildFormat(cwd, root, absolute);
+	const excludeFormatter = absolute ? format : buildFormat(cwd, root, true);
+	const excludePredicate = (_, p) => {
+		const relativePath = excludeFormatter(p, true);
+		return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+	};
+	let maxDepth;
+	if (options.deep !== void 0) maxDepth = Math.round(options.deep - props.depthOffset);
+	const crawler = new fdir({
+		filters: [debug ? (p, isDirectory) => {
+			const path = format(p, isDirectory);
+			const matches = matcher(path) && !ignore(path);
+			if (matches) log(`matched ${path}`);
+			return matches;
+		} : (p, isDirectory) => {
+			const path = format(p, isDirectory);
+			return matcher(path) && !ignore(path);
+		}],
+		exclude: debug ? (_, p) => {
+			const skipped = excludePredicate(_, p);
+			log(`${skipped ? "skipped" : "crawling"} ${p}`);
+			return skipped;
+		} : excludePredicate,
+		fs: options.fs,
+		pathSeparator: "/",
+		relativePaths: !absolute,
+		resolvePaths: absolute,
+		includeBasePath: absolute,
+		resolveSymlinks: followSymbolicLinks,
+		excludeSymlinks: !followSymbolicLinks,
+		excludeFiles: onlyDirectories,
+		includeDirs: onlyDirectories || !options.onlyFiles,
+		maxDepth,
+		signal: options.signal
+	}).crawl(root);
+	if (options.debug) log("internal properties:", {
+		...props,
+		root
+	});
+	return [crawler, cwd !== root && !absolute && buildRelative(cwd, root)];
+}
+//#endregion
+//#region src/index.ts
+function formatPaths(paths, mapper) {
+	if (mapper) for (let i = paths.length - 1; i >= 0; i--) paths[i] = mapper(paths[i]);
+	return paths;
+}
+const defaultOptions = {
+	caseSensitiveMatch: true,
+	cwd: process.cwd(),
+	debug: !!process.env.TINYGLOBBY_DEBUG,
+	expandDirectories: true,
+	followSymbolicLinks: true,
+	onlyFiles: true
+};
+function getOptions(options) {
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve(opts.cwd)).replace(BACKSLASHES, "/");
+	opts.ignore = ensureStringArray(opts.ignore);
+	opts.fs && (opts.fs = {
+		readdir: opts.fs.readdir || readdir,
+		readdirSync: opts.fs.readdirSync || readdirSync,
+		realpath: opts.fs.realpath || realpath,
+		realpathSync: opts.fs.realpathSync || realpathSync,
+		stat: opts.fs.stat || stat,
+		statSync: opts.fs.statSync || statSync
+	});
+	if (opts.debug) log("globbing with options:", opts);
+	return opts;
+}
+function getCrawler(globInput, inputOptions = {}) {
+	var _ref;
+	if (globInput && (inputOptions === null || inputOptions === void 0 ? void 0 : inputOptions.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+	const isModern = isReadonlyArray(globInput) || typeof globInput === "string";
+	const patterns = ensureStringArray((_ref = isModern ? globInput : globInput.patterns) !== null && _ref !== void 0 ? _ref : "**/*");
+	const options = getOptions(isModern ? inputOptions : globInput);
+	return patterns.length > 0 ? buildCrawler(options, patterns) : [];
+}
+async function glob(globInput, options) {
+	const [crawler, relative] = getCrawler(globInput, options);
+	return crawler ? formatPaths(await crawler.withPromise(), relative) : [];
+}
+function globSync(globInput, options) {
+	const [crawler, relative] = getCrawler(globInput, options);
+	return crawler ? formatPaths(crawler.sync(), relative) : [];
+}
+//#endregion
+export { convertPathToPattern, escapePath, glob, globSync, isDynamicPattern };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/package.json
new file mode 100644
index 0000000..06dadac
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/tinyglobby/package.json
@@ -0,0 +1,73 @@
+{
+  "name": "tinyglobby",
+  "version": "0.2.16",
+  "description": "A fast and minimal alternative to globby and fast-glob",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "author": "Superchupu",
+  "license": "MIT",
+  "keywords": [
+    "glob",
+    "patterns",
+    "fast",
+    "implementation"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SuperchupuDev/tinyglobby.git"
+  },
+  "bugs": {
+    "url": "https://github.com/SuperchupuDev/tinyglobby/issues"
+  },
+  "homepage": "https://superchupu.dev/tinyglobby",
+  "funding": {
+    "url": "https://github.com/sponsors/SuperchupuDev"
+  },
+  "dependencies": {
+    "fdir": "^6.5.0",
+    "picomatch": "^4.0.4"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.10",
+    "@types/node": "^25.5.2",
+    "@types/picomatch": "^4.0.3",
+    "fast-glob": "^3.3.3",
+    "fs-fixture": "^2.13.0",
+    "glob": "^13.0.6",
+    "tinybench": "^6.0.0",
+    "tsdown": "^0.21.7",
+    "typescript": "^6.0.2"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "scripts": {
+    "bench": "node benchmark/bench.ts",
+    "bench:setup": "node benchmark/setup.ts",
+    "build": "tsdown",
+    "check": "biome check",
+    "check:fix": "biome check --write --unsafe",
+    "format": "biome format --write",
+    "lint": "biome lint",
+    "test": "node --test \"test/**/*.ts\"",
+    "test:coverage": "node --test --experimental-test-coverage \"test/**/*.ts\"",
+    "test:only": "node --test --test-only \"test/**/*.ts\"",
+    "typecheck": "tsc --noEmit"
+  }
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/LICENSE.md b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/LICENSE.md
new file mode 100644
index 0000000..0aabee5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/LICENSE.md
@@ -0,0 +1,2230 @@
+# Vite core license
+Vite is released under the MIT license:
+
+MIT License
+
+Copyright (c) 2019-present, VoidZero Inc. and Vite 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.
+
+# Licenses of bundled dependencies
+The published Vite artifact additionally contains code with the following licenses:
+Apache-2.0, BSD-2-Clause, CC0-1.0, ISC, MIT
+
+# Bundled dependencies:
+## @jridgewell/gen-mapping, @jridgewell/remapping, @jridgewell/sourcemap-codec, @jridgewell/trace-mapping
+License: MIT
+By: Justin Ridgewell
+Repositories: https://github.com/jridgewell/sourcemaps, https://github.com/jridgewell/sourcemaps, https://github.com/jridgewell/sourcemaps, https://github.com/jridgewell/sourcemaps
+
+> Copyright 2024 Justin Ridgewell <justin@ridgewell.name>
+> 
+> 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.
+
+---------------------------------------
+
+## @jridgewell/resolve-uri
+License: MIT
+By: Justin Ridgewell
+Repository: https://github.com/jridgewell/resolve-uri
+
+> Copyright 2019 Justin Ridgewell <jridgewell@google.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.
+
+---------------------------------------
+
+## @polka/compression
+License: MIT
+Repository: https://github.com/lukeed/polka
+
+---------------------------------------
+
+## @polka/url
+License: MIT
+By: Luke Edwards
+Repository: https://github.com/lukeed/polka
+
+---------------------------------------
+
+## @rollup/plugin-alias, @rollup/plugin-dynamic-import-vars, @rollup/pluginutils
+License: MIT
+By: Johannes Stein
+Repository: https://github.com/rollup/plugins
+
+License: MIT
+By: LarsDenBakker
+Repository: https://github.com/rollup/plugins
+
+License: MIT
+By: Rich Harris
+Repository: https://github.com/rollup/plugins
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/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.
+
+---------------------------------------
+
+## @vercel/detect-agent
+License: Apache-2.0
+By: Vercel
+Repository: https://github.com/vercel/vercel
+
+> Apache License
+>                            Version 2.0, January 2004
+>                         http://www.apache.org/licenses/
+> 
+>    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+> 
+>    1. Definitions.
+> 
+>       "License" shall mean the terms and conditions for use, reproduction,
+>       and distribution as defined by Sections 1 through 9 of this document.
+> 
+>       "Licensor" shall mean the copyright owner or entity authorized by
+>       the copyright owner that is granting the License.
+> 
+>       "Legal Entity" shall mean the union of the acting entity and all
+>       other entities that control, are controlled by, or are under common
+>       control with that entity. For the purposes of this definition,
+>       "control" means (i) the power, direct or indirect, to cause the
+>       direction or management of such entity, whether by contract or
+>       otherwise, or (ii) ownership of fifty percent (50%) or more of the
+>       outstanding shares, or (iii) beneficial ownership of such entity.
+> 
+>       "You" (or "Your") shall mean an individual or Legal Entity
+>       exercising permissions granted by this License.
+> 
+>       "Source" form shall mean the preferred form for making modifications,
+>       including but not limited to software source code, documentation
+>       source, and configuration files.
+> 
+>       "Object" form shall mean any form resulting from mechanical
+>       transformation or translation of a Source form, including but
+>       not limited to compiled object code, generated documentation,
+>       and conversions to other media types.
+> 
+>       "Work" shall mean the work of authorship, whether in Source or
+>       Object form, made available under the License, as indicated by a
+>       copyright notice that is included in or attached to the work
+>       (an example is provided in the Appendix below).
+> 
+>       "Derivative Works" shall mean any work, whether in Source or Object
+>       form, that is based on (or derived from) the Work and for which the
+>       editorial revisions, annotations, elaborations, or other modifications
+>       represent, as a whole, an original work of authorship. For the purposes
+>       of this License, Derivative Works shall not include works that remain
+>       separable from, or merely link (or bind by name) to the interfaces of,
+>       the Work and Derivative Works thereof.
+> 
+>       "Contribution" shall mean any work of authorship, including
+>       the original version of the Work and any modifications or additions
+>       to that Work or Derivative Works thereof, that is intentionally
+>       submitted to Licensor for inclusion in the Work by the copyright owner
+>       or by an individual or Legal Entity authorized to submit on behalf of
+>       the copyright owner. For the purposes of this definition, "submitted"
+>       means any form of electronic, verbal, or written communication sent
+>       to the Licensor or its representatives, including but not limited to
+>       communication on electronic mailing lists, source code control systems,
+>       and issue tracking systems that are managed by, or on behalf of, the
+>       Licensor for the purpose of discussing and improving the Work, but
+>       excluding communication that is conspicuously marked or otherwise
+>       designated in writing by the copyright owner as "Not a Contribution."
+> 
+>       "Contributor" shall mean Licensor and any individual or Legal Entity
+>       on behalf of whom a Contribution has been received by Licensor and
+>       subsequently incorporated within the Work.
+> 
+>    2. Grant of Copyright License. Subject to the terms and conditions of
+>       this License, each Contributor hereby grants to You a perpetual,
+>       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+>       copyright license to reproduce, prepare Derivative Works of,
+>       publicly display, publicly perform, sublicense, and distribute the
+>       Work and such Derivative Works in Source or Object form.
+> 
+>    3. Grant of Patent License. Subject to the terms and conditions of
+>       this License, each Contributor hereby grants to You a perpetual,
+>       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+>       (except as stated in this section) patent license to make, have made,
+>       use, offer to sell, sell, import, and otherwise transfer the Work,
+>       where such license applies only to those patent claims licensable
+>       by such Contributor that are necessarily infringed by their
+>       Contribution(s) alone or by combination of their Contribution(s)
+>       with the Work to which such Contribution(s) was submitted. If You
+>       institute patent litigation against any entity (including a
+>       cross-claim or counterclaim in a lawsuit) alleging that the Work
+>       or a Contribution incorporated within the Work constitutes direct
+>       or contributory patent infringement, then any patent licenses
+>       granted to You under this License for that Work shall terminate
+>       as of the date such litigation is filed.
+> 
+>    4. Redistribution. You may reproduce and distribute copies of the
+>       Work or Derivative Works thereof in any medium, with or without
+>       modifications, and in Source or Object form, provided that You
+>       meet the following conditions:
+> 
+>       (a) You must give any other recipients of the Work or
+>           Derivative Works a copy of this License; and
+> 
+>       (b) You must cause any modified files to carry prominent notices
+>           stating that You changed the files; and
+> 
+>       (c) You must retain, in the Source form of any Derivative Works
+>           that You distribute, all copyright, patent, trademark, and
+>           attribution notices from the Source form of the Work,
+>           excluding those notices that do not pertain to any part of
+>           the Derivative Works; and
+> 
+>       (d) If the Work includes a "NOTICE" text file as part of its
+>           distribution, then any Derivative Works that You distribute must
+>           include a readable copy of the attribution notices contained
+>           within such NOTICE file, excluding those notices that do not
+>           pertain to any part of the Derivative Works, in at least one
+>           of the following places: within a NOTICE text file distributed
+>           as part of the Derivative Works; within the Source form or
+>           documentation, if provided along with the Derivative Works; or,
+>           within a display generated by the Derivative Works, if and
+>           wherever such third-party notices normally appear. The contents
+>           of the NOTICE file are for informational purposes only and
+>           do not modify the License. You may add Your own attribution
+>           notices within Derivative Works that You distribute, alongside
+>           or as an addendum to the NOTICE text from the Work, provided
+>           that such additional attribution notices cannot be construed
+>           as modifying the License.
+> 
+>       You may add Your own copyright statement to Your modifications and
+>       may provide additional or different license terms and conditions
+>       for use, reproduction, or distribution of Your modifications, or
+>       for any such Derivative Works as a whole, provided Your use,
+>       reproduction, and distribution of the Work otherwise complies with
+>       the conditions stated in this License.
+> 
+>    5. Submission of Contributions. Unless You explicitly state otherwise,
+>       any Contribution intentionally submitted for inclusion in the Work
+>       by You to the Licensor shall be under the terms and conditions of
+>       this License, without any additional terms or conditions.
+>       Notwithstanding the above, nothing herein shall supersede or modify
+>       the terms of any separate license agreement you may have executed
+>       with Licensor regarding such Contributions.
+> 
+>    6. Trademarks. This License does not grant permission to use the trade
+>       names, trademarks, service marks, or product names of the Licensor,
+>       except as required for reasonable and customary use in describing the
+>       origin of the Work and reproducing the content of the NOTICE file.
+> 
+>    7. Disclaimer of Warranty. Unless required by applicable law or
+>       agreed to in writing, Licensor provides the Work (and each
+>       Contributor provides its Contributions) on an "AS IS" BASIS,
+>       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+>       implied, including, without limitation, any warranties or conditions
+>       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+>       PARTICULAR PURPOSE. You are solely responsible for determining the
+>       appropriateness of using or redistributing the Work and assume any
+>       risks associated with Your exercise of permissions under this License.
+> 
+>    8. Limitation of Liability. In no event and under no legal theory,
+>       whether in tort (including negligence), contract, or otherwise,
+>       unless required by applicable law (such as deliberate and grossly
+>       negligent acts) or agreed to in writing, shall any Contributor be
+>       liable to You for damages, including any direct, indirect, special,
+>       incidental, or consequential damages of any character arising as a
+>       result of this License or out of the use or inability to use the
+>       Work (including but not limited to damages for loss of goodwill,
+>       work stoppage, computer failure or malfunction, or any and all
+>       other commercial damages or losses), even if such Contributor
+>       has been advised of the possibility of such damages.
+> 
+>    9. Accepting Warranty or Additional Liability. While redistributing
+>       the Work or Derivative Works thereof, You may choose to offer,
+>       and charge a fee for, acceptance of support, warranty, indemnity,
+>       or other liability obligations and/or rights consistent with this
+>       License. However, in accepting such obligations, You may act only
+>       on Your own behalf and on Your sole responsibility, not on behalf
+>       of any other Contributor, and only if You agree to indemnify,
+>       defend, and hold each Contributor harmless for any liability
+>       incurred by, or claims asserted against, such Contributor by reason
+>       of your accepting any such warranty or additional liability.
+> 
+>    END OF TERMS AND CONDITIONS
+> 
+>    APPENDIX: How to apply the Apache License to your work.
+> 
+>       To apply the Apache License to your work, attach the following
+>       boilerplate notice, with the fields enclosed by brackets "[]"
+>       replaced with your own identifying information. (Don't include
+>       the brackets!)  The text should be enclosed in the appropriate
+>       comment syntax for the file format. We also recommend that a
+>       file or class name and description of purpose be included on the
+>       same "printed page" as the copyright notice for easier
+>       identification within third-party archives.
+> 
+>    Copyright 2017 Vercel, Inc.
+> 
+>    Licensed under the Apache License, Version 2.0 (the "License");
+>    you may not use this file except in compliance with the License.
+>    You may obtain a copy of the License at
+> 
+>        http://www.apache.org/licenses/LICENSE-2.0
+> 
+>    Unless required by applicable law or agreed to in writing, software
+>    distributed under the License is distributed on an "AS IS" BASIS,
+>    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+>    See the License for the specific language governing permissions and
+>    limitations under the License.
+
+---------------------------------------
+
+## @vitest/utils
+License: MIT
+Repository: https://github.com/vitest-dev/vitest
+
+> MIT License
+> 
+> Copyright (c) 2021-Present VoidZero Inc. and Vitest 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.
+
+---------------------------------------
+
+## anymatch
+License: ISC
+By: Elan Shanker
+Repository: https://github.com/micromatch/anymatch
+
+> The ISC License
+> 
+> Copyright (c) 2019 Elan Shanker, Paul Miller (https://paulmillr.com)
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## artichokie
+License: MIT
+By: sapphi-red, Evan You
+Repository: https://github.com/sapphi-red/artichokie
+
+> MIT License
+> 
+> Copyright (c) 2020-present, Yuxi (Evan) You
+> Copyright (c) 2023-present, sapphi-red
+> 
+> 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.
+
+---------------------------------------
+
+## binary-extensions
+License: MIT
+By: Sindre Sorhus
+Repository: https://github.com/sindresorhus/binary-extensions
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> Copyright (c) Paul Miller (https://paulmillr.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.
+
+---------------------------------------
+
+## braces, fill-range, is-number
+License: MIT
+By: Jon Schlinkert, Brian Woodward, Elan Shanker, Eugene Sharygin, hemanth.hm
+Repository: https://github.com/micromatch/braces
+
+License: MIT
+By: Jon Schlinkert, Edo Rivai, Paul Miller, Rouven Weßling
+Repository: https://github.com/jonschlinkert/fill-range
+
+License: MIT
+By: Jon Schlinkert, Olsten Larck, Rouven Weßling
+Repository: https://github.com/jonschlinkert/is-number
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> 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.
+
+---------------------------------------
+
+## bundle-name, default-browser, default-browser-id, define-lazy-prop, is-docker, is-inside-container, is-wsl, open, run-applescript, wsl-utils
+License: MIT
+By: Sindre Sorhus
+Repositories: https://github.com/sindresorhus/bundle-name, https://github.com/sindresorhus/default-browser, https://github.com/sindresorhus/default-browser-id, https://github.com/sindresorhus/define-lazy-prop, https://github.com/sindresorhus/is-docker, https://github.com/sindresorhus/is-inside-container, https://github.com/sindresorhus/is-wsl, https://github.com/sindresorhus/open, https://github.com/sindresorhus/run-applescript, https://github.com/sindresorhus/wsl-utils
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://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.
+
+---------------------------------------
+
+## cac
+License: MIT
+By: egoist
+Repository: https://github.com/cacjs/cac
+
+> The MIT License (MIT)
+> 
+> Copyright (c) EGOIST <0x142857@gmail.com> (https://github.com/egoist)
+> 
+> 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.
+
+---------------------------------------
+
+## chokidar
+License: MIT
+By: Paul Miller, Elan Shanker
+Repository: https://github.com/paulmillr/chokidar
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2012-2019 Paul Miller (https://paulmillr.com), Elan Shanker
+> 
+> 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.
+
+---------------------------------------
+
+## connect
+License: MIT
+By: TJ Holowaychuk, Douglas Christopher Wilson, Jonathan Ong, Tim Caswell
+Repository: https://github.com/senchalabs/connect
+
+> (The MIT License)
+> 
+> Copyright (c) 2010 Sencha Inc.
+> Copyright (c) 2011 LearnBoost
+> Copyright (c) 2011-2014 TJ Holowaychuk
+> Copyright (c) 2015 Douglas Christopher Wilson
+> 
+> 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.
+
+---------------------------------------
+
+## convert-source-map
+License: MIT
+By: Thorsten Lorenz
+Repository: https://github.com/thlorenz/convert-source-map
+
+> Copyright 2013 Thorsten Lorenz. 
+> All rights reserved.
+> 
+> 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.
+
+---------------------------------------
+
+## cors
+License: MIT
+By: Troy Goode
+Repository: https://github.com/expressjs/cors
+
+> (The MIT License)
+> 
+> Copyright (c) 2013 Troy Goode <troygoode@gmail.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.
+
+---------------------------------------
+
+## cross-spawn
+License: MIT
+By: André Cruz
+Repository: https://github.com/moxystudio/node-cross-spawn
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2018 Made With MOXY Lda <hello@moxy.studio>
+> 
+> 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.
+
+---------------------------------------
+
+## cssesc
+License: MIT
+By: Mathias Bynens
+Repository: https://github.com/mathiasbynens/cssesc
+
+> Copyright Mathias Bynens <https://mathiasbynens.be/>
+> 
+> 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.
+
+---------------------------------------
+
+## dotenv-expand
+License: BSD-2-Clause
+By: motdotla
+Repository: https://github.com/motdotla/dotenv-expand
+
+> Copyright (c) 2016, Scott Motte
+> All rights reserved.
+> 
+> Redistribution and use in source and binary forms, with or without
+> modification, are permitted provided that the following conditions are met:
+> 
+> * Redistributions of source code must retain the above copyright notice, this
+>   list of conditions and the following disclaimer.
+> 
+> * Redistributions in binary form must reproduce the above copyright notice,
+>   this list of conditions and the following disclaimer in the documentation
+>   and/or other materials provided with the distribution.
+> 
+> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+> AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+> IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+> DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+> FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+> DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+> SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+> OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+> OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---------------------------------------
+
+## ee-first
+License: MIT
+By: Jonathan Ong, Douglas Christopher Wilson
+Repository: https://github.com/jonathanong/ee-first
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014 Jonathan Ong me@jongleberry.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.
+
+---------------------------------------
+
+## encodeurl
+License: MIT
+By: Douglas Christopher Wilson
+Repository: https://github.com/pillarjs/encodeurl
+
+> (The MIT License)
+> 
+> Copyright (c) 2016 Douglas Christopher Wilson
+> 
+> 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.
+
+---------------------------------------
+
+## entities
+License: BSD-2-Clause
+By: Felix Boehm
+Repository: https://github.com/fb55/entities
+
+> Copyright (c) Felix Böhm
+> All rights reserved.
+> 
+> Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+> 
+> Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+> 
+> Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+> 
+> THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+> EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---------------------------------------
+
+## es-module-lexer
+License: MIT
+By: Guy Bedford
+Repository: https://github.com/guybedford/es-module-lexer
+
+> MIT License
+> -----------
+> 
+> Copyright (C) 2018-2022 Guy Bedford
+> 
+> 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.
+
+---------------------------------------
+
+## escape-html
+License: MIT
+Repository: https://github.com/component/escape-html
+
+> (The MIT License)
+> 
+> Copyright (c) 2012-2013 TJ Holowaychuk
+> Copyright (c) 2015 Andreas Lubbe
+> Copyright (c) 2015 Tiancheng "Timothy" Gu
+> 
+> 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.
+
+---------------------------------------
+
+## estree-walker
+License: MIT
+By: Rich Harris
+Repository: https://github.com/Rich-Harris/estree-walker
+
+> Copyright (c) 2015-20 [these people](https://github.com/Rich-Harris/estree-walker/graphs/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.
+
+---------------------------------------
+
+## etag
+License: MIT
+By: Douglas Christopher Wilson, David Björklund
+Repository: https://github.com/jshttp/etag
+
+> (The MIT License)
+> 
+> Copyright (c) 2014-2016 Douglas Christopher Wilson
+> 
+> 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.
+
+---------------------------------------
+
+## finalhandler
+License: MIT
+By: Douglas Christopher Wilson
+Repository: https://github.com/pillarjs/finalhandler
+
+> (The MIT License)
+> 
+> Copyright (c) 2014-2017 Douglas Christopher Wilson <doug@somethingdoug.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.
+
+---------------------------------------
+
+## follow-redirects
+License: MIT
+By: Ruben Verborgh, Olivier Lalonde, James Talmage
+Repository: https://github.com/follow-redirects/follow-redirects
+
+> Copyright 2014–present Olivier Lalonde <olalonde@gmail.com>, James Talmage <james@talmage.io>, Ruben Verborgh
+> 
+> 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.
+
+---------------------------------------
+
+## generic-names
+License: MIT
+By: Alexey Litvinov
+Repository: https://github.com/css-modules/generic-names
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2015 Alexey Litvinov
+> 
+> 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.
+
+---------------------------------------
+
+## glob-parent
+License: ISC
+By: Gulp Team, Elan Shanker, Blaine Bublitz
+Repository: https://github.com/gulpjs/glob-parent
+
+> The ISC License
+> 
+> Copyright (c) 2015, 2019 Elan Shanker
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## host-validation-middleware
+License: MIT
+By: sapphi-red
+Repository: https://github.com/sapphi-red/host-validation-middleware
+
+> MIT License
+> 
+> Copyright (c) 2025 sapphi-red
+> 
+> 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.
+
+---------------------------------------
+
+## http-proxy-3
+License: MIT
+By: William Stein, Charlie Robbins, Jimb Esser, jcrugzz
+Repository: https://github.com/sagemathinc/http-proxy-3
+
+> node-http-3
+> 
+> Copyright (c) 2010-2025 William Stein, Charlie Robbins, Jarrett Cruger & the 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.
+
+---------------------------------------
+
+## icss-utils
+License: ISC
+By: Glen Maddern
+Repository: https://github.com/css-modules/icss-utils
+
+> ISC License (ISC)
+> Copyright 2018 Glen Maddern
+> 
+> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## is-binary-path
+License: MIT
+By: Sindre Sorhus
+Repository: https://github.com/sindresorhus/is-binary-path
+
+> MIT License
+> 
+> Copyright (c) 2019 Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com), Paul Miller (https://paulmillr.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.
+
+---------------------------------------
+
+## is-extglob
+License: MIT
+By: Jon Schlinkert
+Repository: https://github.com/jonschlinkert/is-extglob
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2016, Jon Schlinkert
+> 
+> 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.
+
+---------------------------------------
+
+## is-glob
+License: MIT
+By: Jon Schlinkert, Brian Woodward, Daniel Perez
+Repository: https://github.com/micromatch/is-glob
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2017, Jon Schlinkert.
+> 
+> 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.
+
+---------------------------------------
+
+## isexe, which
+License: ISC
+By: Isaac Z. Schlueter
+Repositories: https://github.com/isaacs/isexe, https://github.com/isaacs/node-which
+
+> The ISC License
+> 
+> Copyright (c) Isaac Z. Schlueter and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## js-tokens
+License: MIT
+By: Simon Lydell
+Repository: https://github.com/lydell/js-tokens
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024 Simon Lydell
+> 
+> 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.
+
+---------------------------------------
+
+## launch-editor, launch-editor-middleware
+License: MIT
+By: Evan You
+Repositories: https://github.com/yyx990803/launch-editor, https://github.com/yyx990803/launch-editor
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2017-present, Yuxi (Evan) You
+> 
+> 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.
+
+---------------------------------------
+
+## lilconfig
+License: MIT
+By: antonk52
+Repository: https://github.com/antonk52/lilconfig
+
+> MIT License
+> 
+> Copyright (c) 2022 Anton Kastritskiy
+> 
+> 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.
+
+---------------------------------------
+
+## loader-utils
+License: MIT
+By: Tobias Koppers @sokra
+Repository: https://github.com/webpack/loader-utils
+
+> Copyright JS Foundation 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.
+
+---------------------------------------
+
+## lodash.camelcase
+License: MIT
+By: John-David Dalton, Blaine Bublitz, Mathias Bynens
+Repository: https://github.com/lodash/lodash
+
+> Copyright jQuery Foundation and other contributors <https://jquery.org/>
+> 
+> Based on Underscore.js, copyright Jeremy Ashkenas,
+> DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+> 
+> This software consists of voluntary contributions made by many
+> individuals. For exact contribution history, see the revision history
+> available at https://github.com/lodash/lodash
+> 
+> The following license applies to all parts of this software except as
+> documented below:
+> 
+> ====
+> 
+> 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.
+> 
+> ====
+> 
+> Copyright and related rights for sample code are waived via CC0. Sample
+> code is defined as all source code displayed within the prose of the
+> documentation.
+> 
+> CC0: http://creativecommons.org/publicdomain/zero/1.0/
+> 
+> ====
+> 
+> Files located in the node_modules and vendor directories are externally
+> maintained libraries used by this software which have their own
+> licenses; we recommend you read them, as their terms may differ from the
+> terms above.
+
+---------------------------------------
+
+## magic-string
+License: MIT
+By: Rich Harris
+Repository: https://github.com/Rich-Harris/magic-string
+
+> Copyright 2018 Rich Harris
+> 
+> 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.
+
+---------------------------------------
+
+## mlly, ufo
+License: MIT
+Repositories: https://github.com/unjs/mlly, https://github.com/unjs/ufo
+
+> MIT License
+> 
+> Copyright (c) Pooya Parsa <pooya@pi0.io>
+> 
+> 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.
+
+---------------------------------------
+
+## mrmime
+License: MIT
+By: Luke Edwards
+Repository: https://github.com/lukeed/mrmime
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (https://lukeed.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.
+
+---------------------------------------
+
+## normalize-path
+License: MIT
+By: Jon Schlinkert, Blaine Bublitz
+Repository: https://github.com/jonschlinkert/normalize-path
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2018, Jon Schlinkert.
+> 
+> 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.
+
+---------------------------------------
+
+## object-assign
+License: MIT
+By: Sindre Sorhus
+Repository: https://github.com/sindresorhus/object-assign
+
+> The MIT License (MIT)
+> 
+> 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.
+
+---------------------------------------
+
+## obug
+License: MIT
+By: Kevin Deng
+Repository: https://github.com/sxzz/obug
+
+> The MIT License (MIT)
+> 
+> Copyright © 2025-PRESENT Kevin Deng (https://github.com/sxzz)
+> Copyright (c) 2014-2017 TJ Holowaychuk <tj@vision-media.ca>
+> Copyright (c) 2018-2021 Josh Junon
+> 
+> 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.
+
+---------------------------------------
+
+## on-finished
+License: MIT
+By: Douglas Christopher Wilson, Jonathan Ong
+Repository: https://github.com/jshttp/on-finished
+
+> (The MIT License)
+> 
+> Copyright (c) 2013 Jonathan Ong <me@jongleberry.com>
+> Copyright (c) 2014 Douglas Christopher Wilson <doug@somethingdoug.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.
+
+---------------------------------------
+
+## parse5
+License: MIT
+By: Ivan Nikulin, James Garbutt, Felix Boehm, Titus
+Repository: https://github.com/inikulin/parse5
+
+> Copyright (c) 2013-2019 Ivan Nikulin (ifaaan@gmail.com, https://github.com/inikulin)
+> 
+> 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.
+
+---------------------------------------
+
+## parseurl
+License: MIT
+By: Douglas Christopher Wilson, Jonathan Ong
+Repository: https://github.com/pillarjs/parseurl
+
+> (The MIT License)
+> 
+> Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+> Copyright (c) 2014-2017 Douglas Christopher Wilson <doug@somethingdoug.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.
+
+---------------------------------------
+
+## path-key, shebang-regex
+License: MIT
+By: Sindre Sorhus
+Repositories: https://github.com/sindresorhus/path-key, https://github.com/sindresorhus/shebang-regex
+
+> 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.
+
+---------------------------------------
+
+## periscopic
+License: MIT
+Repository: https://github.com/Rich-Harris/periscopic
+
+> Copyright (c) 2019 Rich Harris
+> 
+> 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.
+
+---------------------------------------
+
+## picocolors
+License: ISC
+By: Alexey Raspopov
+Repository: https://github.com/alexeyraspopov/picocolors
+
+> ISC License
+> 
+> Copyright (c) 2021-2024 Oleksii Raspopov, Kostiantyn Denysov, Anton Verinov
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+> OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## postcss-import
+License: MIT
+By: Maxime Thirouin
+Repository: https://github.com/postcss/postcss-import
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014 Maxime Thirouin, Jason Campbell & Kevin Mårtensson
+> 
+> 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.
+
+---------------------------------------
+
+## postcss-load-config
+License: MIT
+By: Michael Ciniawky, Ryan Dunckel, Mateusz Derks, Dalton Santos, Patrick Gilday, François Wouts
+Repository: https://github.com/postcss/postcss-load-config
+
+> The MIT License (MIT)
+> 
+> Copyright Michael Ciniawsky <michael.ciniawsky@gmail.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.
+
+---------------------------------------
+
+## postcss-modules
+License: MIT
+By: Alexander Madyankin
+Repository: https://github.com/css-modules/postcss-modules
+
+> The MIT License (MIT)
+> 
+> Copyright 2015-present Alexander Madyankin <alexander@madyankin.name>
+> 
+> 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.
+
+---------------------------------------
+
+## postcss-modules-extract-imports
+License: ISC
+By: Glen Maddern
+Repository: https://github.com/css-modules/postcss-modules-extract-imports
+
+> Copyright 2015 Glen Maddern
+> 
+> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## postcss-modules-local-by-default
+License: MIT
+By: Mark Dalgleish
+Repository: https://github.com/css-modules/postcss-modules-local-by-default
+
+> The MIT License (MIT)
+> 
+> Copyright 2015 Mark Dalgleish <mark.john.dalgleish@gmail.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.
+
+---------------------------------------
+
+## postcss-modules-scope
+License: ISC
+By: Glen Maddern
+Repository: https://github.com/css-modules/postcss-modules-scope
+
+> ISC License (ISC)
+> 
+> Copyright (c) 2015, Glen Maddern
+> 
+> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## postcss-modules-values
+License: ISC
+By: Glen Maddern
+Repository: https://github.com/css-modules/postcss-modules-values
+
+> ISC License (ISC)
+> 
+> Copyright (c) 2015, Glen Maddern
+> 
+> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## postcss-selector-parser
+License: MIT
+By: Ben Briggs, Chris Eppstein
+Repository: https://github.com/postcss/postcss-selector-parser
+
+> Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+> 
+> 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.
+
+---------------------------------------
+
+## postcss-value-parser
+License: MIT
+By: Bogdan Chadkin
+Repository: https://github.com/TrySound/postcss-value-parser
+
+> Copyright (c) Bogdan Chadkin <trysound@yandex.ru>
+> 
+> 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.
+
+---------------------------------------
+
+## readdirp
+License: MIT
+By: Thorsten Lorenz, Paul Miller
+Repository: https://github.com/paulmillr/readdirp
+
+> MIT License
+> 
+> Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.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.
+
+---------------------------------------
+
+## resolve.exports, totalist
+License: MIT
+By: Luke Edwards
+Repositories: https://github.com/lukeed/resolve.exports, https://github.com/lukeed/totalist
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.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.
+
+---------------------------------------
+
+## shebang-command
+License: MIT
+By: Kevin Mårtensson
+Repository: https://github.com/kevva/shebang-command
+
+> MIT License
+> 
+> Copyright (c) Kevin Mårtensson <kevinmartensson@gmail.com> (github.com/kevva)
+> 
+> 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.
+
+---------------------------------------
+
+## shell-quote
+License: MIT
+By: James Halliday
+Repository: http://github.com/ljharb/shell-quote
+
+> The MIT License
+> 
+> Copyright (c) 2013 James Halliday (mail@substack.net)
+> 
+> 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.
+
+---------------------------------------
+
+## sirv
+License: MIT
+By: Luke Edwards
+Repository: https://github.com/lukeed/sirv
+
+---------------------------------------
+
+## statuses
+License: MIT
+By: Douglas Christopher Wilson, Jonathan Ong
+Repository: https://github.com/jshttp/statuses
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+> Copyright (c) 2016 Douglas Christopher Wilson <doug@somethingdoug.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.
+
+---------------------------------------
+
+## string-hash
+License: CC0-1.0
+By: The Dark Sky Company
+Repository: https://github.com/darkskyapp/string-hash
+
+---------------------------------------
+
+## strip-literal
+License: MIT
+By: Anthony Fu
+Repository: https://github.com/antfu/strip-literal
+
+> MIT License
+> 
+> Copyright (c) 2022 Anthony Fu <https://github.com/antfu>
+> 
+> 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.
+
+---------------------------------------
+
+## to-regex-range
+License: MIT
+By: Jon Schlinkert, Rouven Weßling
+Repository: https://github.com/micromatch/to-regex-range
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2015-present, Jon Schlinkert.
+> 
+> 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.
+
+---------------------------------------
+
+## unpipe
+License: MIT
+By: Douglas Christopher Wilson
+Repository: https://github.com/stream-utils/unpipe
+
+> (The MIT License)
+> 
+> Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.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.
+
+---------------------------------------
+
+## util-deprecate
+License: MIT
+By: Nathan Rajlich
+Repository: https://github.com/TooTallNate/util-deprecate
+
+> (The MIT License)
+> 
+> Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
+> 
+> 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.
+
+---------------------------------------
+
+## utils-merge
+License: MIT
+By: Jared Hanson
+Repository: https://github.com/jaredhanson/utils-merge
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2013-2017 Jared Hanson
+> 
+> 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.
+
+---------------------------------------
+
+## vary
+License: MIT
+By: Douglas Christopher Wilson
+Repository: https://github.com/jshttp/vary
+
+> (The MIT License)
+> 
+> Copyright (c) 2014-2017 Douglas Christopher Wilson
+> 
+> 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.
+
+---------------------------------------
+
+## ws
+License: MIT
+By: Einar Otto Stangvik
+Repository: https://github.com/websockets/ws
+
+> Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+> Copyright (c) 2013 Arnout Kazemier and contributors
+> Copyright (c) 2016 Luigi Pinca and 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.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/README.md b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/README.md
new file mode 100644
index 0000000..1460e75
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/README.md
@@ -0,0 +1,20 @@
+# Vite ⚡
+
+> Next Generation Frontend Tooling
+
+- 💡 Instant Server Start
+- ⚡️ Lightning Fast HMR
+- 🛠️ Rich Features
+- 📦 Optimized Build
+- 🔩 Universal Plugin Interface
+- 🔑 Fully Typed APIs
+
+Vite (French word for "quick", pronounced [`/viːt/`](https://cdn.jsdelivr.net/gh/vitejs/vite@main/docs/public/vite.mp3), like "veet") is a build tool that aims to provide a faster and leaner development experience for modern web projects. It consists of two major parts:
+
+- A dev server that provides [rich feature enhancements](https://vite.dev/guide/features) over [native ES modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), for example extremely fast [Hot Module Replacement (HMR)](https://vite.dev/guide/features#hot-module-replacement).
+
+- A build command that bundles your code with [Rolldown](https://rolldown.rs), pre-configured to output highly optimized static assets for production.
+
+In addition, Vite is highly extensible via its [Plugin API](https://vite.dev/guide/api-plugin.html) and [JavaScript API](https://vite.dev/guide/api-javascript.html) with full typing support.
+
+[Read the Docs to Learn More](https://vite.dev).
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/bin/openChrome.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/bin/openChrome.js
new file mode 100644
index 0000000..5a4aa95
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/bin/openChrome.js
@@ -0,0 +1,68 @@
+/*
+Copyright (c) 2015-present, Facebook, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file at
+https://github.com/facebook/create-react-app/blob/main/LICENSE
+*/
+
+/* global Application */
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function run(argv) {
+  const urlToOpen = argv[0]
+  // Allow requested program to be optional, default to Google Chrome
+  const programName = argv[1] ?? 'Google Chrome'
+
+  const app = Application(programName)
+
+  if (app.windows.length === 0) {
+    app.Window().make()
+  }
+
+  // 1: Looking for tab running debugger then,
+  //    Reload debugging tab if found, then return
+  const found = lookupTabWithUrl(urlToOpen, app)
+  if (found) {
+    found.targetWindow.activeTabIndex = found.targetTabIndex
+    found.targetTab.reload()
+    found.targetWindow.index = 1
+    app.activate()
+    return
+  }
+
+  // 2: Looking for Empty tab
+  //    In case debugging tab was not found
+  //    We try to find an empty tab instead
+  const emptyTabFound = lookupTabWithUrl('chrome://newtab/', app)
+  if (emptyTabFound) {
+    emptyTabFound.targetWindow.activeTabIndex = emptyTabFound.targetTabIndex
+    emptyTabFound.targetTab.url = urlToOpen
+    app.activate()
+    return
+  }
+
+  // 3: Create new tab
+  //    both debugging and empty tab were not found make a new tab with url
+  const firstWindow = app.windows[0]
+  firstWindow.tabs.push(app.Tab({ url: urlToOpen }))
+  app.activate()
+}
+
+/**
+ * Lookup tab with given url
+ */
+function lookupTabWithUrl(lookupUrl, app) {
+  const windows = app.windows()
+  for (const window of windows) {
+    for (const [tabIndex, tab] of window.tabs().entries()) {
+      if (tab.url().includes(lookupUrl)) {
+        return {
+          targetTab: tab,
+          targetTabIndex: tabIndex + 1,
+          targetWindow: window,
+        }
+      }
+    }
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/bin/vite.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/bin/vite.js
new file mode 100644
index 0000000..79c49ab
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/bin/vite.js
@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { performance } from 'node:perf_hooks'
+import module from 'node:module'
+
+if (!import.meta.url.includes('node_modules')) {
+  if (!process.env.DEBUG_DISABLE_SOURCE_MAP) {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins -- only used in dev
+    process.setSourceMapsEnabled(true)
+  }
+
+  process.on('unhandledRejection', (err) => {
+    throw new Error('UNHANDLED PROMISE REJECTION', { cause: err })
+  })
+}
+
+global.__vite_start_time = performance.now()
+
+// check debug mode first before requiring the CLI.
+const debugIndex = process.argv.findIndex((arg) => /^(?:-d|--debug)$/.test(arg))
+const filterIndex = process.argv.findIndex((arg) =>
+  /^(?:-f|--filter)$/.test(arg),
+)
+const profileIndex = process.argv.indexOf('--profile')
+
+if (debugIndex > 0) {
+  let value = process.argv[debugIndex + 1]
+  if (!value || value[0] === '-') {
+    value = 'vite:*'
+  } else {
+    // support debugging multiple flags with comma-separated list
+    value = value
+      .split(',')
+      .map((v) => `vite:${v}`)
+      .join(',')
+  }
+  process.env.DEBUG = `${
+    process.env.DEBUG ? process.env.DEBUG + ',' : ''
+  }${value}`
+
+  if (filterIndex > 0) {
+    const filter = process.argv[filterIndex + 1]
+    if (filter && filter[0] !== '-') {
+      process.env.VITE_DEBUG_FILTER = filter
+    }
+  }
+}
+
+function start() {
+  try {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it is supported in Node 22.8.0+ and only called if it exists
+    module.enableCompileCache?.()
+    // flush the cache after 10s because the cache is not flushed until process end
+    // for dev server, the cache is never flushed unless manually flushed because the process.exit is called
+    // also flushing the cache in SIGINT handler seems to cause the process to hang
+    setTimeout(() => {
+      try {
+        // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it is supported in Node 22.12.0+ and only called if it exists
+        module.flushCompileCache?.()
+      } catch {}
+    }, 10 * 1000).unref()
+  } catch {}
+  return import('../dist/node/cli.js')
+}
+
+if (profileIndex > 0) {
+  process.argv.splice(profileIndex, 1)
+  const next = process.argv[profileIndex]
+  if (next && next[0] !== '-') {
+    process.argv.splice(profileIndex, 1)
+  }
+  const inspector = await import('node:inspector').then((r) => r.default)
+  const session = (global.__vite_profile_session = new inspector.Session())
+  session.connect()
+  session.post('Profiler.enable', () => {
+    session.post('Profiler.start', start)
+  })
+} else {
+  start()
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/client.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/client.d.ts
new file mode 100644
index 0000000..e807d61
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/client.d.ts
@@ -0,0 +1,282 @@
+/// <reference path="./types/importMeta.d.ts" />
+
+// virtual modules
+declare module 'vite/modulepreload-polyfill' {}
+
+// CSS modules
+type CSSModuleClasses = { readonly [key: string]: string }
+
+declare module '*.module.css' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.scss' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.sass' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.less' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.styl' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.stylus' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.pcss' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.sss' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+
+// CSS
+declare module '*.css' {}
+declare module '*.scss' {}
+declare module '*.sass' {}
+declare module '*.less' {}
+declare module '*.styl' {}
+declare module '*.stylus' {}
+declare module '*.pcss' {}
+declare module '*.sss' {}
+
+// Built-in asset types
+// see `src/node/constants.ts`
+
+// images
+declare module '*.apng' {
+  const src: string
+  export default src
+}
+declare module '*.bmp' {
+  const src: string
+  export default src
+}
+declare module '*.png' {
+  const src: string
+  export default src
+}
+declare module '*.jpg' {
+  const src: string
+  export default src
+}
+declare module '*.jpeg' {
+  const src: string
+  export default src
+}
+declare module '*.jfif' {
+  const src: string
+  export default src
+}
+declare module '*.pjpeg' {
+  const src: string
+  export default src
+}
+declare module '*.pjp' {
+  const src: string
+  export default src
+}
+declare module '*.gif' {
+  const src: string
+  export default src
+}
+declare module '*.svg' {
+  const src: string
+  export default src
+}
+declare module '*.ico' {
+  const src: string
+  export default src
+}
+declare module '*.webp' {
+  const src: string
+  export default src
+}
+declare module '*.avif' {
+  const src: string
+  export default src
+}
+declare module '*.cur' {
+  const src: string
+  export default src
+}
+declare module '*.jxl' {
+  const src: string
+  export default src
+}
+
+// media
+declare module '*.mp4' {
+  const src: string
+  export default src
+}
+declare module '*.webm' {
+  const src: string
+  export default src
+}
+declare module '*.ogg' {
+  const src: string
+  export default src
+}
+declare module '*.mp3' {
+  const src: string
+  export default src
+}
+declare module '*.wav' {
+  const src: string
+  export default src
+}
+declare module '*.flac' {
+  const src: string
+  export default src
+}
+declare module '*.aac' {
+  const src: string
+  export default src
+}
+declare module '*.opus' {
+  const src: string
+  export default src
+}
+declare module '*.mov' {
+  const src: string
+  export default src
+}
+declare module '*.m4a' {
+  const src: string
+  export default src
+}
+declare module '*.vtt' {
+  const src: string
+  export default src
+}
+
+// fonts
+declare module '*.woff' {
+  const src: string
+  export default src
+}
+declare module '*.woff2' {
+  const src: string
+  export default src
+}
+declare module '*.eot' {
+  const src: string
+  export default src
+}
+declare module '*.ttf' {
+  const src: string
+  export default src
+}
+declare module '*.otf' {
+  const src: string
+  export default src
+}
+
+// other
+declare module '*.webmanifest' {
+  const src: string
+  export default src
+}
+declare module '*.pdf' {
+  const src: string
+  export default src
+}
+declare module '*.txt' {
+  const src: string
+  export default src
+}
+
+// wasm?init
+declare module '*.wasm?init' {
+  const initWasm: (
+    options?: WebAssembly.Imports,
+  ) => Promise<WebAssembly.Instance>
+  export default initWasm
+}
+
+// web worker
+declare module '*?worker' {
+  const workerConstructor: {
+    new (options?: { name?: string }): Worker
+  }
+  export default workerConstructor
+}
+
+declare module '*?worker&inline' {
+  const workerConstructor: {
+    new (options?: { name?: string }): Worker
+  }
+  export default workerConstructor
+}
+
+declare module '*?worker&url' {
+  const src: string
+  export default src
+}
+
+declare module '*?sharedworker' {
+  const sharedWorkerConstructor: {
+    new (options?: { name?: string }): SharedWorker
+  }
+  export default sharedWorkerConstructor
+}
+
+declare module '*?sharedworker&inline' {
+  const sharedWorkerConstructor: {
+    new (options?: { name?: string }): SharedWorker
+  }
+  export default sharedWorkerConstructor
+}
+
+declare module '*?sharedworker&url' {
+  const src: string
+  export default src
+}
+
+declare module '*?raw' {
+  const src: string
+  export default src
+}
+
+declare module '*?url' {
+  const src: string
+  export default src
+}
+
+declare module '*?inline' {
+  const src: string
+  export default src
+}
+
+declare module '*?no-inline' {
+  const src: string
+  export default src
+}
+
+declare module '*?url&inline' {
+  const src: string
+  export default src
+}
+
+declare module '*?url&no-inline' {
+  const src: string
+  export default src
+}
+
+declare interface VitePreloadErrorEvent extends Event {
+  payload: Error
+}
+
+declare interface WindowEventMap {
+  'vite:preloadError': VitePreloadErrorEvent
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/client/client.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/client/client.mjs
new file mode 100644
index 0000000..943d56c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/client/client.mjs
@@ -0,0 +1,1247 @@
+import "@vite/env";
+//#region ../../node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/non-secure/index.js
+let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+let nanoid = (size = 21) => {
+	let id = "";
+	let i = size | 0;
+	while (i--) id += urlAlphabet[Math.random() * 64 | 0];
+	return id;
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.130.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.130.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.130.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.130.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/shared/hmr.ts
+var HMRContext = class {
+	constructor(hmrClient, ownerPath) {
+		this.hmrClient = hmrClient;
+		this.ownerPath = ownerPath;
+		_defineProperty(this, "newListeners", void 0);
+		if (!hmrClient.dataMap.has(ownerPath)) hmrClient.dataMap.set(ownerPath, {});
+		const mod = hmrClient.hotModulesMap.get(ownerPath);
+		if (mod) mod.callbacks = [];
+		const staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+		if (staleListeners) for (const [event, staleFns] of staleListeners) {
+			const listeners = hmrClient.customListenersMap.get(event);
+			if (listeners) hmrClient.customListenersMap.set(event, listeners.filter((l) => !staleFns.includes(l)));
+		}
+		this.newListeners = /* @__PURE__ */ new Map();
+		hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+	}
+	get data() {
+		return this.hmrClient.dataMap.get(this.ownerPath);
+	}
+	accept(deps, callback) {
+		if (typeof deps === "function" || !deps) this.acceptDeps([this.ownerPath], ([mod]) => deps?.(mod));
+		else if (typeof deps === "string") this.acceptDeps([deps], ([mod]) => callback?.(mod));
+		else if (Array.isArray(deps)) this.acceptDeps(deps, callback);
+		else throw new Error(`invalid hot.accept() usage.`);
+	}
+	acceptExports(_, callback) {
+		this.acceptDeps([this.ownerPath], ([mod]) => callback?.(mod));
+	}
+	dispose(cb) {
+		this.hmrClient.disposeMap.set(this.ownerPath, cb);
+	}
+	prune(cb) {
+		this.hmrClient.pruneMap.set(this.ownerPath, cb);
+	}
+	decline() {}
+	invalidate(message) {
+		const firstInvalidatedBy = this.hmrClient.currentFirstInvalidatedBy ?? this.ownerPath;
+		this.hmrClient.notifyListeners("vite:invalidate", {
+			path: this.ownerPath,
+			message,
+			firstInvalidatedBy
+		});
+		this.send("vite:invalidate", {
+			path: this.ownerPath,
+			message,
+			firstInvalidatedBy
+		});
+		this.hmrClient.logger.debug(`invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`);
+	}
+	on(event, cb) {
+		const addToMap = (map) => {
+			const existing = map.get(event) || [];
+			existing.push(cb);
+			map.set(event, existing);
+		};
+		addToMap(this.hmrClient.customListenersMap);
+		addToMap(this.newListeners);
+	}
+	off(event, cb) {
+		const removeFromMap = (map) => {
+			const existing = map.get(event);
+			if (existing === void 0) return;
+			const pruned = existing.filter((l) => l !== cb);
+			if (pruned.length === 0) {
+				map.delete(event);
+				return;
+			}
+			map.set(event, pruned);
+		};
+		removeFromMap(this.hmrClient.customListenersMap);
+		removeFromMap(this.newListeners);
+	}
+	send(event, data) {
+		this.hmrClient.send({
+			type: "custom",
+			event,
+			data
+		});
+	}
+	acceptDeps(deps, callback = () => {}) {
+		const mod = this.hmrClient.hotModulesMap.get(this.ownerPath) || {
+			id: this.ownerPath,
+			callbacks: []
+		};
+		mod.callbacks.push({
+			deps,
+			fn: callback
+		});
+		this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
+	}
+};
+var HMRClient = class {
+	constructor(logger, transport, importUpdatedModule) {
+		this.logger = logger;
+		this.transport = transport;
+		this.importUpdatedModule = importUpdatedModule;
+		_defineProperty(this, "hotModulesMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "disposeMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "pruneMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "dataMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "customListenersMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "ctxToListenersMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "currentFirstInvalidatedBy", void 0);
+		_defineProperty(this, "updateQueue", []);
+		_defineProperty(this, "pendingUpdateQueue", false);
+	}
+	async notifyListeners(event, data) {
+		const cbs = this.customListenersMap.get(event);
+		if (cbs) await Promise.allSettled(cbs.map((cb) => cb(data)));
+	}
+	send(payload) {
+		this.transport.send(payload).catch((err) => {
+			this.logger.error(err);
+		});
+	}
+	clear() {
+		this.hotModulesMap.clear();
+		this.disposeMap.clear();
+		this.pruneMap.clear();
+		this.dataMap.clear();
+		this.customListenersMap.clear();
+		this.ctxToListenersMap.clear();
+	}
+	async prunePaths(paths) {
+		await Promise.all(paths.map((path) => {
+			const disposer = this.disposeMap.get(path);
+			if (disposer) return disposer(this.dataMap.get(path));
+		}));
+		await Promise.all(paths.map((path) => {
+			const fn = this.pruneMap.get(path);
+			if (fn) return fn(this.dataMap.get(path));
+		}));
+	}
+	warnFailedUpdate(err, path) {
+		if (!(err instanceof Error) || !err.message.includes("fetch")) this.logger.error(err);
+		this.logger.error(`Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
+	}
+	/**
+	* buffer multiple hot updates triggered by the same src change
+	* so that they are invoked in the same order they were sent.
+	* (otherwise the order may be inconsistent because of the http request round trip)
+	*/
+	async queueUpdate(payload) {
+		this.updateQueue.push(this.fetchUpdate(payload));
+		if (!this.pendingUpdateQueue) {
+			this.pendingUpdateQueue = true;
+			await Promise.resolve();
+			this.pendingUpdateQueue = false;
+			const loading = [...this.updateQueue];
+			this.updateQueue = [];
+			(await Promise.all(loading)).forEach((fn) => fn && fn());
+		}
+	}
+	async fetchUpdate(update) {
+		const { path, acceptedPath, firstInvalidatedBy } = update;
+		const mod = this.hotModulesMap.get(path);
+		if (!mod) return;
+		let fetchedModule;
+		const isSelfUpdate = path === acceptedPath;
+		const qualifiedCallbacks = mod.callbacks.filter(({ deps }) => deps.includes(acceptedPath));
+		if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+			const disposer = this.disposeMap.get(acceptedPath);
+			if (disposer) await disposer(this.dataMap.get(acceptedPath));
+			try {
+				fetchedModule = await this.importUpdatedModule(update);
+			} catch (e) {
+				this.warnFailedUpdate(e, acceptedPath);
+			}
+		}
+		return () => {
+			try {
+				this.currentFirstInvalidatedBy = firstInvalidatedBy;
+				for (const { deps, fn } of qualifiedCallbacks) fn(deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0));
+				const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+				this.logger.debug(`hot updated: ${loggedPath}`);
+			} finally {
+				this.currentFirstInvalidatedBy = void 0;
+			}
+		};
+	}
+};
+//#endregion
+//#region src/shared/constants.ts
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+typeof process !== "undefined" && process.platform;
+(async function() {}).constructor;
+function promiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((_resolve, _reject) => {
+			resolve = _resolve;
+			reject = _reject;
+		}),
+		resolve,
+		reject
+	};
+}
+//#endregion
+//#region src/shared/moduleRunnerTransport.ts
+function reviveInvokeError(e) {
+	const error = new Error(e.message || "Unknown invoke error");
+	Object.assign(error, e, { runnerError: /* @__PURE__ */ new Error("RunnerError") });
+	return error;
+}
+const createInvokeableTransport = (transport) => {
+	if (transport.invoke) return {
+		...transport,
+		async invoke(name, data) {
+			const result = await transport.invoke({
+				type: "custom",
+				event: "vite:invoke",
+				data: {
+					id: "send",
+					name,
+					data
+				}
+			});
+			if ("error" in result) throw reviveInvokeError(result.error);
+			return result.result;
+		}
+	};
+	if (!transport.send || !transport.connect) throw new Error("transport must implement send and connect when invoke is not implemented");
+	const rpcPromises = /* @__PURE__ */ new Map();
+	return {
+		...transport,
+		connect({ onMessage, onDisconnection }) {
+			return transport.connect({
+				onMessage(payload) {
+					if (payload.type === "custom" && payload.event === "vite:invoke") {
+						const data = payload.data;
+						if (data.id.startsWith("response:")) {
+							const invokeId = data.id.slice(9);
+							const promise = rpcPromises.get(invokeId);
+							if (!promise) return;
+							if (promise.timeoutId) clearTimeout(promise.timeoutId);
+							rpcPromises.delete(invokeId);
+							const { error, result } = data.data;
+							if (error) promise.reject(error);
+							else promise.resolve(result);
+							return;
+						}
+					}
+					onMessage(payload);
+				},
+				onDisconnection
+			});
+		},
+		disconnect() {
+			rpcPromises.forEach((promise) => {
+				promise.reject(/* @__PURE__ */ new Error(`transport was disconnected, cannot call ${JSON.stringify(promise.name)}`));
+			});
+			rpcPromises.clear();
+			return transport.disconnect?.();
+		},
+		send(data) {
+			return transport.send(data);
+		},
+		async invoke(name, data) {
+			const promiseId = nanoid();
+			const wrappedData = {
+				type: "custom",
+				event: "vite:invoke",
+				data: {
+					name,
+					id: `send:${promiseId}`,
+					data
+				}
+			};
+			const sendPromise = transport.send(wrappedData);
+			const { promise, resolve, reject } = promiseWithResolvers();
+			const timeout = transport.timeout ?? 6e4;
+			let timeoutId;
+			if (timeout > 0) {
+				timeoutId = setTimeout(() => {
+					rpcPromises.delete(promiseId);
+					reject(/* @__PURE__ */ new Error(`transport invoke timed out after ${timeout}ms (data: ${JSON.stringify(wrappedData)})`));
+				}, timeout);
+				timeoutId?.unref?.();
+			}
+			rpcPromises.set(promiseId, {
+				resolve,
+				reject,
+				name,
+				timeoutId
+			});
+			if (sendPromise) sendPromise.catch((err) => {
+				clearTimeout(timeoutId);
+				rpcPromises.delete(promiseId);
+				reject(err);
+			});
+			try {
+				return await promise;
+			} catch (err) {
+				throw reviveInvokeError(err);
+			}
+		}
+	};
+};
+const normalizeModuleRunnerTransport = (transport) => {
+	const invokeableTransport = createInvokeableTransport(transport);
+	let isConnected = !invokeableTransport.connect;
+	let connectingPromise;
+	return {
+		...transport,
+		...invokeableTransport.connect ? { async connect(onMessage) {
+			if (isConnected) return;
+			if (connectingPromise) {
+				await connectingPromise;
+				return;
+			}
+			const maybePromise = invokeableTransport.connect({
+				onMessage: onMessage ?? (() => {}),
+				onDisconnection() {
+					isConnected = false;
+				}
+			});
+			if (maybePromise) {
+				connectingPromise = maybePromise;
+				await connectingPromise;
+				connectingPromise = void 0;
+			}
+			isConnected = true;
+		} } : {},
+		...invokeableTransport.disconnect ? { async disconnect() {
+			if (!isConnected) return;
+			if (connectingPromise) await connectingPromise;
+			isConnected = false;
+			await invokeableTransport.disconnect();
+		} } : {},
+		async send(data) {
+			if (!invokeableTransport.send) return;
+			if (!isConnected) if (connectingPromise) await connectingPromise;
+			else throw new Error("send was called before connect");
+			await invokeableTransport.send(data);
+		},
+		async invoke(name, data) {
+			if (!isConnected) if (connectingPromise) await connectingPromise;
+			else throw new Error("invoke was called before connect");
+			return invokeableTransport.invoke(name, data);
+		}
+	};
+};
+const createWebSocketModuleRunnerTransport = (options) => {
+	const pingInterval = options.pingInterval ?? 3e4;
+	let ws;
+	let pingIntervalId;
+	return {
+		async connect({ onMessage, onDisconnection }) {
+			const socket = options.createConnection();
+			socket.addEventListener("message", ({ data }) => {
+				onMessage(JSON.parse(data));
+			});
+			let isOpened = socket.readyState === socket.OPEN;
+			if (!isOpened) await new Promise((resolve, reject) => {
+				socket.addEventListener("open", () => {
+					isOpened = true;
+					resolve();
+				}, { once: true });
+				socket.addEventListener("close", () => {
+					if (!isOpened) {
+						reject(/* @__PURE__ */ new Error("WebSocket closed without opened."));
+						return;
+					}
+					onMessage({
+						type: "custom",
+						event: "vite:ws:disconnect",
+						data: { webSocket: socket }
+					});
+					onDisconnection();
+				});
+			});
+			onMessage({
+				type: "custom",
+				event: "vite:ws:connect",
+				data: { webSocket: socket }
+			});
+			ws = socket;
+			pingIntervalId = setInterval(() => {
+				if (socket.readyState === socket.OPEN) socket.send(JSON.stringify({ type: "ping" }));
+			}, pingInterval);
+		},
+		disconnect() {
+			clearInterval(pingIntervalId);
+			ws?.close();
+		},
+		send(data) {
+			ws.send(JSON.stringify(data));
+		}
+	};
+};
+//#endregion
+//#region src/shared/hmrHandler.ts
+function createHMRHandler(handler) {
+	const queue = new Queue();
+	return (payload) => queue.enqueue(() => handler(payload));
+}
+var Queue = class {
+	constructor() {
+		_defineProperty(this, "queue", []);
+		_defineProperty(this, "pending", false);
+	}
+	enqueue(promise) {
+		return new Promise((resolve, reject) => {
+			this.queue.push({
+				promise,
+				resolve,
+				reject
+			});
+			this.dequeue();
+		});
+	}
+	dequeue() {
+		if (this.pending) return false;
+		const item = this.queue.shift();
+		if (!item) return false;
+		this.pending = true;
+		item.promise().then(item.resolve).catch(item.reject).finally(() => {
+			this.pending = false;
+			this.dequeue();
+		});
+		return true;
+	}
+};
+//#endregion
+//#region src/shared/forwardConsole.ts
+function setupForwardConsoleHandler(transport, options) {
+	if (!options.enabled) return;
+	function sendError(type, error) {
+		transport.send({
+			type: "custom",
+			event: "vite:forward-console",
+			data: {
+				type,
+				data: {
+					name: error?.name || "Unknown Error",
+					message: error?.message || String(error),
+					stack: error?.stack
+				}
+			}
+		});
+	}
+	function sendLog(level, args) {
+		transport.send({
+			type: "custom",
+			event: "vite:forward-console",
+			data: {
+				type: "log",
+				data: {
+					level,
+					message: formatConsoleArgs(args)
+				}
+			}
+		});
+	}
+	for (const level of options.logLevels) {
+		const original = console[level];
+		if (typeof original !== "function") continue;
+		console[level] = (...args) => {
+			original(...args);
+			sendLog(level, args);
+		};
+	}
+	if (options.unhandledErrors && typeof window !== "undefined") {
+		window.addEventListener("error", (event) => {
+			sendError("error", event.error ?? (event.message ? new Error(event.message) : event));
+		});
+		window.addEventListener("unhandledrejection", (event) => {
+			sendError("unhandled-rejection", event.reason);
+		});
+	}
+}
+function formatConsoleArgs(args) {
+	if (args.length === 0) return "";
+	if (typeof args[0] !== "string") return args.map((arg) => stringifyConsoleArg(arg)).join(" ");
+	const len = args.length;
+	let i = 1;
+	let message = args[0].replace(/%[sdjifoOc%]/g, (specifier) => {
+		if (specifier === "%%") return "%";
+		if (i >= len) return specifier;
+		const arg = args[i++];
+		switch (specifier) {
+			case "%s":
+				if (typeof arg === "bigint") return `${arg.toString()}n`;
+				return typeof arg === "object" && arg != null ? stringifyConsoleArg(arg) : String(arg);
+			case "%d":
+				if (typeof arg === "bigint") return `${arg.toString()}n`;
+				if (typeof arg === "symbol") return "NaN";
+				return Number(arg).toString();
+			case "%i":
+				if (typeof arg === "bigint") return `${arg.toString()}n`;
+				return Number.parseInt(String(arg), 10).toString();
+			case "%f": return Number.parseFloat(String(arg)).toString();
+			case "%o":
+			case "%O": return stringifyConsoleArg(arg);
+			case "%j": try {
+				return JSON.stringify(arg) ?? "undefined";
+			} catch {
+				return "[Circular]";
+			}
+			case "%c": return "";
+			default: return specifier;
+		}
+	});
+	for (let arg = args[i]; i < len; arg = args[++i]) if (arg == null || typeof arg !== "object") message += ` ${typeof arg === "symbol" ? arg.toString() : String(arg)}`;
+	else message += ` ${stringifyConsoleArg(arg)}`;
+	return message;
+}
+function stringifyConsoleArg(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "undefined") return String(value);
+	if (typeof value === "symbol") return value.toString();
+	if (typeof value === "function") return value.name ? `[Function: ${value.name}]` : "[Function]";
+	if (value instanceof Error) return value.stack || `${value.name}: ${value.message}`;
+	if (typeof value === "bigint") return `${value}n`;
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		return JSON.stringify(value, (_, nested) => {
+			if (typeof nested === "bigint") return `${nested}n`;
+			if (nested instanceof Error) return {
+				name: nested.name,
+				message: nested.message,
+				stack: nested.stack
+			};
+			if (nested && typeof nested === "object") {
+				if (seen.has(nested)) return "[Circular]";
+				seen.add(nested);
+			}
+			return nested;
+		}) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+//#region src/client/overlay.ts
+const hmrConfigName = __HMR_CONFIG_NAME__;
+const base$1 = __BASE__ || "/";
+const cspNonce = "document" in globalThis ? document.querySelector("meta[property=csp-nonce]")?.nonce : void 0;
+function h(e, attrs = {}, ...children) {
+	const elem = document.createElement(e);
+	for (const [k, v] of Object.entries(attrs)) if (v !== void 0) elem.setAttribute(k, v);
+	elem.append(...children);
+	return elem;
+}
+const templateStyle = `
+:host {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 99999;
+  --monospace: 'SFMono-Regular', Consolas,
+  'Liberation Mono', Menlo, Courier, monospace;
+  --red: #ff5555;
+  --yellow: #e2aa53;
+  --purple: #cfa4ff;
+  --cyan: #2dd9da;
+  --dim: #c9c9c9;
+
+  --window-background: #181818;
+  --window-color: #d8d8d8;
+}
+
+.backdrop {
+  position: fixed;
+  z-index: 99999;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  overflow-y: scroll;
+  margin: 0;
+  background: rgba(0, 0, 0, 0.66);
+}
+
+.window {
+  font-family: var(--monospace);
+  line-height: 1.5;
+  max-width: 80vw;
+  color: var(--window-color);
+  box-sizing: border-box;
+  margin: 30px auto;
+  padding: 2.5vh 4vw;
+  position: relative;
+  background: var(--window-background);
+  border-radius: 6px 6px 8px 8px;
+  box-shadow: 0 19px 38px rgba(0,0,0,0.30), 0 15px 12px rgba(0,0,0,0.22);
+  overflow: hidden;
+  border-top: 8px solid var(--red);
+  direction: ltr;
+  text-align: left;
+}
+
+pre {
+  font-family: var(--monospace);
+  font-size: 16px;
+  margin-top: 0;
+  margin-bottom: 1em;
+  overflow-x: scroll;
+  scrollbar-width: none;
+}
+
+pre::-webkit-scrollbar {
+  display: none;
+}
+
+pre.frame::-webkit-scrollbar {
+  display: block;
+  height: 5px;
+}
+
+pre.frame::-webkit-scrollbar-thumb {
+  background: #999;
+  border-radius: 5px;
+}
+
+pre.frame {
+  scrollbar-width: thin;
+}
+
+.message {
+  line-height: 1.3;
+  font-weight: 600;
+  white-space: pre-wrap;
+}
+
+.message-body {
+  color: var(--red);
+}
+
+.plugin {
+  color: var(--purple);
+}
+
+.file {
+  color: var(--cyan);
+  margin-bottom: 0;
+  white-space: pre-wrap;
+  word-break: break-all;
+}
+
+.frame {
+  color: var(--yellow);
+}
+
+.stack {
+  font-size: 13px;
+  color: var(--dim);
+}
+
+.tip {
+  font-size: 13px;
+  color: #999;
+  border-top: 1px dotted #999;
+  padding-top: 13px;
+  line-height: 1.8;
+}
+
+code {
+  font-size: 13px;
+  font-family: var(--monospace);
+  color: var(--yellow);
+}
+
+.file-link {
+  text-decoration: underline;
+  cursor: pointer;
+}
+
+kbd {
+  line-height: 1.5;
+  font-family: ui-monospace, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  font-size: 0.75rem;
+  font-weight: 700;
+  background-color: rgb(38, 40, 44);
+  color: rgb(166, 167, 171);
+  padding: 0.15rem 0.3rem;
+  border-radius: 0.25rem;
+  border-width: 0.0625rem 0.0625rem 0.1875rem;
+  border-style: solid;
+  border-color: rgb(54, 57, 64);
+  border-image: initial;
+}
+`;
+const createTemplate = () => h("div", {
+	class: "backdrop",
+	part: "backdrop"
+}, h("div", {
+	class: "window",
+	part: "window"
+}, h("pre", {
+	class: "message",
+	part: "message"
+}, h("span", {
+	class: "plugin",
+	part: "plugin"
+}), h("span", {
+	class: "message-body",
+	part: "message-body"
+})), h("pre", {
+	class: "file",
+	part: "file"
+}), h("pre", {
+	class: "frame",
+	part: "frame"
+}), h("pre", {
+	class: "stack",
+	part: "stack"
+}), h("div", {
+	class: "tip",
+	part: "tip"
+}, "Click outside, press ", h("kbd", {}, "Esc"), " key, or fix the code to dismiss.", h("br"), "You can also disable this overlay by setting ", h("code", { part: "config-option-name" }, "server.hmr.overlay"), " to ", h("code", { part: "config-option-value" }, "false"), " in ", h("code", { part: "config-file-name" }, hmrConfigName), ".")), h("style", { nonce: cspNonce }, templateStyle));
+const fileRE = /(?:file:\/\/)?(?:[a-zA-Z]:\\|\/).*?:\d+:\d+/g;
+const codeframeRE = /^(?:>?\s*\d+\s+\|.*|\s+\|\s*\^.*)\r?\n/gm;
+const { HTMLElement = class {} } = globalThis;
+var ErrorOverlay = class extends HTMLElement {
+	constructor(err, links = true) {
+		super();
+		this.root = this.attachShadow({ mode: "open" });
+		this.root.appendChild(createTemplate());
+		codeframeRE.lastIndex = 0;
+		const hasFrame = err.frame && codeframeRE.test(err.frame);
+		const message = hasFrame ? err.message.replace(codeframeRE, "") : err.message;
+		if (err.plugin) this.text(".plugin", `[plugin:${err.plugin}] `);
+		this.text(".message-body", message.trim());
+		const [file] = (err.loc?.file || err.id || "unknown file").split(`?`);
+		if (err.loc) this.text(".file", `${file}:${err.loc.line}:${err.loc.column}`, links);
+		else if (err.id) this.text(".file", file);
+		if (hasFrame) this.text(".frame", err.frame.trim());
+		this.text(".stack", err.stack, links);
+		this.root.querySelector(".window").addEventListener("click", (e) => {
+			e.stopPropagation();
+		});
+		this.addEventListener("click", () => {
+			this.close();
+		});
+		this.closeOnEsc = (e) => {
+			if (e.key === "Escape" || e.code === "Escape") this.close();
+		};
+		document.addEventListener("keydown", this.closeOnEsc);
+	}
+	text(selector, text, linkFiles = false) {
+		const el = this.root.querySelector(selector);
+		if (!linkFiles) el.textContent = text;
+		else {
+			let curIndex = 0;
+			let match;
+			fileRE.lastIndex = 0;
+			while (match = fileRE.exec(text)) {
+				const { 0: file, index } = match;
+				const frag = text.slice(curIndex, index);
+				el.appendChild(document.createTextNode(frag));
+				const link = document.createElement("a");
+				link.textContent = file;
+				link.className = "file-link";
+				link.onclick = () => {
+					fetch(new URL(`${base$1}__open-in-editor?file=${encodeURIComponent(file)}`, import.meta.url));
+				};
+				el.appendChild(link);
+				curIndex += frag.length + file.length;
+			}
+			if (curIndex < text.length) el.appendChild(document.createTextNode(text.slice(curIndex)));
+		}
+	}
+	close() {
+		this.parentNode?.removeChild(this);
+		document.removeEventListener("keydown", this.closeOnEsc);
+	}
+};
+const overlayId = "vite-error-overlay";
+const { customElements } = globalThis;
+if (customElements && !customElements.get("vite-error-overlay")) customElements.define(overlayId, ErrorOverlay);
+//#endregion
+//#region src/client/client.ts
+console.debug("[vite] connecting...");
+const importMetaUrl = new URL(import.meta.url);
+const serverHost = __SERVER_HOST__;
+const socketProtocol = __HMR_PROTOCOL__ || (importMetaUrl.protocol === "https:" ? "wss" : "ws");
+const hmrPort = __HMR_PORT__;
+const socketHost = `${__HMR_HOSTNAME__ || importMetaUrl.hostname}:${hmrPort || importMetaUrl.port}${__HMR_BASE__}`;
+const directSocketHost = __HMR_DIRECT_TARGET__;
+const base = __BASE__ || "/";
+const hmrTimeout = __HMR_TIMEOUT__;
+const wsToken = __WS_TOKEN__;
+const isBundleMode = __BUNDLED_DEV__;
+const forwardConsole = __SERVER_FORWARD_CONSOLE__;
+const transport = normalizeModuleRunnerTransport((() => {
+	let wsTransport = createWebSocketModuleRunnerTransport({
+		createConnection: () => new WebSocket(`${socketProtocol}://${socketHost}?token=${wsToken}`, "vite-hmr"),
+		pingInterval: hmrTimeout
+	});
+	return {
+		async connect(handlers) {
+			try {
+				await wsTransport.connect(handlers);
+			} catch (e) {
+				if (!hmrPort) {
+					wsTransport = createWebSocketModuleRunnerTransport({
+						createConnection: () => new WebSocket(`${socketProtocol}://${directSocketHost}?token=${wsToken}`, "vite-hmr"),
+						pingInterval: hmrTimeout
+					});
+					try {
+						await wsTransport.connect(handlers);
+						console.info("[vite] Direct websocket connection fallback. Check out https://vite.dev/config/server-options.html#server-hmr to remove the previous connection error.");
+					} catch (e) {
+						if (e instanceof Error && e.message.includes("WebSocket closed without opened.")) {
+							const currentScriptHostURL = new URL(import.meta.url);
+							const currentScriptHost = currentScriptHostURL.host + currentScriptHostURL.pathname.replace(/@vite\/client$/, "");
+							console.error(`[vite] failed to connect to websocket.
+your current setup:
+  (browser) ${currentScriptHost} <--[HTTP]--> ${serverHost} (server)\n  (browser) ${socketHost} <--[WebSocket (failing)]--> ${directSocketHost} (server)\nCheck out your Vite / network configuration and https://vite.dev/config/server-options.html#server-hmr .`);
+						}
+					}
+					return;
+				}
+				console.error(`[vite] failed to connect to websocket (${e}). `);
+				throw e;
+			}
+		},
+		async disconnect() {
+			await wsTransport.disconnect();
+		},
+		send(data) {
+			wsTransport.send(data);
+		}
+	};
+})());
+let willUnload = false;
+if (typeof window !== "undefined") window.addEventListener?.("beforeunload", () => {
+	willUnload = true;
+});
+function cleanUrl(pathname) {
+	const url = new URL(pathname, "http://vite.dev");
+	url.searchParams.delete("direct");
+	return url.pathname + url.search;
+}
+let isFirstUpdate = true;
+const outdatedLinkTags = /* @__PURE__ */ new WeakSet();
+const debounceReload = (time) => {
+	let timer;
+	return () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		timer = setTimeout(() => {
+			location.reload();
+		}, time);
+	};
+};
+const pageReload = debounceReload(20);
+const hmrClient = new HMRClient({
+	error: (err) => console.error("[vite]", err),
+	debug: (...msg) => console.debug("[vite]", ...msg)
+}, transport, isBundleMode ? async function importUpdatedModule({ url, acceptedPath, isWithinCircularImport }) {
+	const importPromise = import(base + url).then(() => globalThis.__rolldown_runtime__.loadExports(acceptedPath));
+	if (isWithinCircularImport) importPromise.catch(() => {
+		console.info(`[hmr] ${acceptedPath} failed to apply HMR as it's within a circular import. Reloading page to reset the execution order. To debug and break the circular import, you can run \`vite --debug hmr\` to log the circular dependency path if a file change triggered it.`);
+		pageReload();
+	});
+	return await importPromise;
+} : async function importUpdatedModule({ acceptedPath, timestamp, explicitImportRequired, isWithinCircularImport }) {
+	const [acceptedPathWithoutQuery, query] = acceptedPath.split(`?`);
+	const importPromise = import(
+		/* @vite-ignore */
+		base + acceptedPathWithoutQuery.slice(1) + `?${explicitImportRequired ? "import&" : ""}t=${timestamp}${query ? `&${query}` : ""}`
+);
+	if (isWithinCircularImport) importPromise.catch(() => {
+		console.info(`[hmr] ${acceptedPath} failed to apply HMR as it's within a circular import. Reloading page to reset the execution order. To debug and break the circular import, you can run \`vite --debug hmr\` to log the circular dependency path if a file change triggered it.`);
+		pageReload();
+	});
+	return await importPromise;
+});
+transport.connect(createHMRHandler(handleMessage));
+setupForwardConsoleHandler(transport, forwardConsole);
+async function handleMessage(payload) {
+	switch (payload.type) {
+		case "connected":
+			console.debug(`[vite] connected.`);
+			break;
+		case "update":
+			await hmrClient.notifyListeners("vite:beforeUpdate", payload);
+			if (hasDocument) if (isFirstUpdate && hasErrorOverlay()) {
+				location.reload();
+				return;
+			} else {
+				if (enableOverlay) clearErrorOverlay();
+				isFirstUpdate = false;
+			}
+			await Promise.all(payload.updates.map(async (update) => {
+				if (update.type === "js-update") return hmrClient.queueUpdate(update);
+				const { path, timestamp } = update;
+				const searchUrl = cleanUrl(path);
+				const el = Array.from(document.querySelectorAll("link")).find((e) => !outdatedLinkTags.has(e) && cleanUrl(e.href).includes(searchUrl));
+				if (!el) return;
+				const newPath = `${base}${searchUrl.slice(1)}${searchUrl.includes("?") ? "&" : "?"}t=${timestamp}`;
+				return new Promise((resolve) => {
+					const newLinkTag = el.cloneNode();
+					newLinkTag.href = new URL(newPath, el.href).href;
+					const removeOldEl = () => {
+						el.remove();
+						console.debug(`[vite] css hot updated: ${searchUrl}`);
+						resolve();
+					};
+					newLinkTag.addEventListener("load", removeOldEl);
+					newLinkTag.addEventListener("error", removeOldEl);
+					outdatedLinkTags.add(el);
+					el.after(newLinkTag);
+				});
+			}));
+			await hmrClient.notifyListeners("vite:afterUpdate", payload);
+			break;
+		case "custom":
+			await hmrClient.notifyListeners(payload.event, payload.data);
+			if (payload.event === "vite:ws:disconnect") {
+				if (hasDocument && !willUnload) {
+					console.log(`[vite] server connection lost. Polling for restart...`);
+					const socket = payload.data.webSocket;
+					const url = new URL(socket.url);
+					url.search = "";
+					await waitForSuccessfulPing(url.href);
+					location.reload();
+				}
+			}
+			break;
+		case "full-reload":
+			await hmrClient.notifyListeners("vite:beforeFullReload", payload);
+			if (hasDocument) if (payload.path && payload.path.endsWith(".html")) {
+				const pagePath = decodeURI(location.pathname);
+				const payloadPath = base + payload.path.slice(1);
+				if (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) pageReload();
+				return;
+			} else pageReload();
+			break;
+		case "prune":
+			await hmrClient.notifyListeners("vite:beforePrune", payload);
+			await hmrClient.prunePaths(payload.paths);
+			break;
+		case "error":
+			await hmrClient.notifyListeners("vite:error", payload);
+			if (hasDocument) {
+				const err = payload.err;
+				if (enableOverlay) createErrorOverlay(err);
+				else console.error(`[vite] Internal Server Error\n${err.message}\n${err.stack}`);
+			}
+			break;
+		case "ping": break;
+		default: return payload;
+	}
+}
+const enableOverlay = __HMR_ENABLE_OVERLAY__;
+const hasDocument = "document" in globalThis;
+function createErrorOverlay(err) {
+	clearErrorOverlay();
+	const { customElements } = globalThis;
+	if (customElements) {
+		const ErrorOverlayConstructor = customElements.get(overlayId);
+		document.body.appendChild(new ErrorOverlayConstructor(err));
+	}
+}
+function clearErrorOverlay() {
+	document.querySelectorAll(overlayId).forEach((n) => n.close());
+}
+function hasErrorOverlay() {
+	return document.querySelectorAll(overlayId).length;
+}
+function waitForSuccessfulPing(socketUrl) {
+	if (typeof SharedWorker === "undefined") {
+		const visibilityManager = {
+			currentState: document.visibilityState,
+			listeners: /* @__PURE__ */ new Set()
+		};
+		const onVisibilityChange = () => {
+			visibilityManager.currentState = document.visibilityState;
+			for (const listener of visibilityManager.listeners) listener(visibilityManager.currentState);
+		};
+		document.addEventListener("visibilitychange", onVisibilityChange);
+		return waitForSuccessfulPingInternal(socketUrl, visibilityManager);
+	}
+	const blob = new Blob([
+		"\"use strict\";",
+		`const waitForSuccessfulPingInternal = ${waitForSuccessfulPingInternal.toString()};`,
+		`const fn = ${pingWorkerContentMain.toString()};`,
+		`fn(${JSON.stringify(socketUrl)})`
+	], { type: "application/javascript" });
+	const objURL = URL.createObjectURL(blob);
+	const sharedWorker = new SharedWorker(objURL);
+	return new Promise((resolve, reject) => {
+		const onVisibilityChange = () => {
+			sharedWorker.port.postMessage({ visibility: document.visibilityState });
+		};
+		document.addEventListener("visibilitychange", onVisibilityChange);
+		sharedWorker.port.addEventListener("message", (event) => {
+			document.removeEventListener("visibilitychange", onVisibilityChange);
+			sharedWorker.port.close();
+			const data = event.data;
+			if (data.type === "error") {
+				reject(data.error);
+				return;
+			}
+			resolve();
+		});
+		onVisibilityChange();
+		sharedWorker.port.start();
+	});
+}
+function pingWorkerContentMain(socketUrl) {
+	self.addEventListener("connect", (_event) => {
+		const port = _event.ports[0];
+		if (!socketUrl) {
+			port.postMessage({
+				type: "error",
+				error: /* @__PURE__ */ new Error("socketUrl not found")
+			});
+			return;
+		}
+		const visibilityManager = {
+			currentState: "visible",
+			listeners: /* @__PURE__ */ new Set()
+		};
+		port.addEventListener("message", (event) => {
+			const { visibility } = event.data;
+			visibilityManager.currentState = visibility;
+			console.debug("[vite] new window visibility", visibility);
+			for (const listener of visibilityManager.listeners) listener(visibility);
+		});
+		port.start();
+		console.debug("[vite] connected from window");
+		waitForSuccessfulPingInternal(socketUrl, visibilityManager).then(() => {
+			console.debug("[vite] ping successful");
+			try {
+				port.postMessage({ type: "success" });
+			} catch (error) {
+				port.postMessage({
+					type: "error",
+					error
+				});
+			}
+		}, (error) => {
+			console.debug("[vite] error happened", error);
+			try {
+				port.postMessage({
+					type: "error",
+					error
+				});
+			} catch (error) {
+				port.postMessage({
+					type: "error",
+					error
+				});
+			}
+		});
+	});
+}
+async function waitForSuccessfulPingInternal(socketUrl, visibilityManager, ms = 1e3) {
+	function wait(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	async function ping() {
+		try {
+			const socket = new WebSocket(socketUrl, "vite-ping");
+			return new Promise((resolve) => {
+				function onOpen() {
+					resolve(true);
+					close();
+				}
+				function onError() {
+					resolve(false);
+					close();
+				}
+				function close() {
+					socket.removeEventListener("open", onOpen);
+					socket.removeEventListener("error", onError);
+					socket.close();
+				}
+				socket.addEventListener("open", onOpen);
+				socket.addEventListener("error", onError);
+			});
+		} catch {
+			return false;
+		}
+	}
+	function waitForWindowShow(visibilityManager) {
+		return new Promise((resolve) => {
+			const onChange = (newVisibility) => {
+				if (newVisibility === "visible") {
+					resolve();
+					visibilityManager.listeners.delete(onChange);
+				}
+			};
+			visibilityManager.listeners.add(onChange);
+		});
+	}
+	if (await ping()) return;
+	await wait(ms);
+	while (true) if (visibilityManager.currentState === "visible") {
+		if (await ping()) break;
+		await wait(ms);
+	} else await waitForWindowShow(visibilityManager);
+}
+const sheetsMap = /* @__PURE__ */ new Map();
+const linkSheetsMap = /* @__PURE__ */ new Map();
+if ("document" in globalThis) {
+	document.querySelectorAll("style[data-vite-dev-id]").forEach((el) => {
+		sheetsMap.set(el.getAttribute("data-vite-dev-id"), el);
+	});
+	document.querySelectorAll("link[rel=\"stylesheet\"][data-vite-dev-id]").forEach((el) => {
+		linkSheetsMap.set(el.getAttribute("data-vite-dev-id"), el);
+	});
+}
+let lastInsertedStyle;
+function updateStyle(id, content) {
+	if (linkSheetsMap.has(id)) return;
+	let style = sheetsMap.get(id);
+	if (!style) {
+		style = document.createElement("style");
+		style.setAttribute("type", "text/css");
+		style.setAttribute("data-vite-dev-id", id);
+		style.textContent = content;
+		if (cspNonce) style.setAttribute("nonce", cspNonce);
+		if (!lastInsertedStyle) {
+			document.head.appendChild(style);
+			setTimeout(() => {
+				lastInsertedStyle = void 0;
+			}, 0);
+		} else lastInsertedStyle.insertAdjacentElement("afterend", style);
+		lastInsertedStyle = style;
+	} else style.textContent = content;
+	sheetsMap.set(id, style);
+}
+function removeStyle(id) {
+	if (linkSheetsMap.has(id)) {
+		document.querySelectorAll(`link[rel="stylesheet"][data-vite-dev-id]`).forEach((el) => {
+			if (el.getAttribute("data-vite-dev-id") === id) el.remove();
+		});
+		linkSheetsMap.delete(id);
+	}
+	const style = sheetsMap.get(id);
+	if (style) {
+		document.head.removeChild(style);
+		sheetsMap.delete(id);
+	}
+}
+function createHotContext(ownerPath) {
+	return new HMRContext(hmrClient, ownerPath);
+}
+/**
+* urls here are dynamic import() urls that couldn't be statically analyzed
+*/
+function injectQuery(url, queryToInject) {
+	if (url[0] !== "." && url[0] !== "/") return url;
+	const pathname = url.replace(/[?#].*$/, "");
+	const { search, hash } = new URL(url, "http://vite.dev");
+	return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
+}
+if (isBundleMode && typeof DevRuntime !== "undefined") {
+	var _ref;
+	class ViteDevRuntime extends DevRuntime {
+		createModuleHotContext(moduleId) {
+			const ctx = createHotContext(moduleId);
+			ctx._internal = {
+				updateStyle,
+				removeStyle
+			};
+			return ctx;
+		}
+		applyUpdates(_boundaries) {}
+	}
+	const clientId = nanoid();
+	transport.send({
+		type: "custom",
+		event: "vite:module-loaded",
+		data: {
+			modules: [],
+			clientId
+		}
+	});
+	(_ref = globalThis).__rolldown_runtime__ ?? (_ref.__rolldown_runtime__ = new ViteDevRuntime({ send(message) {
+		switch (message.type) {
+			case "hmr:module-registered":
+				transport.send({
+					type: "custom",
+					event: "vite:module-loaded",
+					data: {
+						modules: message.modules.slice(),
+						clientId
+					}
+				});
+				break;
+			default: throw new Error(`Unknown message type: ${JSON.stringify(message)}`);
+		}
+	} }, clientId));
+}
+//#endregion
+export { ErrorOverlay, createHotContext, injectQuery, removeStyle, updateStyle };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/client/env.mjs b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/client/env.mjs
new file mode 100644
index 0000000..c7fd120
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/client/env.mjs
@@ -0,0 +1,18 @@
+//#region src/client/env.ts
+const context = (() => {
+	if (typeof globalThis !== "undefined") return globalThis;
+	else if (typeof self !== "undefined") return self;
+	else if (typeof window !== "undefined") return window;
+	else return Function("return this")();
+})();
+const defines = __DEFINES__;
+Object.keys(defines).forEach((key) => {
+	const segments = key.split(".");
+	let target = context;
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		if (i === segments.length - 1) target[segment] = defines[key];
+		else target = target[segment] || (target[segment] = {});
+	}
+});
+//#endregion
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/build.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/build.js
new file mode 100644
index 0000000..7a79b31
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/build.js
@@ -0,0 +1,5381 @@
+import { H as __require, z as __commonJSMin } from "./logger.js";
+import { t as require_lib } from "./lib.js";
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.14/node_modules/postcss-modules/build/fs.js
+var require_fs = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getFileSystem = getFileSystem;
+	exports.setFileSystem = setFileSystem;
+	let fileSystem = {
+		readFile: () => {
+			throw Error("readFile not implemented");
+		},
+		writeFile: () => {
+			throw Error("writeFile not implemented");
+		}
+	};
+	function setFileSystem(fs) {
+		fileSystem.readFile = fs.readFile;
+		fileSystem.writeFile = fs.writeFile;
+	}
+	function getFileSystem() {
+		return fileSystem;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.14/node_modules/postcss-modules/build/unquote.js
+var require_unquote = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = unquote;
+	const reg = /['"]/;
+	function unquote(str) {
+		if (!str) return "";
+		if (reg.test(str.charAt(0))) str = str.substr(1);
+		if (reg.test(str.charAt(str.length - 1))) str = str.substr(0, str.length - 1);
+		return str;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.14/node_modules/icss-utils/src/replaceValueSymbols.js
+var require_replaceValueSymbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const matchValueName = /[$]?[\w-]+/g;
+	const replaceValueSymbols = (value, replacements) => {
+		let matches;
+		while (matches = matchValueName.exec(value)) {
+			const replacement = replacements[matches[0]];
+			if (replacement) {
+				value = value.slice(0, matches.index) + replacement + value.slice(matchValueName.lastIndex);
+				matchValueName.lastIndex -= matches[0].length - replacement.length;
+			}
+		}
+		return value;
+	};
+	module.exports = replaceValueSymbols;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.14/node_modules/icss-utils/src/replaceSymbols.js
+var require_replaceSymbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const replaceValueSymbols = require_replaceValueSymbols();
+	const replaceSymbols = (css, replacements) => {
+		css.walk((node) => {
+			if (node.type === "decl" && node.value) node.value = replaceValueSymbols(node.value.toString(), replacements);
+			else if (node.type === "rule" && node.selector) node.selector = replaceValueSymbols(node.selector.toString(), replacements);
+			else if (node.type === "atrule" && node.params) node.params = replaceValueSymbols(node.params.toString(), replacements);
+		});
+	};
+	module.exports = replaceSymbols;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.14/node_modules/icss-utils/src/extractICSS.js
+var require_extractICSS = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const importPattern = /^:import\(("[^"]*"|'[^']*'|[^"']+)\)$/;
+	const balancedQuotes = /^("[^"]*"|'[^']*'|[^"']+)$/;
+	const getDeclsObject = (rule) => {
+		const object = {};
+		rule.walkDecls((decl) => {
+			const before = decl.raws.before ? decl.raws.before.trim() : "";
+			object[before + decl.prop] = decl.value;
+		});
+		return object;
+	};
+	/**
+	*
+	* @param {string} css
+	* @param {boolean} removeRules
+	* @param {'auto' | 'rule' | 'at-rule'} mode
+	*/
+	const extractICSS = (css, removeRules = true, mode = "auto") => {
+		const icssImports = {};
+		const icssExports = {};
+		function addImports(node, path) {
+			const unquoted = path.replace(/'|"/g, "");
+			icssImports[unquoted] = Object.assign(icssImports[unquoted] || {}, getDeclsObject(node));
+			if (removeRules) node.remove();
+		}
+		function addExports(node) {
+			Object.assign(icssExports, getDeclsObject(node));
+			if (removeRules) node.remove();
+		}
+		css.each((node) => {
+			if (node.type === "rule" && mode !== "at-rule") {
+				if (node.selector.slice(0, 7) === ":import") {
+					const matches = importPattern.exec(node.selector);
+					if (matches) addImports(node, matches[1]);
+				}
+				if (node.selector === ":export") addExports(node);
+			}
+			if (node.type === "atrule" && mode !== "rule") {
+				if (node.name === "icss-import") {
+					const matches = balancedQuotes.exec(node.params);
+					if (matches) addImports(node, matches[1]);
+				}
+				if (node.name === "icss-export") addExports(node);
+			}
+		});
+		return {
+			icssImports,
+			icssExports
+		};
+	};
+	module.exports = extractICSS;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.14/node_modules/icss-utils/src/createICSSRules.js
+var require_createICSSRules = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const createImports = (imports, postcss, mode = "rule") => {
+		return Object.keys(imports).map((path) => {
+			const aliases = imports[path];
+			const declarations = Object.keys(aliases).map((key) => postcss.decl({
+				prop: key,
+				value: aliases[key],
+				raws: { before: "\n  " }
+			}));
+			const hasDeclarations = declarations.length > 0;
+			const rule = mode === "rule" ? postcss.rule({
+				selector: `:import('${path}')`,
+				raws: { after: hasDeclarations ? "\n" : "" }
+			}) : postcss.atRule({
+				name: "icss-import",
+				params: `'${path}'`,
+				raws: { after: hasDeclarations ? "\n" : "" }
+			});
+			if (hasDeclarations) rule.append(declarations);
+			return rule;
+		});
+	};
+	const createExports = (exports$7, postcss, mode = "rule") => {
+		const declarations = Object.keys(exports$7).map((key) => postcss.decl({
+			prop: key,
+			value: exports$7[key],
+			raws: { before: "\n  " }
+		}));
+		if (declarations.length === 0) return [];
+		const rule = mode === "rule" ? postcss.rule({
+			selector: `:export`,
+			raws: { after: "\n" }
+		}) : postcss.atRule({
+			name: "icss-export",
+			raws: { after: "\n" }
+		});
+		rule.append(declarations);
+		return [rule];
+	};
+	const createICSSRules = (imports, exports$8, postcss, mode) => [...createImports(imports, postcss, mode), ...createExports(exports$8, postcss, mode)];
+	module.exports = createICSSRules;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.14/node_modules/icss-utils/src/index.js
+var require_src$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		replaceValueSymbols: require_replaceValueSymbols(),
+		replaceSymbols: require_replaceSymbols(),
+		extractICSS: require_extractICSS(),
+		createICSSRules: require_createICSSRules()
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.14/node_modules/postcss-modules/build/Parser.js
+var require_Parser = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = void 0;
+	var _icssUtils = require_src$4();
+	const importRegexp = /^:import\((.+)\)$/;
+	var Parser = class {
+		constructor(pathFetcher, trace) {
+			this.pathFetcher = pathFetcher;
+			this.plugin = this.plugin.bind(this);
+			this.exportTokens = {};
+			this.translations = {};
+			this.trace = trace;
+		}
+		plugin() {
+			const parser = this;
+			return {
+				postcssPlugin: "css-modules-parser",
+				async OnceExit(css) {
+					await Promise.all(parser.fetchAllImports(css));
+					parser.linkImportedSymbols(css);
+					return parser.extractExports(css);
+				}
+			};
+		}
+		fetchAllImports(css) {
+			let imports = [];
+			css.each((node) => {
+				if (node.type == "rule" && node.selector.match(importRegexp)) imports.push(this.fetchImport(node, css.source.input.from, imports.length));
+			});
+			return imports;
+		}
+		linkImportedSymbols(css) {
+			(0, _icssUtils.replaceSymbols)(css, this.translations);
+		}
+		extractExports(css) {
+			css.each((node) => {
+				if (node.type == "rule" && node.selector == ":export") this.handleExport(node);
+			});
+		}
+		handleExport(exportNode) {
+			exportNode.each((decl) => {
+				if (decl.type == "decl") {
+					Object.keys(this.translations).forEach((translation) => {
+						decl.value = decl.value.replace(translation, this.translations[translation]);
+					});
+					this.exportTokens[decl.prop] = decl.value;
+				}
+			});
+			exportNode.remove();
+		}
+		async fetchImport(importNode, relativeTo, depNr) {
+			const file = importNode.selector.match(importRegexp)[1];
+			const depTrace = this.trace + String.fromCharCode(depNr);
+			const exports$6 = await this.pathFetcher(file, relativeTo, depTrace);
+			try {
+				importNode.each((decl) => {
+					if (decl.type == "decl") this.translations[decl.prop] = exports$6[decl.value];
+				});
+				importNode.remove();
+			} catch (err) {
+				console.log(err);
+			}
+		}
+	};
+	exports.default = Parser;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.14/node_modules/postcss-modules/build/saveJSON.js
+var require_saveJSON = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = saveJSON;
+	var _fs = require_fs();
+	function saveJSON(cssFile, json) {
+		return new Promise((resolve, reject) => {
+			const { writeFile } = (0, _fs.getFileSystem)();
+			writeFile(`${cssFile}.json`, JSON.stringify(json), (e) => e ? reject(e) : resolve(json));
+		});
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/lodash.camelcase@4.3.0/node_modules/lodash.camelcase/index.js
+var require_lodash_camelcase = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* lodash (Custom Build) <https://lodash.com/>
+	* Build: `lodash modularize exports="npm" -o ./`
+	* Copyright jQuery Foundation and other contributors <https://jquery.org/>
+	* Released under MIT license <https://lodash.com/license>
+	* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+	* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+	*/
+	/** Used as references for various `Number` constants. */
+	var INFINITY = Infinity;
+	/** `Object#toString` result references. */
+	var symbolTag = "[object Symbol]";
+	/** Used to match words composed of alphanumeric characters. */
+	var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+	/** Used to match Latin Unicode letters (excluding mathematical operators). */
+	var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+	/** Used to compose unicode character classes. */
+	var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f\\ufe20-\\ufe23", rsComboSymbolsRange = "\\u20d0-\\u20f0", rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+	/** Used to compose unicode capture groups. */
+	var rsApos = "['’]", rsAstral = "[" + rsAstralRange + "]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboMarksRange + rsComboSymbolsRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
+	/** Used to compose unicode regexes. */
+	var rsLowerMisc = "(?:" + rsLower + "|" + rsMisc + ")", rsUpperMisc = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptLowerContr = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptUpperContr = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [
+		rsNonAstral,
+		rsRegional,
+		rsSurrPair
+	].join("|") + ")" + rsOptVar + reOptMod + ")*", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [
+		rsDingbat,
+		rsRegional,
+		rsSurrPair
+	].join("|") + ")" + rsSeq, rsSymbol = "(?:" + [
+		rsNonAstral + rsCombo + "?",
+		rsCombo,
+		rsRegional,
+		rsSurrPair,
+		rsAstral
+	].join("|") + ")";
+	/** Used to match apostrophes. */
+	var reApos = RegExp(rsApos, "g");
+	/**
+	* Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
+	* [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
+	*/
+	var reComboMark = RegExp(rsCombo, "g");
+	/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
+	var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+	/** Used to match complex or compound words. */
+	var reUnicodeWord = RegExp([
+		rsUpper + "?" + rsLower + "+" + rsOptLowerContr + "(?=" + [
+			rsBreak,
+			rsUpper,
+			"$"
+		].join("|") + ")",
+		rsUpperMisc + "+" + rsOptUpperContr + "(?=" + [
+			rsBreak,
+			rsUpper + rsLowerMisc,
+			"$"
+		].join("|") + ")",
+		rsUpper + "?" + rsLowerMisc + "+" + rsOptLowerContr,
+		rsUpper + "+" + rsOptUpperContr,
+		rsDigits,
+		rsEmoji
+	].join("|"), "g");
+	/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
+	var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + "]");
+	/** Used to detect strings that need a more robust regexp to match words. */
+	var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+	/** Used to map Latin Unicode letters to basic Latin letters. */
+	var deburredLetters = {
+		"À": "A",
+		"Á": "A",
+		"Â": "A",
+		"Ã": "A",
+		"Ä": "A",
+		"Å": "A",
+		"à": "a",
+		"á": "a",
+		"â": "a",
+		"ã": "a",
+		"ä": "a",
+		"å": "a",
+		"Ç": "C",
+		"ç": "c",
+		"Ð": "D",
+		"ð": "d",
+		"È": "E",
+		"É": "E",
+		"Ê": "E",
+		"Ë": "E",
+		"è": "e",
+		"é": "e",
+		"ê": "e",
+		"ë": "e",
+		"Ì": "I",
+		"Í": "I",
+		"Î": "I",
+		"Ï": "I",
+		"ì": "i",
+		"í": "i",
+		"î": "i",
+		"ï": "i",
+		"Ñ": "N",
+		"ñ": "n",
+		"Ò": "O",
+		"Ó": "O",
+		"Ô": "O",
+		"Õ": "O",
+		"Ö": "O",
+		"Ø": "O",
+		"ò": "o",
+		"ó": "o",
+		"ô": "o",
+		"õ": "o",
+		"ö": "o",
+		"ø": "o",
+		"Ù": "U",
+		"Ú": "U",
+		"Û": "U",
+		"Ü": "U",
+		"ù": "u",
+		"ú": "u",
+		"û": "u",
+		"ü": "u",
+		"Ý": "Y",
+		"ý": "y",
+		"ÿ": "y",
+		"Æ": "Ae",
+		"æ": "ae",
+		"Þ": "Th",
+		"þ": "th",
+		"ß": "ss",
+		"Ā": "A",
+		"Ă": "A",
+		"Ą": "A",
+		"ā": "a",
+		"ă": "a",
+		"ą": "a",
+		"Ć": "C",
+		"Ĉ": "C",
+		"Ċ": "C",
+		"Č": "C",
+		"ć": "c",
+		"ĉ": "c",
+		"ċ": "c",
+		"č": "c",
+		"Ď": "D",
+		"Đ": "D",
+		"ď": "d",
+		"đ": "d",
+		"Ē": "E",
+		"Ĕ": "E",
+		"Ė": "E",
+		"Ę": "E",
+		"Ě": "E",
+		"ē": "e",
+		"ĕ": "e",
+		"ė": "e",
+		"ę": "e",
+		"ě": "e",
+		"Ĝ": "G",
+		"Ğ": "G",
+		"Ġ": "G",
+		"Ģ": "G",
+		"ĝ": "g",
+		"ğ": "g",
+		"ġ": "g",
+		"ģ": "g",
+		"Ĥ": "H",
+		"Ħ": "H",
+		"ĥ": "h",
+		"ħ": "h",
+		"Ĩ": "I",
+		"Ī": "I",
+		"Ĭ": "I",
+		"Į": "I",
+		"İ": "I",
+		"ĩ": "i",
+		"ī": "i",
+		"ĭ": "i",
+		"į": "i",
+		"ı": "i",
+		"Ĵ": "J",
+		"ĵ": "j",
+		"Ķ": "K",
+		"ķ": "k",
+		"ĸ": "k",
+		"Ĺ": "L",
+		"Ļ": "L",
+		"Ľ": "L",
+		"Ŀ": "L",
+		"Ł": "L",
+		"ĺ": "l",
+		"ļ": "l",
+		"ľ": "l",
+		"ŀ": "l",
+		"ł": "l",
+		"Ń": "N",
+		"Ņ": "N",
+		"Ň": "N",
+		"Ŋ": "N",
+		"ń": "n",
+		"ņ": "n",
+		"ň": "n",
+		"ŋ": "n",
+		"Ō": "O",
+		"Ŏ": "O",
+		"Ő": "O",
+		"ō": "o",
+		"ŏ": "o",
+		"ő": "o",
+		"Ŕ": "R",
+		"Ŗ": "R",
+		"Ř": "R",
+		"ŕ": "r",
+		"ŗ": "r",
+		"ř": "r",
+		"Ś": "S",
+		"Ŝ": "S",
+		"Ş": "S",
+		"Š": "S",
+		"ś": "s",
+		"ŝ": "s",
+		"ş": "s",
+		"š": "s",
+		"Ţ": "T",
+		"Ť": "T",
+		"Ŧ": "T",
+		"ţ": "t",
+		"ť": "t",
+		"ŧ": "t",
+		"Ũ": "U",
+		"Ū": "U",
+		"Ŭ": "U",
+		"Ů": "U",
+		"Ű": "U",
+		"Ų": "U",
+		"ũ": "u",
+		"ū": "u",
+		"ŭ": "u",
+		"ů": "u",
+		"ű": "u",
+		"ų": "u",
+		"Ŵ": "W",
+		"ŵ": "w",
+		"Ŷ": "Y",
+		"ŷ": "y",
+		"Ÿ": "Y",
+		"Ź": "Z",
+		"Ż": "Z",
+		"Ž": "Z",
+		"ź": "z",
+		"ż": "z",
+		"ž": "z",
+		"IJ": "IJ",
+		"ij": "ij",
+		"Œ": "Oe",
+		"œ": "oe",
+		"ʼn": "'n",
+		"ſ": "ss"
+	};
+	/** Used as a reference to the global object. */
+	var root = typeof global == "object" && global && global.Object === Object && global || typeof self == "object" && self && self.Object === Object && self || Function("return this")();
+	/**
+	* A specialized version of `_.reduce` for arrays without support for
+	* iteratee shorthands.
+	*
+	* @private
+	* @param {Array} [array] The array to iterate over.
+	* @param {Function} iteratee The function invoked per iteration.
+	* @param {*} [accumulator] The initial value.
+	* @param {boolean} [initAccum] Specify using the first element of `array` as
+	*  the initial value.
+	* @returns {*} Returns the accumulated value.
+	*/
+	function arrayReduce(array, iteratee, accumulator, initAccum) {
+		var index = -1, length = array ? array.length : 0;
+		if (initAccum && length) accumulator = array[++index];
+		while (++index < length) accumulator = iteratee(accumulator, array[index], index, array);
+		return accumulator;
+	}
+	/**
+	* Converts an ASCII `string` to an array.
+	*
+	* @private
+	* @param {string} string The string to convert.
+	* @returns {Array} Returns the converted array.
+	*/
+	function asciiToArray(string) {
+		return string.split("");
+	}
+	/**
+	* Splits an ASCII `string` into an array of its words.
+	*
+	* @private
+	* @param {string} The string to inspect.
+	* @returns {Array} Returns the words of `string`.
+	*/
+	function asciiWords(string) {
+		return string.match(reAsciiWord) || [];
+	}
+	/**
+	* The base implementation of `_.propertyOf` without support for deep paths.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @returns {Function} Returns the new accessor function.
+	*/
+	function basePropertyOf(object) {
+		return function(key) {
+			return object == null ? void 0 : object[key];
+		};
+	}
+	/**
+	* Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
+	* letters to basic Latin letters.
+	*
+	* @private
+	* @param {string} letter The matched letter to deburr.
+	* @returns {string} Returns the deburred letter.
+	*/
+	var deburrLetter = basePropertyOf(deburredLetters);
+	/**
+	* Checks if `string` contains Unicode symbols.
+	*
+	* @private
+	* @param {string} string The string to inspect.
+	* @returns {boolean} Returns `true` if a symbol is found, else `false`.
+	*/
+	function hasUnicode(string) {
+		return reHasUnicode.test(string);
+	}
+	/**
+	* Checks if `string` contains a word composed of Unicode symbols.
+	*
+	* @private
+	* @param {string} string The string to inspect.
+	* @returns {boolean} Returns `true` if a word is found, else `false`.
+	*/
+	function hasUnicodeWord(string) {
+		return reHasUnicodeWord.test(string);
+	}
+	/**
+	* Converts `string` to an array.
+	*
+	* @private
+	* @param {string} string The string to convert.
+	* @returns {Array} Returns the converted array.
+	*/
+	function stringToArray(string) {
+		return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
+	}
+	/**
+	* Converts a Unicode `string` to an array.
+	*
+	* @private
+	* @param {string} string The string to convert.
+	* @returns {Array} Returns the converted array.
+	*/
+	function unicodeToArray(string) {
+		return string.match(reUnicode) || [];
+	}
+	/**
+	* Splits a Unicode `string` into an array of its words.
+	*
+	* @private
+	* @param {string} The string to inspect.
+	* @returns {Array} Returns the words of `string`.
+	*/
+	function unicodeWords(string) {
+		return string.match(reUnicodeWord) || [];
+	}
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var objectToString = Object.prototype.toString;
+	/** Built-in value references. */
+	var Symbol = root.Symbol;
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol ? Symbol.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+	/**
+	* The base implementation of `_.slice` without an iteratee call guard.
+	*
+	* @private
+	* @param {Array} array The array to slice.
+	* @param {number} [start=0] The start position.
+	* @param {number} [end=array.length] The end position.
+	* @returns {Array} Returns the slice of `array`.
+	*/
+	function baseSlice(array, start, end) {
+		var index = -1, length = array.length;
+		if (start < 0) start = -start > length ? 0 : length + start;
+		end = end > length ? length : end;
+		if (end < 0) end += length;
+		length = start > end ? 0 : end - start >>> 0;
+		start >>>= 0;
+		var result = Array(length);
+		while (++index < length) result[index] = array[index + start];
+		return result;
+	}
+	/**
+	* The base implementation of `_.toString` which doesn't convert nullish
+	* values to empty strings.
+	*
+	* @private
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	*/
+	function baseToString(value) {
+		if (typeof value == "string") return value;
+		if (isSymbol(value)) return symbolToString ? symbolToString.call(value) : "";
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+	}
+	/**
+	* Casts `array` to a slice if it's needed.
+	*
+	* @private
+	* @param {Array} array The array to inspect.
+	* @param {number} start The start position.
+	* @param {number} [end=array.length] The end position.
+	* @returns {Array} Returns the cast slice.
+	*/
+	function castSlice(array, start, end) {
+		var length = array.length;
+		end = end === void 0 ? length : end;
+		return !start && end >= length ? array : baseSlice(array, start, end);
+	}
+	/**
+	* Creates a function like `_.lowerFirst`.
+	*
+	* @private
+	* @param {string} methodName The name of the `String` case method to use.
+	* @returns {Function} Returns the new case function.
+	*/
+	function createCaseFirst(methodName) {
+		return function(string) {
+			string = toString(string);
+			var strSymbols = hasUnicode(string) ? stringToArray(string) : void 0;
+			var chr = strSymbols ? strSymbols[0] : string.charAt(0);
+			var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
+			return chr[methodName]() + trailing;
+		};
+	}
+	/**
+	* Creates a function like `_.camelCase`.
+	*
+	* @private
+	* @param {Function} callback The function to combine each word.
+	* @returns {Function} Returns the new compounder function.
+	*/
+	function createCompounder(callback) {
+		return function(string) {
+			return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
+		};
+	}
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike(value) {
+		return !!value && typeof value == "object";
+	}
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol(value) {
+		return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+	}
+	/**
+	* Converts `value` to a string. An empty string is returned for `null`
+	* and `undefined` values. The sign of `-0` is preserved.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	* @example
+	*
+	* _.toString(null);
+	* // => ''
+	*
+	* _.toString(-0);
+	* // => '-0'
+	*
+	* _.toString([1, 2, 3]);
+	* // => '1,2,3'
+	*/
+	function toString(value) {
+		return value == null ? "" : baseToString(value);
+	}
+	/**
+	* Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to convert.
+	* @returns {string} Returns the camel cased string.
+	* @example
+	*
+	* _.camelCase('Foo Bar');
+	* // => 'fooBar'
+	*
+	* _.camelCase('--foo-bar--');
+	* // => 'fooBar'
+	*
+	* _.camelCase('__FOO_BAR__');
+	* // => 'fooBar'
+	*/
+	var camelCase = createCompounder(function(result, word, index) {
+		word = word.toLowerCase();
+		return result + (index ? capitalize(word) : word);
+	});
+	/**
+	* Converts the first character of `string` to upper case and the remaining
+	* to lower case.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to capitalize.
+	* @returns {string} Returns the capitalized string.
+	* @example
+	*
+	* _.capitalize('FRED');
+	* // => 'Fred'
+	*/
+	function capitalize(string) {
+		return upperFirst(toString(string).toLowerCase());
+	}
+	/**
+	* Deburrs `string` by converting
+	* [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+	* and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+	* letters to basic Latin letters and removing
+	* [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to deburr.
+	* @returns {string} Returns the deburred string.
+	* @example
+	*
+	* _.deburr('déjà vu');
+	* // => 'deja vu'
+	*/
+	function deburr(string) {
+		string = toString(string);
+		return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
+	}
+	/**
+	* Converts the first character of `string` to upper case.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category String
+	* @param {string} [string=''] The string to convert.
+	* @returns {string} Returns the converted string.
+	* @example
+	*
+	* _.upperFirst('fred');
+	* // => 'Fred'
+	*
+	* _.upperFirst('FRED');
+	* // => 'FRED'
+	*/
+	var upperFirst = createCaseFirst("toUpperCase");
+	/**
+	* Splits `string` into an array of its words.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to inspect.
+	* @param {RegExp|string} [pattern] The pattern to match words.
+	* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+	* @returns {Array} Returns the words of `string`.
+	* @example
+	*
+	* _.words('fred, barney, & pebbles');
+	* // => ['fred', 'barney', 'pebbles']
+	*
+	* _.words('fred, barney, & pebbles', /[^, ]+/g);
+	* // => ['fred', 'barney', '&', 'pebbles']
+	*/
+	function words(string, pattern, guard) {
+		string = toString(string);
+		pattern = guard ? void 0 : pattern;
+		if (pattern === void 0) return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
+		return string.match(pattern) || [];
+	}
+	module.exports = camelCase;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.14/node_modules/postcss-modules/build/localsConvention.js
+var require_localsConvention = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.makeLocalsConventionReducer = makeLocalsConventionReducer;
+	var _lodash = _interopRequireDefault(require_lodash_camelcase());
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function dashesCamelCase(string) {
+		return string.replace(/-+(\w)/g, (_, firstLetter) => firstLetter.toUpperCase());
+	}
+	function makeLocalsConventionReducer(localsConvention, inputFile) {
+		const isFunc = typeof localsConvention === "function";
+		return (tokens, [className, value]) => {
+			if (isFunc) {
+				const convention = localsConvention(className, value, inputFile);
+				tokens[convention] = value;
+				return tokens;
+			}
+			switch (localsConvention) {
+				case "camelCase":
+					tokens[className] = value;
+					tokens[(0, _lodash.default)(className)] = value;
+					break;
+				case "camelCaseOnly":
+					tokens[(0, _lodash.default)(className)] = value;
+					break;
+				case "dashes":
+					tokens[className] = value;
+					tokens[dashesCamelCase(className)] = value;
+					break;
+				case "dashesOnly":
+					tokens[dashesCamelCase(className)] = value;
+					break;
+			}
+			return tokens;
+		};
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.14/node_modules/postcss-modules/build/FileSystemLoader.js
+var require_FileSystemLoader = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = void 0;
+	var _postcss$1 = _interopRequireDefault(__require("postcss"));
+	var _path = _interopRequireDefault(__require("path"));
+	var _Parser = _interopRequireDefault(require_Parser());
+	var _fs = require_fs();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	var Core = class Core {
+		constructor(plugins) {
+			this.plugins = plugins || Core.defaultPlugins;
+		}
+		async load(sourceString, sourcePath, trace, pathFetcher) {
+			const parser = new _Parser.default(pathFetcher, trace);
+			const plugins = this.plugins.concat([parser.plugin()]);
+			return {
+				injectableSource: (await (0, _postcss$1.default)(plugins).process(sourceString, { from: sourcePath })).css,
+				exportTokens: parser.exportTokens
+			};
+		}
+	};
+	const traceKeySorter = (a, b) => {
+		if (a.length < b.length) return a < b.substring(0, a.length) ? -1 : 1;
+		if (a.length > b.length) return a.substring(0, b.length) <= b ? -1 : 1;
+		return a < b ? -1 : 1;
+	};
+	var FileSystemLoader = class {
+		constructor(root, plugins, fileResolve) {
+			if (root === "/" && process.platform === "win32") {
+				const cwdDrive = process.cwd().slice(0, 3);
+				if (!/^[A-Za-z]:\\$/.test(cwdDrive)) throw new Error(`Failed to obtain root from "${process.cwd()}".`);
+				root = cwdDrive;
+			}
+			this.root = root;
+			this.fileResolve = fileResolve;
+			this.sources = {};
+			this.traces = {};
+			this.importNr = 0;
+			this.core = new Core(plugins);
+			this.tokensByFile = {};
+			this.fs = (0, _fs.getFileSystem)();
+		}
+		async fetch(_newPath, relativeTo, _trace) {
+			const newPath = _newPath.replace(/^["']|["']$/g, "");
+			const trace = _trace || String.fromCharCode(this.importNr++);
+			const useFileResolve = typeof this.fileResolve === "function";
+			const fileResolvedPath = useFileResolve ? await this.fileResolve(newPath, relativeTo) : await Promise.resolve();
+			if (fileResolvedPath && !_path.default.isAbsolute(fileResolvedPath)) throw new Error("The returned path from the \"fileResolve\" option must be absolute.");
+			const relativeDir = _path.default.dirname(relativeTo);
+			const rootRelativePath = fileResolvedPath || _path.default.resolve(relativeDir, newPath);
+			let fileRelativePath = fileResolvedPath || _path.default.resolve(_path.default.resolve(this.root, relativeDir), newPath);
+			if (!useFileResolve && newPath[0] !== "." && !_path.default.isAbsolute(newPath)) try {
+				fileRelativePath = __require.resolve(newPath);
+			} catch (e) {}
+			const tokens = this.tokensByFile[fileRelativePath];
+			if (tokens) return tokens;
+			return new Promise((resolve, reject) => {
+				this.fs.readFile(fileRelativePath, "utf-8", async (err, source) => {
+					if (err) reject(err);
+					const { injectableSource, exportTokens } = await this.core.load(source, rootRelativePath, trace, this.fetch.bind(this));
+					this.sources[fileRelativePath] = injectableSource;
+					this.traces[trace] = fileRelativePath;
+					this.tokensByFile[fileRelativePath] = exportTokens;
+					resolve(exportTokens);
+				});
+			});
+		}
+		get finalSource() {
+			const traces = this.traces;
+			const sources = this.sources;
+			let written = /* @__PURE__ */ new Set();
+			return Object.keys(traces).sort(traceKeySorter).map((key) => {
+				const filename = traces[key];
+				if (written.has(filename)) return null;
+				written.add(filename);
+				return sources[filename];
+			}).join("");
+		}
+	};
+	exports.default = FileSystemLoader;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-extract-imports@3.1.0_postcss@8.5.14/node_modules/postcss-modules-extract-imports/src/topologicalSort.js
+var require_topologicalSort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const PERMANENT_MARKER = 2;
+	const TEMPORARY_MARKER = 1;
+	function createError(node, graph) {
+		const er = /* @__PURE__ */ new Error("Nondeterministic import's order");
+		er.nodes = [node, graph[node].find((relatedNode) => graph[relatedNode].indexOf(node) > -1)];
+		return er;
+	}
+	function walkGraph(node, graph, state, result, strict) {
+		if (state[node] === PERMANENT_MARKER) return;
+		if (state[node] === TEMPORARY_MARKER) {
+			if (strict) return createError(node, graph);
+			return;
+		}
+		state[node] = TEMPORARY_MARKER;
+		const children = graph[node];
+		const length = children.length;
+		for (let i = 0; i < length; ++i) {
+			const error = walkGraph(children[i], graph, state, result, strict);
+			if (error instanceof Error) return error;
+		}
+		state[node] = PERMANENT_MARKER;
+		result.push(node);
+	}
+	function topologicalSort(graph, strict) {
+		const result = [];
+		const state = {};
+		const nodes = Object.keys(graph);
+		const length = nodes.length;
+		for (let i = 0; i < length; ++i) {
+			const er = walkGraph(nodes[i], graph, state, result, strict);
+			if (er instanceof Error) return er;
+		}
+		return result;
+	}
+	module.exports = topologicalSort;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-extract-imports@3.1.0_postcss@8.5.14/node_modules/postcss-modules-extract-imports/src/index.js
+var require_src$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const topologicalSort = require_topologicalSort();
+	const matchImports = /^(.+?)\s+from\s+(?:"([^"]+)"|'([^']+)'|(global))$/;
+	const icssImport = /^:import\((?:"([^"]+)"|'([^']+)')\)/;
+	const VISITED_MARKER = 1;
+	/**
+	* :import('G') {}
+	*
+	* Rule
+	*   composes: ... from 'A'
+	*   composes: ... from 'B'
+	
+	* Rule
+	*   composes: ... from 'A'
+	*   composes: ... from 'A'
+	*   composes: ... from 'C'
+	*
+	* Results in:
+	*
+	* graph: {
+	*   G: [],
+	*   A: [],
+	*   B: ['A'],
+	*   C: ['A'],
+	* }
+	*/
+	function addImportToGraph(importId, parentId, graph, visited) {
+		const siblingsId = parentId + "_siblings";
+		const visitedId = parentId + "_" + importId;
+		if (visited[visitedId] !== VISITED_MARKER) {
+			if (!Array.isArray(visited[siblingsId])) visited[siblingsId] = [];
+			const siblings = visited[siblingsId];
+			if (Array.isArray(graph[importId])) graph[importId] = graph[importId].concat(siblings);
+			else graph[importId] = siblings.slice();
+			visited[visitedId] = VISITED_MARKER;
+			siblings.push(importId);
+		}
+	}
+	module.exports = (options = {}) => {
+		let importIndex = 0;
+		const createImportedName = typeof options.createImportedName !== "function" ? (importName) => `i__imported_${importName.replace(/\W/g, "_")}_${importIndex++}` : options.createImportedName;
+		const failOnWrongOrder = options.failOnWrongOrder;
+		return {
+			postcssPlugin: "postcss-modules-extract-imports",
+			prepare() {
+				const graph = {};
+				const visited = {};
+				const existingImports = {};
+				const importDecls = {};
+				const imports = {};
+				return { Once(root, postcss) {
+					root.walkRules((rule) => {
+						const matches = icssImport.exec(rule.selector);
+						if (matches) {
+							const [, doubleQuotePath, singleQuotePath] = matches;
+							const importPath = doubleQuotePath || singleQuotePath;
+							addImportToGraph(importPath, "root", graph, visited);
+							existingImports[importPath] = rule;
+						}
+					});
+					root.walkDecls(/^composes$/, (declaration) => {
+						const multiple = declaration.value.split(",");
+						const values = [];
+						multiple.forEach((value) => {
+							const matches = value.trim().match(matchImports);
+							if (!matches) {
+								values.push(value);
+								return;
+							}
+							let tmpSymbols;
+							let [, symbols, doubleQuotePath, singleQuotePath, global] = matches;
+							if (global) tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
+							else {
+								const importPath = doubleQuotePath || singleQuotePath;
+								let parent = declaration.parent;
+								let parentIndexes = "";
+								while (parent.type !== "root") {
+									parentIndexes = parent.parent.index(parent) + "_" + parentIndexes;
+									parent = parent.parent;
+								}
+								const { selector } = declaration.parent;
+								addImportToGraph(importPath, `_${parentIndexes}${selector}`, graph, visited);
+								importDecls[importPath] = declaration;
+								imports[importPath] = imports[importPath] || {};
+								tmpSymbols = symbols.split(/\s+/).map((s) => {
+									if (!imports[importPath][s]) imports[importPath][s] = createImportedName(s, importPath);
+									return imports[importPath][s];
+								});
+							}
+							values.push(tmpSymbols.join(" "));
+						});
+						declaration.value = values.join(", ");
+					});
+					const importsOrder = topologicalSort(graph, failOnWrongOrder);
+					if (importsOrder instanceof Error) throw importDecls[importsOrder.nodes.find((importPath) => importDecls.hasOwnProperty(importPath))].error("Failed to resolve order of composed modules " + importsOrder.nodes.map((importPath) => "`" + importPath + "`").join(", ") + ".", {
+						plugin: "postcss-modules-extract-imports",
+						word: "composes"
+					});
+					let lastImportRule;
+					importsOrder.forEach((path) => {
+						const importedSymbols = imports[path];
+						let rule = existingImports[path];
+						if (!rule && importedSymbols) {
+							rule = postcss.rule({
+								selector: `:import("${path}")`,
+								raws: { after: "\n" }
+							});
+							if (lastImportRule) root.insertAfter(lastImportRule, rule);
+							else root.prepend(rule);
+						}
+						lastImportRule = rule;
+						if (!importedSymbols) return;
+						Object.keys(importedSymbols).forEach((importedSymbol) => {
+							rule.append(postcss.decl({
+								value: importedSymbol,
+								prop: importedSymbols[importedSymbol],
+								raws: { before: "\n  " }
+							}));
+						});
+					});
+				} };
+			}
+		};
+	};
+	module.exports.postcss = true;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/wasm-hash.js
+var require_wasm_hash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const MAX_SHORT_STRING = Math.floor(65472 / 4) & -4;
+	var WasmHash = class {
+		/**
+		* @param {WebAssembly.Instance} instance wasm instance
+		* @param {WebAssembly.Instance[]} instancesPool pool of instances
+		* @param {number} chunkSize size of data chunks passed to wasm
+		* @param {number} digestSize size of digest returned by wasm
+		*/
+		constructor(instance, instancesPool, chunkSize, digestSize) {
+			const exports$2 = instance.exports;
+			exports$2.init();
+			this.exports = exports$2;
+			this.mem = Buffer.from(exports$2.memory.buffer, 0, 65536);
+			this.buffered = 0;
+			this.instancesPool = instancesPool;
+			this.chunkSize = chunkSize;
+			this.digestSize = digestSize;
+		}
+		reset() {
+			this.buffered = 0;
+			this.exports.init();
+		}
+		/**
+		* @param {Buffer | string} data data
+		* @param {BufferEncoding=} encoding encoding
+		* @returns {this} itself
+		*/
+		update(data, encoding) {
+			if (typeof data === "string") {
+				while (data.length > MAX_SHORT_STRING) {
+					this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
+					data = data.slice(MAX_SHORT_STRING);
+				}
+				this._updateWithShortString(data, encoding);
+				return this;
+			}
+			this._updateWithBuffer(data);
+			return this;
+		}
+		/**
+		* @param {string} data data
+		* @param {BufferEncoding=} encoding encoding
+		* @returns {void}
+		*/
+		_updateWithShortString(data, encoding) {
+			const { exports: exports$3, buffered, mem, chunkSize } = this;
+			let endPos;
+			if (data.length < 70) if (!encoding || encoding === "utf-8" || encoding === "utf8") {
+				endPos = buffered;
+				for (let i = 0; i < data.length; i++) {
+					const cc = data.charCodeAt(i);
+					if (cc < 128) mem[endPos++] = cc;
+					else if (cc < 2048) {
+						mem[endPos] = cc >> 6 | 192;
+						mem[endPos + 1] = cc & 63 | 128;
+						endPos += 2;
+					} else {
+						endPos += mem.write(data.slice(i), endPos, encoding);
+						break;
+					}
+				}
+			} else if (encoding === "latin1") {
+				endPos = buffered;
+				for (let i = 0; i < data.length; i++) {
+					const cc = data.charCodeAt(i);
+					mem[endPos++] = cc;
+				}
+			} else endPos = buffered + mem.write(data, buffered, encoding);
+			else endPos = buffered + mem.write(data, buffered, encoding);
+			if (endPos < chunkSize) this.buffered = endPos;
+			else {
+				const l = endPos & ~(this.chunkSize - 1);
+				exports$3.update(l);
+				const newBuffered = endPos - l;
+				this.buffered = newBuffered;
+				if (newBuffered > 0) mem.copyWithin(0, l, endPos);
+			}
+		}
+		/**
+		* @param {Buffer} data data
+		* @returns {void}
+		*/
+		_updateWithBuffer(data) {
+			const { exports: exports$4, buffered, mem } = this;
+			const length = data.length;
+			if (buffered + length < this.chunkSize) {
+				data.copy(mem, buffered, 0, length);
+				this.buffered += length;
+			} else {
+				const l = buffered + length & ~(this.chunkSize - 1);
+				if (l > 65536) {
+					let i = 65536 - buffered;
+					data.copy(mem, buffered, 0, i);
+					exports$4.update(65536);
+					const stop = l - buffered - 65536;
+					while (i < stop) {
+						data.copy(mem, 0, i, i + 65536);
+						exports$4.update(65536);
+						i += 65536;
+					}
+					data.copy(mem, 0, i, l - buffered);
+					exports$4.update(l - buffered - i);
+				} else {
+					data.copy(mem, buffered, 0, l - buffered);
+					exports$4.update(l);
+				}
+				const newBuffered = length + buffered - l;
+				this.buffered = newBuffered;
+				if (newBuffered > 0) data.copy(mem, 0, length - newBuffered, length);
+			}
+		}
+		digest(type) {
+			const { exports: exports$5, buffered, mem, digestSize } = this;
+			exports$5.final(buffered);
+			this.instancesPool.push(this);
+			const hex = mem.toString("latin1", 0, digestSize);
+			if (type === "hex") return hex;
+			if (type === "binary" || !type) return Buffer.from(hex, "hex");
+			return Buffer.from(hex, "hex").toString(type);
+		}
+	};
+	const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
+		if (instancesPool.length > 0) {
+			const old = instancesPool.pop();
+			old.reset();
+			return old;
+		} else return new WasmHash(new WebAssembly.Instance(wasmModule), instancesPool, chunkSize, digestSize);
+	};
+	module.exports = create;
+	module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/xxhash64.js
+var require_xxhash64 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const create = require_wasm_hash();
+	const xxhash64 = new WebAssembly.Module(Buffer.from("AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrUIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqwYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEACfyACIAE1AgBCh5Wvr5i23puef36FQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCECIAFBBGoLIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAiACQh2IhUL5893xmfaZqxZ+IgIgAkIgiIUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL", "base64"));
+	module.exports = create.bind(null, xxhash64, [], 32, 16);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/BatchedHash.js
+var require_BatchedHash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const MAX_SHORT_STRING = require_wasm_hash().MAX_SHORT_STRING;
+	var BatchedHash = class {
+		constructor(hash) {
+			this.string = void 0;
+			this.encoding = void 0;
+			this.hash = hash;
+		}
+		/**
+		* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+		* @param {string|Buffer} data data
+		* @param {string=} inputEncoding data encoding
+		* @returns {this} updated hash
+		*/
+		update(data, inputEncoding) {
+			if (this.string !== void 0) {
+				if (typeof data === "string" && inputEncoding === this.encoding && this.string.length + data.length < MAX_SHORT_STRING) {
+					this.string += data;
+					return this;
+				}
+				this.hash.update(this.string, this.encoding);
+				this.string = void 0;
+			}
+			if (typeof data === "string") if (data.length < MAX_SHORT_STRING && (!inputEncoding || !inputEncoding.startsWith("ba"))) {
+				this.string = data;
+				this.encoding = inputEncoding;
+			} else this.hash.update(data, inputEncoding);
+			else this.hash.update(data);
+			return this;
+		}
+		/**
+		* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+		* @param {string=} encoding encoding of the return value
+		* @returns {string|Buffer} digest
+		*/
+		digest(encoding) {
+			if (this.string !== void 0) this.hash.update(this.string, this.encoding);
+			return this.hash.digest(encoding);
+		}
+	};
+	module.exports = BatchedHash;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/md4.js
+var require_md4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const create = require_wasm_hash();
+	const md4 = new WebAssembly.Module(Buffer.from("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", "base64"));
+	module.exports = create.bind(null, md4, [], 64, 32);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/BulkUpdateDecorator.js
+var require_BulkUpdateDecorator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const BULK_SIZE = 2e3;
+	const digestCaches = {};
+	var BulkUpdateDecorator = class {
+		/**
+		* @param {Hash | function(): Hash} hashOrFactory function to create a hash
+		* @param {string=} hashKey key for caching
+		*/
+		constructor(hashOrFactory, hashKey) {
+			this.hashKey = hashKey;
+			if (typeof hashOrFactory === "function") {
+				this.hashFactory = hashOrFactory;
+				this.hash = void 0;
+			} else {
+				this.hashFactory = void 0;
+				this.hash = hashOrFactory;
+			}
+			this.buffer = "";
+		}
+		/**
+		* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+		* @param {string|Buffer} data data
+		* @param {string=} inputEncoding data encoding
+		* @returns {this} updated hash
+		*/
+		update(data, inputEncoding) {
+			if (inputEncoding !== void 0 || typeof data !== "string" || data.length > BULK_SIZE) {
+				if (this.hash === void 0) this.hash = this.hashFactory();
+				if (this.buffer.length > 0) {
+					this.hash.update(this.buffer);
+					this.buffer = "";
+				}
+				this.hash.update(data, inputEncoding);
+			} else {
+				this.buffer += data;
+				if (this.buffer.length > BULK_SIZE) {
+					if (this.hash === void 0) this.hash = this.hashFactory();
+					this.hash.update(this.buffer);
+					this.buffer = "";
+				}
+			}
+			return this;
+		}
+		/**
+		* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+		* @param {string=} encoding encoding of the return value
+		* @returns {string|Buffer} digest
+		*/
+		digest(encoding) {
+			let digestCache;
+			const buffer = this.buffer;
+			if (this.hash === void 0) {
+				const cacheKey = `${this.hashKey}-${encoding}`;
+				digestCache = digestCaches[cacheKey];
+				if (digestCache === void 0) digestCache = digestCaches[cacheKey] = /* @__PURE__ */ new Map();
+				const cacheEntry = digestCache.get(buffer);
+				if (cacheEntry !== void 0) return cacheEntry;
+				this.hash = this.hashFactory();
+			}
+			if (buffer.length > 0) this.hash.update(buffer);
+			const digestResult = this.hash.digest(encoding);
+			if (digestCache !== void 0) digestCache.set(buffer, digestResult);
+			return digestResult;
+		}
+	};
+	module.exports = BulkUpdateDecorator;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/getHashDigest.js
+var require_getHashDigest = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const baseEncodeTables = {
+		26: "abcdefghijklmnopqrstuvwxyz",
+		32: "123456789abcdefghjkmnpqrstuvwxyz",
+		36: "0123456789abcdefghijklmnopqrstuvwxyz",
+		49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ",
+		52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+		58: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ",
+		62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+		64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_"
+	};
+	/**
+	* @param {Uint32Array} uint32Array Treated as a long base-0x100000000 number, little endian
+	* @param {number} divisor The divisor
+	* @return {number} Modulo (remainder) of the division
+	*/
+	function divmod32(uint32Array, divisor) {
+		let carry = 0;
+		for (let i = uint32Array.length - 1; i >= 0; i--) {
+			const value = carry * 4294967296 + uint32Array[i];
+			carry = value % divisor;
+			uint32Array[i] = Math.floor(value / divisor);
+		}
+		return carry;
+	}
+	function encodeBufferToBase(buffer, base, length) {
+		const encodeTable = baseEncodeTables[base];
+		if (!encodeTable) throw new Error("Unknown encoding base" + base);
+		const limit = Math.ceil(buffer.length * 8 / Math.log2(base));
+		length = Math.min(length, limit);
+		const uint32Array = new Uint32Array(Math.ceil(buffer.length / 4));
+		buffer.copy(Buffer.from(uint32Array.buffer));
+		let output = "";
+		for (let i = 0; i < length; i++) output = encodeTable[divmod32(uint32Array, base)] + output;
+		return output;
+	}
+	let crypto = void 0;
+	let createXXHash64 = void 0;
+	let createMd4 = void 0;
+	let BatchedHash = void 0;
+	let BulkUpdateDecorator = void 0;
+	function getHashDigest(buffer, algorithm, digestType, maxLength) {
+		algorithm = algorithm || "xxhash64";
+		maxLength = maxLength || 9999;
+		let hash;
+		if (algorithm === "xxhash64") {
+			if (createXXHash64 === void 0) {
+				createXXHash64 = require_xxhash64();
+				if (BatchedHash === void 0) BatchedHash = require_BatchedHash();
+			}
+			hash = new BatchedHash(createXXHash64());
+		} else if (algorithm === "md4") {
+			if (createMd4 === void 0) {
+				createMd4 = require_md4();
+				if (BatchedHash === void 0) BatchedHash = require_BatchedHash();
+			}
+			hash = new BatchedHash(createMd4());
+		} else if (algorithm === "native-md4") {
+			if (typeof crypto === "undefined") {
+				crypto = __require("crypto");
+				if (BulkUpdateDecorator === void 0) BulkUpdateDecorator = require_BulkUpdateDecorator();
+			}
+			hash = new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
+		} else {
+			if (typeof crypto === "undefined") {
+				crypto = __require("crypto");
+				if (BulkUpdateDecorator === void 0) BulkUpdateDecorator = require_BulkUpdateDecorator();
+			}
+			hash = new BulkUpdateDecorator(() => crypto.createHash(algorithm), algorithm);
+		}
+		hash.update(buffer);
+		if (digestType === "base26" || digestType === "base32" || digestType === "base36" || digestType === "base49" || digestType === "base52" || digestType === "base58" || digestType === "base62" || digestType === "base64safe") return encodeBufferToBase(hash.digest(), digestType === "base64safe" ? 64 : digestType.substr(4), maxLength);
+		return hash.digest(digestType || "hex").substr(0, maxLength);
+	}
+	module.exports = getHashDigest;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/interpolateName.js
+var require_interpolateName = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$1 = __require("path");
+	const getHashDigest = require_getHashDigest();
+	function interpolateName(loaderContext, name, options = {}) {
+		let filename;
+		const hasQuery = loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1;
+		if (typeof name === "function") filename = name(loaderContext.resourcePath, hasQuery ? loaderContext.resourceQuery : void 0);
+		else filename = name || "[hash].[ext]";
+		const context = options.context;
+		const content = options.content;
+		const regExp = options.regExp;
+		let ext = "bin";
+		let basename = "file";
+		let directory = "";
+		let folder = "";
+		let query = "";
+		if (loaderContext.resourcePath) {
+			const parsed = path$1.parse(loaderContext.resourcePath);
+			let resourcePath = loaderContext.resourcePath;
+			if (parsed.ext) ext = parsed.ext.substr(1);
+			if (parsed.dir) {
+				basename = parsed.name;
+				resourcePath = parsed.dir + path$1.sep;
+			}
+			if (typeof context !== "undefined") {
+				directory = path$1.relative(context, resourcePath + "_").replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+				directory = directory.substr(0, directory.length - 1);
+			} else directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+			if (directory.length <= 1) directory = "";
+			else folder = path$1.basename(directory);
+		}
+		if (loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1) {
+			query = loaderContext.resourceQuery;
+			const hashIdx = query.indexOf("#");
+			if (hashIdx >= 0) query = query.substr(0, hashIdx);
+		}
+		let url = filename;
+		if (content) url = url.replace(/\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*(?:safe)?))?(?::(\d+))?\]/gi, (all, hashType, digestType, maxLength) => getHashDigest(content, hashType, digestType, parseInt(maxLength, 10)));
+		url = url.replace(/\[ext\]/gi, () => ext).replace(/\[name\]/gi, () => basename).replace(/\[path\]/gi, () => directory).replace(/\[folder\]/gi, () => folder).replace(/\[query\]/gi, () => query);
+		if (regExp && loaderContext.resourcePath) {
+			const match = loaderContext.resourcePath.match(new RegExp(regExp));
+			match && match.forEach((matched, i) => {
+				url = url.replace(new RegExp("\\[" + i + "\\]", "ig"), matched);
+			});
+		}
+		if (typeof loaderContext.options === "object" && typeof loaderContext.options.customInterpolateName === "function") url = loaderContext.options.customInterpolateName.call(loaderContext, url, name, options);
+		return url;
+	}
+	module.exports = interpolateName;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/generic-names@4.0.0/node_modules/generic-names/index.js
+var require_generic_names = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var interpolateName = require_interpolateName();
+	var path = __require("path");
+	/**
+	* @param  {string} pattern
+	* @param  {object} options
+	* @param  {string} options.context
+	* @param  {string} options.hashPrefix
+	* @return {function}
+	*/
+	module.exports = function createGenerator(pattern, options) {
+		options = options || {};
+		var context = options && typeof options.context === "string" ? options.context : process.cwd();
+		var hashPrefix = options && typeof options.hashPrefix === "string" ? options.hashPrefix : "";
+		/**
+		* @param  {string} localName Usually a class name
+		* @param  {string} filepath  Absolute path
+		* @return {string}
+		*/
+		return function generate(localName, filepath) {
+			var name = pattern.replace(/\[local\]/gi, localName);
+			return interpolateName({ resourcePath: filepath }, name, {
+				content: hashPrefix + path.relative(context, filepath).replace(/\\/g, "/") + "\0" + localName,
+				context
+			}).replace(/* @__PURE__ */ new RegExp("[^a-zA-Z0-9\\-_\xA0-￿]", "g"), "-").replace(/^((-?[0-9])|--)/, "_$1");
+		};
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/util/unesc.js
+var require_unesc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = unesc;
+	/**
+	* 
+	* @param {string} str 
+	* @returns {[string, number]|undefined}
+	*/
+	function gobbleHex(str) {
+		var lower = str.toLowerCase();
+		var hex = "";
+		var spaceTerminated = false;
+		for (var i = 0; i < 6 && lower[i] !== void 0; i++) {
+			var code = lower.charCodeAt(i);
+			var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
+			spaceTerminated = code === 32;
+			if (!valid) break;
+			hex += lower[i];
+		}
+		if (hex.length === 0) return;
+		var codePoint = parseInt(hex, 16);
+		if (codePoint >= 55296 && codePoint <= 57343 || codePoint === 0 || codePoint > 1114111) return ["�", hex.length + (spaceTerminated ? 1 : 0)];
+		return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
+	}
+	var CONTAINS_ESCAPE = /\\/;
+	function unesc(str) {
+		if (!CONTAINS_ESCAPE.test(str)) return str;
+		var ret = "";
+		for (var i = 0; i < str.length; i++) {
+			if (str[i] === "\\") {
+				var gobbled = gobbleHex(str.slice(i + 1, i + 7));
+				if (gobbled !== void 0) {
+					ret += gobbled[0];
+					i += gobbled[1];
+					continue;
+				}
+				if (str[i + 1] === "\\") {
+					ret += "\\";
+					i++;
+					continue;
+				}
+				if (str.length === i + 1) ret += str[i];
+				continue;
+			}
+			ret += str[i];
+		}
+		return ret;
+	}
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/util/getProp.js
+var require_getProp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = getProp;
+	function getProp(obj) {
+		for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) props[_key - 1] = arguments[_key];
+		while (props.length > 0) {
+			var prop = props.shift();
+			if (!obj[prop]) return;
+			obj = obj[prop];
+		}
+		return obj;
+	}
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/util/ensureObject.js
+var require_ensureObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = ensureObject;
+	function ensureObject(obj) {
+		for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) props[_key - 1] = arguments[_key];
+		while (props.length > 0) {
+			var prop = props.shift();
+			if (!obj[prop]) obj[prop] = {};
+			obj = obj[prop];
+		}
+	}
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/util/stripComments.js
+var require_stripComments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = stripComments;
+	function stripComments(str) {
+		var s = "";
+		var commentStart = str.indexOf("/*");
+		var lastEnd = 0;
+		while (commentStart >= 0) {
+			s = s + str.slice(lastEnd, commentStart);
+			var commentEnd = str.indexOf("*/", commentStart + 2);
+			if (commentEnd < 0) return s;
+			lastEnd = commentEnd + 2;
+			commentStart = str.indexOf("/*", lastEnd);
+		}
+		s = s + str.slice(lastEnd);
+		return s;
+	}
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/util/index.js
+var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.unesc = exports.stripComments = exports.getProp = exports.ensureObject = void 0;
+	exports.unesc = _interopRequireDefault(require_unesc())["default"];
+	exports.getProp = _interopRequireDefault(require_getProp())["default"];
+	exports.ensureObject = _interopRequireDefault(require_ensureObject())["default"];
+	exports.stripComments = _interopRequireDefault(require_stripComments())["default"];
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/node.js
+var require_node$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _util = require_util();
+	function _defineProperties(target, props) {
+		for (var i = 0; i < props.length; i++) {
+			var descriptor = props[i];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	var cloneNode = function cloneNode(obj, parent) {
+		if (typeof obj !== "object" || obj === null) return obj;
+		var cloned = new obj.constructor();
+		for (var i in obj) {
+			if (!obj.hasOwnProperty(i)) continue;
+			var value = obj[i];
+			if (i === "parent" && typeof value === "object") {
+				if (parent) cloned[i] = parent;
+			} else if (value instanceof Array) cloned[i] = value.map(function(j) {
+				return cloneNode(j, cloned);
+			});
+			else cloned[i] = cloneNode(value, cloned);
+		}
+		return cloned;
+	};
+	exports["default"] = /* @__PURE__ */ function() {
+		function Node(opts) {
+			if (opts === void 0) opts = {};
+			Object.assign(this, opts);
+			this.spaces = this.spaces || {};
+			this.spaces.before = this.spaces.before || "";
+			this.spaces.after = this.spaces.after || "";
+		}
+		var _proto = Node.prototype;
+		_proto.remove = function remove() {
+			if (this.parent) this.parent.removeChild(this);
+			this.parent = void 0;
+			return this;
+		};
+		_proto.replaceWith = function replaceWith() {
+			if (this.parent) {
+				for (var index in arguments) this.parent.insertBefore(this, arguments[index]);
+				this.remove();
+			}
+			return this;
+		};
+		_proto.next = function next() {
+			return this.parent.at(this.parent.index(this) + 1);
+		};
+		_proto.prev = function prev() {
+			return this.parent.at(this.parent.index(this) - 1);
+		};
+		_proto.clone = function clone(overrides) {
+			if (overrides === void 0) overrides = {};
+			var cloned = cloneNode(this);
+			for (var name in overrides) cloned[name] = overrides[name];
+			return cloned;
+		};
+		_proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
+			if (!this.raws) this.raws = {};
+			var originalValue = this[name];
+			var originalEscaped = this.raws[name];
+			this[name] = originalValue + value;
+			if (originalEscaped || valueEscaped !== value) this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
+			else delete this.raws[name];
+		};
+		_proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
+			if (!this.raws) this.raws = {};
+			this[name] = value;
+			this.raws[name] = valueEscaped;
+		};
+		_proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
+			this[name] = value;
+			if (this.raws) delete this.raws[name];
+		};
+		_proto.isAtPosition = function isAtPosition(line, column) {
+			if (this.source && this.source.start && this.source.end) {
+				if (this.source.start.line > line) return false;
+				if (this.source.end.line < line) return false;
+				if (this.source.start.line === line && this.source.start.column > column) return false;
+				if (this.source.end.line === line && this.source.end.column < column) return false;
+				return true;
+			}
+		};
+		_proto.stringifyProperty = function stringifyProperty(name) {
+			return this.raws && this.raws[name] || this[name];
+		};
+		_proto.valueToString = function valueToString() {
+			return String(this.stringifyProperty("value"));
+		};
+		_proto.toString = function toString() {
+			return [
+				this.rawSpaceBefore,
+				this.valueToString(),
+				this.rawSpaceAfter
+			].join("");
+		};
+		_createClass(Node, [{
+			key: "rawSpaceBefore",
+			get: function get() {
+				var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
+				if (rawSpace === void 0) rawSpace = this.spaces && this.spaces.before;
+				return rawSpace || "";
+			},
+			set: function set(raw) {
+				(0, _util.ensureObject)(this, "raws", "spaces");
+				this.raws.spaces.before = raw;
+			}
+		}, {
+			key: "rawSpaceAfter",
+			get: function get() {
+				var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
+				if (rawSpace === void 0) rawSpace = this.spaces.after;
+				return rawSpace || "";
+			},
+			set: function set(raw) {
+				(0, _util.ensureObject)(this, "raws", "spaces");
+				this.raws.spaces.after = raw;
+			}
+		}]);
+		return Node;
+	}();
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/types.js
+var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.UNIVERSAL = exports.TAG = exports.STRING = exports.SELECTOR = exports.ROOT = exports.PSEUDO = exports.NESTING = exports.ID = exports.COMMENT = exports.COMBINATOR = exports.CLASS = exports.ATTRIBUTE = void 0;
+	exports.TAG = "tag";
+	exports.STRING = "string";
+	exports.SELECTOR = "selector";
+	exports.ROOT = "root";
+	exports.PSEUDO = "pseudo";
+	exports.NESTING = "nesting";
+	exports.ID = "id";
+	exports.COMMENT = "comment";
+	exports.COMBINATOR = "combinator";
+	exports.CLASS = "class";
+	exports.ATTRIBUTE = "attribute";
+	exports.UNIVERSAL = "universal";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/container.js
+var require_container = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(require_node$1());
+	var types = _interopRequireWildcard(require_types());
+	function _getRequireWildcardCache(nodeInterop) {
+		if (typeof WeakMap !== "function") return null;
+		var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+		var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+		return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
+			return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+		})(nodeInterop);
+	}
+	function _interopRequireWildcard(obj, nodeInterop) {
+		if (!nodeInterop && obj && obj.__esModule) return obj;
+		if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { "default": obj };
+		var cache = _getRequireWildcardCache(nodeInterop);
+		if (cache && cache.has(obj)) return cache.get(obj);
+		var newObj = {};
+		var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		for (var key in obj) if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+			var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+			if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+			else newObj[key] = obj[key];
+		}
+		newObj["default"] = obj;
+		if (cache) cache.set(obj, newObj);
+		return newObj;
+	}
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+		var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+		if (it) return (it = it.call(o)).next.bind(it);
+		if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+			if (it) o = it;
+			var i = 0;
+			return function() {
+				if (i >= o.length) return { done: true };
+				return {
+					done: false,
+					value: o[i++]
+				};
+			};
+		}
+		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	function _unsupportedIterableToArray(o, minLen) {
+		if (!o) return;
+		if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+		var n = Object.prototype.toString.call(o).slice(8, -1);
+		if (n === "Object" && o.constructor) n = o.constructor.name;
+		if (n === "Map" || n === "Set") return Array.from(o);
+		if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+	}
+	function _arrayLikeToArray(arr, len) {
+		if (len == null || len > arr.length) len = arr.length;
+		for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+		return arr2;
+	}
+	function _defineProperties(target, props) {
+		for (var i = 0; i < props.length; i++) {
+			var descriptor = props[i];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose(Container, _Node);
+		function Container(opts) {
+			var _this = _Node.call(this, opts) || this;
+			if (!_this.nodes) _this.nodes = [];
+			return _this;
+		}
+		var _proto = Container.prototype;
+		_proto.append = function append(selector) {
+			selector.parent = this;
+			this.nodes.push(selector);
+			return this;
+		};
+		_proto.prepend = function prepend(selector) {
+			selector.parent = this;
+			this.nodes.unshift(selector);
+			for (var id in this.indexes) this.indexes[id]++;
+			return this;
+		};
+		_proto.at = function at(index) {
+			return this.nodes[index];
+		};
+		_proto.index = function index(child) {
+			if (typeof child === "number") return child;
+			return this.nodes.indexOf(child);
+		};
+		_proto.removeChild = function removeChild(child) {
+			child = this.index(child);
+			this.at(child).parent = void 0;
+			this.nodes.splice(child, 1);
+			var index;
+			for (var id in this.indexes) {
+				index = this.indexes[id];
+				if (index >= child) this.indexes[id] = index - 1;
+			}
+			return this;
+		};
+		_proto.removeAll = function removeAll() {
+			for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done;) {
+				var node = _step.value;
+				node.parent = void 0;
+			}
+			this.nodes = [];
+			return this;
+		};
+		_proto.empty = function empty() {
+			return this.removeAll();
+		};
+		_proto.insertAfter = function insertAfter(oldNode, newNode) {
+			var _this$nodes;
+			newNode.parent = this;
+			var oldIndex = this.index(oldNode);
+			var resetNode = [];
+			for (var i = 2; i < arguments.length; i++) resetNode.push(arguments[i]);
+			(_this$nodes = this.nodes).splice.apply(_this$nodes, [
+				oldIndex + 1,
+				0,
+				newNode
+			].concat(resetNode));
+			newNode.parent = this;
+			var index;
+			for (var id in this.indexes) {
+				index = this.indexes[id];
+				if (oldIndex < index) this.indexes[id] = index + arguments.length - 1;
+			}
+			return this;
+		};
+		_proto.insertBefore = function insertBefore(oldNode, newNode) {
+			var _this$nodes2;
+			newNode.parent = this;
+			var oldIndex = this.index(oldNode);
+			var resetNode = [];
+			for (var i = 2; i < arguments.length; i++) resetNode.push(arguments[i]);
+			(_this$nodes2 = this.nodes).splice.apply(_this$nodes2, [
+				oldIndex,
+				0,
+				newNode
+			].concat(resetNode));
+			newNode.parent = this;
+			var index;
+			for (var id in this.indexes) {
+				index = this.indexes[id];
+				if (index >= oldIndex) this.indexes[id] = index + arguments.length - 1;
+			}
+			return this;
+		};
+		_proto._findChildAtPosition = function _findChildAtPosition(line, col) {
+			var found = void 0;
+			this.each(function(node) {
+				if (node.atPosition) {
+					var foundChild = node.atPosition(line, col);
+					if (foundChild) {
+						found = foundChild;
+						return false;
+					}
+				} else if (node.isAtPosition(line, col)) {
+					found = node;
+					return false;
+				}
+			});
+			return found;
+		};
+		_proto.atPosition = function atPosition(line, col) {
+			if (this.isAtPosition(line, col)) return this._findChildAtPosition(line, col) || this;
+			else return;
+		};
+		_proto._inferEndPosition = function _inferEndPosition() {
+			if (this.last && this.last.source && this.last.source.end) {
+				this.source = this.source || {};
+				this.source.end = this.source.end || {};
+				Object.assign(this.source.end, this.last.source.end);
+			}
+		};
+		_proto.each = function each(callback) {
+			if (!this.lastEach) this.lastEach = 0;
+			if (!this.indexes) this.indexes = {};
+			this.lastEach++;
+			var id = this.lastEach;
+			this.indexes[id] = 0;
+			if (!this.length) return;
+			var index, result;
+			while (this.indexes[id] < this.length) {
+				index = this.indexes[id];
+				result = callback(this.at(index), index);
+				if (result === false) break;
+				this.indexes[id] += 1;
+			}
+			delete this.indexes[id];
+			if (result === false) return false;
+		};
+		_proto.walk = function walk(callback) {
+			return this.each(function(node, i) {
+				var result = callback(node, i);
+				if (result !== false && node.length) result = node.walk(callback);
+				if (result === false) return false;
+			});
+		};
+		_proto.walkAttributes = function walkAttributes(callback) {
+			var _this2 = this;
+			return this.walk(function(selector) {
+				if (selector.type === types.ATTRIBUTE) return callback.call(_this2, selector);
+			});
+		};
+		_proto.walkClasses = function walkClasses(callback) {
+			var _this3 = this;
+			return this.walk(function(selector) {
+				if (selector.type === types.CLASS) return callback.call(_this3, selector);
+			});
+		};
+		_proto.walkCombinators = function walkCombinators(callback) {
+			var _this4 = this;
+			return this.walk(function(selector) {
+				if (selector.type === types.COMBINATOR) return callback.call(_this4, selector);
+			});
+		};
+		_proto.walkComments = function walkComments(callback) {
+			var _this5 = this;
+			return this.walk(function(selector) {
+				if (selector.type === types.COMMENT) return callback.call(_this5, selector);
+			});
+		};
+		_proto.walkIds = function walkIds(callback) {
+			var _this6 = this;
+			return this.walk(function(selector) {
+				if (selector.type === types.ID) return callback.call(_this6, selector);
+			});
+		};
+		_proto.walkNesting = function walkNesting(callback) {
+			var _this7 = this;
+			return this.walk(function(selector) {
+				if (selector.type === types.NESTING) return callback.call(_this7, selector);
+			});
+		};
+		_proto.walkPseudos = function walkPseudos(callback) {
+			var _this8 = this;
+			return this.walk(function(selector) {
+				if (selector.type === types.PSEUDO) return callback.call(_this8, selector);
+			});
+		};
+		_proto.walkTags = function walkTags(callback) {
+			var _this9 = this;
+			return this.walk(function(selector) {
+				if (selector.type === types.TAG) return callback.call(_this9, selector);
+			});
+		};
+		_proto.walkUniversals = function walkUniversals(callback) {
+			var _this10 = this;
+			return this.walk(function(selector) {
+				if (selector.type === types.UNIVERSAL) return callback.call(_this10, selector);
+			});
+		};
+		_proto.split = function split(callback) {
+			var _this11 = this;
+			var current = [];
+			return this.reduce(function(memo, node, index) {
+				var split = callback.call(_this11, node);
+				current.push(node);
+				if (split) {
+					memo.push(current);
+					current = [];
+				} else if (index === _this11.length - 1) memo.push(current);
+				return memo;
+			}, []);
+		};
+		_proto.map = function map(callback) {
+			return this.nodes.map(callback);
+		};
+		_proto.reduce = function reduce(callback, memo) {
+			return this.nodes.reduce(callback, memo);
+		};
+		_proto.every = function every(callback) {
+			return this.nodes.every(callback);
+		};
+		_proto.some = function some(callback) {
+			return this.nodes.some(callback);
+		};
+		_proto.filter = function filter(callback) {
+			return this.nodes.filter(callback);
+		};
+		_proto.sort = function sort(callback) {
+			return this.nodes.sort(callback);
+		};
+		_proto.toString = function toString() {
+			return this.map(String).join("");
+		};
+		_createClass(Container, [
+			{
+				key: "first",
+				get: function get() {
+					return this.at(0);
+				}
+			},
+			{
+				key: "last",
+				get: function get() {
+					return this.at(this.length - 1);
+				}
+			},
+			{
+				key: "length",
+				get: function get() {
+					return this.nodes.length;
+				}
+			}
+		]);
+		return Container;
+	}(_node["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/root.js
+var require_root = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _container = _interopRequireDefault(require_container());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties(target, props) {
+		for (var i = 0; i < props.length; i++) {
+			var descriptor = props[i];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Container) {
+		_inheritsLoose(Root, _Container);
+		function Root(opts) {
+			var _this = _Container.call(this, opts) || this;
+			_this.type = _types.ROOT;
+			return _this;
+		}
+		var _proto = Root.prototype;
+		_proto.toString = function toString() {
+			var str = this.reduce(function(memo, selector) {
+				memo.push(String(selector));
+				return memo;
+			}, []).join(",");
+			return this.trailingComma ? str + "," : str;
+		};
+		_proto.error = function error(message, options) {
+			if (this._error) return this._error(message, options);
+			else return new Error(message);
+		};
+		_createClass(Root, [{
+			key: "errorGenerator",
+			set: function set(handler) {
+				this._error = handler;
+			}
+		}]);
+		return Root;
+	}(_container["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/selector.js
+var require_selector = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _container = _interopRequireDefault(require_container());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Container) {
+		_inheritsLoose(Selector, _Container);
+		function Selector(opts) {
+			var _this = _Container.call(this, opts) || this;
+			_this.type = _types.SELECTOR;
+			return _this;
+		}
+		return Selector;
+	}(_container["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cssesc@3.0.0/node_modules/cssesc/cssesc.js
+/*! https://mths.be/cssesc v3.0.0 by @mathias */
+var require_cssesc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasOwnProperty = {}.hasOwnProperty;
+	var merge = function merge(options, defaults) {
+		if (!options) return defaults;
+		var result = {};
+		for (var key in defaults) result[key] = hasOwnProperty.call(options, key) ? options[key] : defaults[key];
+		return result;
+	};
+	var regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
+	var regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
+	var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
+	var cssesc = function cssesc(string, options) {
+		options = merge(options, cssesc.options);
+		if (options.quotes != "single" && options.quotes != "double") options.quotes = "single";
+		var quote = options.quotes == "double" ? "\"" : "'";
+		var isIdentifier = options.isIdentifier;
+		var firstChar = string.charAt(0);
+		var output = "";
+		var counter = 0;
+		var length = string.length;
+		while (counter < length) {
+			var character = string.charAt(counter++);
+			var codePoint = character.charCodeAt();
+			var value = void 0;
+			if (codePoint < 32 || codePoint > 126) {
+				if (codePoint >= 55296 && codePoint <= 56319 && counter < length) {
+					var extra = string.charCodeAt(counter++);
+					if ((extra & 64512) == 56320) codePoint = ((codePoint & 1023) << 10) + (extra & 1023) + 65536;
+					else counter--;
+				}
+				value = "\\" + codePoint.toString(16).toUpperCase() + " ";
+			} else if (options.escapeEverything) if (regexAnySingleEscape.test(character)) value = "\\" + character;
+			else value = "\\" + codePoint.toString(16).toUpperCase() + " ";
+			else if (/[\t\n\f\r\x0B]/.test(character)) value = "\\" + codePoint.toString(16).toUpperCase() + " ";
+			else if (character == "\\" || !isIdentifier && (character == "\"" && quote == character || character == "'" && quote == character) || isIdentifier && regexSingleEscape.test(character)) value = "\\" + character;
+			else value = character;
+			output += value;
+		}
+		if (isIdentifier) {
+			if (/^-[-\d]/.test(output)) output = "\\-" + output.slice(1);
+			else if (/\d/.test(firstChar)) output = "\\3" + firstChar + " " + output.slice(1);
+		}
+		output = output.replace(regexExcessiveSpaces, function($0, $1, $2) {
+			if ($1 && $1.length % 2) return $0;
+			return ($1 || "") + $2;
+		});
+		if (!isIdentifier && options.wrap) return quote + output + quote;
+		return output;
+	};
+	cssesc.options = {
+		"escapeEverything": false,
+		"isIdentifier": false,
+		"quotes": "single",
+		"wrap": false
+	};
+	cssesc.version = "3.0.0";
+	module.exports = cssesc;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/className.js
+var require_className = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _cssesc = _interopRequireDefault(require_cssesc());
+	var _util = require_util();
+	var _node = _interopRequireDefault(require_node$1());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties(target, props) {
+		for (var i = 0; i < props.length; i++) {
+			var descriptor = props[i];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose(ClassName, _Node);
+		function ClassName(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types.CLASS;
+			_this._constructed = true;
+			return _this;
+		}
+		var _proto = ClassName.prototype;
+		_proto.valueToString = function valueToString() {
+			return "." + _Node.prototype.valueToString.call(this);
+		};
+		_createClass(ClassName, [{
+			key: "value",
+			get: function get() {
+				return this._value;
+			},
+			set: function set(v) {
+				if (this._constructed) {
+					var escaped = (0, _cssesc["default"])(v, { isIdentifier: true });
+					if (escaped !== v) {
+						(0, _util.ensureObject)(this, "raws");
+						this.raws.value = escaped;
+					} else if (this.raws) delete this.raws.value;
+				}
+				this._value = v;
+			}
+		}]);
+		return ClassName;
+	}(_node["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/comment.js
+var require_comment = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(require_node$1());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose(Comment, _Node);
+		function Comment(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types.COMMENT;
+			return _this;
+		}
+		return Comment;
+	}(_node["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/id.js
+var require_id = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(require_node$1());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose(ID, _Node);
+		function ID(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types.ID;
+			return _this;
+		}
+		var _proto = ID.prototype;
+		_proto.valueToString = function valueToString() {
+			return "#" + _Node.prototype.valueToString.call(this);
+		};
+		return ID;
+	}(_node["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/namespace.js
+var require_namespace = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _cssesc = _interopRequireDefault(require_cssesc());
+	var _util = require_util();
+	var _node = _interopRequireDefault(require_node$1());
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties(target, props) {
+		for (var i = 0; i < props.length; i++) {
+			var descriptor = props[i];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose(Namespace, _Node);
+		function Namespace() {
+			return _Node.apply(this, arguments) || this;
+		}
+		var _proto = Namespace.prototype;
+		_proto.qualifiedName = function qualifiedName(value) {
+			if (this.namespace) return this.namespaceString + "|" + value;
+			else return value;
+		};
+		_proto.valueToString = function valueToString() {
+			return this.qualifiedName(_Node.prototype.valueToString.call(this));
+		};
+		_createClass(Namespace, [
+			{
+				key: "namespace",
+				get: function get() {
+					return this._namespace;
+				},
+				set: function set(namespace) {
+					if (namespace === true || namespace === "*" || namespace === "&") {
+						this._namespace = namespace;
+						if (this.raws) delete this.raws.namespace;
+						return;
+					}
+					var escaped = (0, _cssesc["default"])(namespace, { isIdentifier: true });
+					this._namespace = namespace;
+					if (escaped !== namespace) {
+						(0, _util.ensureObject)(this, "raws");
+						this.raws.namespace = escaped;
+					} else if (this.raws) delete this.raws.namespace;
+				}
+			},
+			{
+				key: "ns",
+				get: function get() {
+					return this._namespace;
+				},
+				set: function set(namespace) {
+					this.namespace = namespace;
+				}
+			},
+			{
+				key: "namespaceString",
+				get: function get() {
+					if (this.namespace) {
+						var ns = this.stringifyProperty("namespace");
+						if (ns === true) return "";
+						else return ns;
+					} else return "";
+				}
+			}
+		]);
+		return Namespace;
+	}(_node["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/tag.js
+var require_tag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _namespace = _interopRequireDefault(require_namespace());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Namespace) {
+		_inheritsLoose(Tag, _Namespace);
+		function Tag(opts) {
+			var _this = _Namespace.call(this, opts) || this;
+			_this.type = _types.TAG;
+			return _this;
+		}
+		return Tag;
+	}(_namespace["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/string.js
+var require_string = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(require_node$1());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose(String, _Node);
+		function String(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types.STRING;
+			return _this;
+		}
+		return String;
+	}(_node["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
+var require_pseudo = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _container = _interopRequireDefault(require_container());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Container) {
+		_inheritsLoose(Pseudo, _Container);
+		function Pseudo(opts) {
+			var _this = _Container.call(this, opts) || this;
+			_this.type = _types.PSEUDO;
+			return _this;
+		}
+		var _proto = Pseudo.prototype;
+		_proto.toString = function toString() {
+			var params = this.length ? "(" + this.map(String).join(",") + ")" : "";
+			return [
+				this.rawSpaceBefore,
+				this.stringifyProperty("value"),
+				params,
+				this.rawSpaceAfter
+			].join("");
+		};
+		return Pseudo;
+	}(_container["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/util-deprecate@1.0.2/node_modules/util-deprecate/node.js
+var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* For Node.js, simply re-export the core `util.deprecate` function.
+	*/
+	module.exports = __require("util").deprecate;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/attribute.js
+var require_attribute = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	exports.unescapeValue = unescapeValue;
+	var _cssesc = _interopRequireDefault(require_cssesc());
+	var _unesc = _interopRequireDefault(require_unesc());
+	var _namespace = _interopRequireDefault(require_namespace());
+	var _types = require_types();
+	var _CSSESC_QUOTE_OPTIONS;
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties(target, props) {
+		for (var i = 0; i < props.length; i++) {
+			var descriptor = props[i];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	var deprecate = require_node();
+	var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
+	var warnOfDeprecatedValueAssignment = deprecate(function() {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.");
+	var warnOfDeprecatedQuotedAssignment = deprecate(function() {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
+	var warnOfDeprecatedConstructor = deprecate(function() {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
+	function unescapeValue(value) {
+		var deprecatedUsage = false;
+		var quoteMark = null;
+		var unescaped = value;
+		var m = unescaped.match(WRAPPED_IN_QUOTES);
+		if (m) {
+			quoteMark = m[1];
+			unescaped = m[2];
+		}
+		unescaped = (0, _unesc["default"])(unescaped);
+		if (unescaped !== value) deprecatedUsage = true;
+		return {
+			deprecatedUsage,
+			unescaped,
+			quoteMark
+		};
+	}
+	function handleDeprecatedContructorOpts(opts) {
+		if (opts.quoteMark !== void 0) return opts;
+		if (opts.value === void 0) return opts;
+		warnOfDeprecatedConstructor();
+		var _unescapeValue = unescapeValue(opts.value), quoteMark = _unescapeValue.quoteMark, unescaped = _unescapeValue.unescaped;
+		if (!opts.raws) opts.raws = {};
+		if (opts.raws.value === void 0) opts.raws.value = opts.value;
+		opts.value = unescaped;
+		opts.quoteMark = quoteMark;
+		return opts;
+	}
+	var Attribute = /* @__PURE__ */ function(_Namespace) {
+		_inheritsLoose(Attribute, _Namespace);
+		function Attribute(opts) {
+			var _this;
+			if (opts === void 0) opts = {};
+			_this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
+			_this.type = _types.ATTRIBUTE;
+			_this.raws = _this.raws || {};
+			Object.defineProperty(_this.raws, "unquoted", {
+				get: deprecate(function() {
+					return _this.value;
+				}, "attr.raws.unquoted is deprecated. Call attr.value instead."),
+				set: deprecate(function() {
+					return _this.value;
+				}, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
+			});
+			_this._constructed = true;
+			return _this;
+		}
+		/**
+		* Returns the Attribute's value quoted such that it would be legal to use
+		* in the value of a css file. The original value's quotation setting
+		* used for stringification is left unchanged. See `setValue(value, options)`
+		* if you want to control the quote settings of a new value for the attribute.
+		*
+		* You can also change the quotation used for the current value by setting quoteMark.
+		*
+		* Options:
+		*   * quoteMark {'"' | "'" | null} - Use this value to quote the value. If this
+		*     option is not set, the original value for quoteMark will be used. If
+		*     indeterminate, a double quote is used. The legal values are:
+		*     * `null` - the value will be unquoted and characters will be escaped as necessary.
+		*     * `'` - the value will be quoted with a single quote and single quotes are escaped.
+		*     * `"` - the value will be quoted with a double quote and double quotes are escaped.
+		*   * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark
+		*     over the quoteMark option value.
+		*   * smart {boolean} - if true, will select a quote mark based on the value
+		*     and the other options specified here. See the `smartQuoteMark()`
+		*     method.
+		**/
+		var _proto = Attribute.prototype;
+		_proto.getQuotedValue = function getQuotedValue(options) {
+			if (options === void 0) options = {};
+			var cssescopts = CSSESC_QUOTE_OPTIONS[this._determineQuoteMark(options)];
+			return (0, _cssesc["default"])(this._value, cssescopts);
+		};
+		_proto._determineQuoteMark = function _determineQuoteMark(options) {
+			return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
+		};
+		_proto.setValue = function setValue(value, options) {
+			if (options === void 0) options = {};
+			this._value = value;
+			this._quoteMark = this._determineQuoteMark(options);
+			this._syncRawValue();
+		};
+		_proto.smartQuoteMark = function smartQuoteMark(options) {
+			var v = this.value;
+			var numSingleQuotes = v.replace(/[^']/g, "").length;
+			var numDoubleQuotes = v.replace(/[^"]/g, "").length;
+			if (numSingleQuotes + numDoubleQuotes === 0) {
+				var escaped = (0, _cssesc["default"])(v, { isIdentifier: true });
+				if (escaped === v) return Attribute.NO_QUOTE;
+				else {
+					var pref = this.preferredQuoteMark(options);
+					if (pref === Attribute.NO_QUOTE) {
+						var quote = this.quoteMark || options.quoteMark || Attribute.DOUBLE_QUOTE;
+						if ((0, _cssesc["default"])(v, CSSESC_QUOTE_OPTIONS[quote]).length < escaped.length) return quote;
+					}
+					return pref;
+				}
+			} else if (numDoubleQuotes === numSingleQuotes) return this.preferredQuoteMark(options);
+			else if (numDoubleQuotes < numSingleQuotes) return Attribute.DOUBLE_QUOTE;
+			else return Attribute.SINGLE_QUOTE;
+		};
+		_proto.preferredQuoteMark = function preferredQuoteMark(options) {
+			var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
+			if (quoteMark === void 0) quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
+			if (quoteMark === void 0) quoteMark = Attribute.DOUBLE_QUOTE;
+			return quoteMark;
+		};
+		_proto._syncRawValue = function _syncRawValue() {
+			var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
+			if (rawValue === this._value) {
+				if (this.raws) delete this.raws.value;
+			} else this.raws.value = rawValue;
+		};
+		_proto._handleEscapes = function _handleEscapes(prop, value) {
+			if (this._constructed) {
+				var escaped = (0, _cssesc["default"])(value, { isIdentifier: true });
+				if (escaped !== value) this.raws[prop] = escaped;
+				else delete this.raws[prop];
+			}
+		};
+		_proto._spacesFor = function _spacesFor(name) {
+			var attrSpaces = {
+				before: "",
+				after: ""
+			};
+			var spaces = this.spaces[name] || {};
+			var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
+			return Object.assign(attrSpaces, spaces, rawSpaces);
+		};
+		_proto._stringFor = function _stringFor(name, spaceName, concat) {
+			if (spaceName === void 0) spaceName = name;
+			if (concat === void 0) concat = defaultAttrConcat;
+			var attrSpaces = this._spacesFor(spaceName);
+			return concat(this.stringifyProperty(name), attrSpaces);
+		};
+		_proto.offsetOf = function offsetOf(name) {
+			var count = 1;
+			var attributeSpaces = this._spacesFor("attribute");
+			count += attributeSpaces.before.length;
+			if (name === "namespace" || name === "ns") return this.namespace ? count : -1;
+			if (name === "attributeNS") return count;
+			count += this.namespaceString.length;
+			if (this.namespace) count += 1;
+			if (name === "attribute") return count;
+			count += this.stringifyProperty("attribute").length;
+			count += attributeSpaces.after.length;
+			var operatorSpaces = this._spacesFor("operator");
+			count += operatorSpaces.before.length;
+			var operator = this.stringifyProperty("operator");
+			if (name === "operator") return operator ? count : -1;
+			count += operator.length;
+			count += operatorSpaces.after.length;
+			var valueSpaces = this._spacesFor("value");
+			count += valueSpaces.before.length;
+			var value = this.stringifyProperty("value");
+			if (name === "value") return value ? count : -1;
+			count += value.length;
+			count += valueSpaces.after.length;
+			var insensitiveSpaces = this._spacesFor("insensitive");
+			count += insensitiveSpaces.before.length;
+			if (name === "insensitive") return this.insensitive ? count : -1;
+			return -1;
+		};
+		_proto.toString = function toString() {
+			var _this2 = this;
+			var selector = [this.rawSpaceBefore, "["];
+			selector.push(this._stringFor("qualifiedAttribute", "attribute"));
+			if (this.operator && (this.value || this.value === "")) {
+				selector.push(this._stringFor("operator"));
+				selector.push(this._stringFor("value"));
+				selector.push(this._stringFor("insensitiveFlag", "insensitive", function(attrValue, attrSpaces) {
+					if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) attrSpaces.before = " ";
+					return defaultAttrConcat(attrValue, attrSpaces);
+				}));
+			}
+			selector.push("]");
+			selector.push(this.rawSpaceAfter);
+			return selector.join("");
+		};
+		_createClass(Attribute, [
+			{
+				key: "quoted",
+				get: function get() {
+					var qm = this.quoteMark;
+					return qm === "'" || qm === "\"";
+				},
+				set: function set(value) {
+					warnOfDeprecatedQuotedAssignment();
+				}
+			},
+			{
+				key: "quoteMark",
+				get: function get() {
+					return this._quoteMark;
+				},
+				set: function set(quoteMark) {
+					if (!this._constructed) {
+						this._quoteMark = quoteMark;
+						return;
+					}
+					if (this._quoteMark !== quoteMark) {
+						this._quoteMark = quoteMark;
+						this._syncRawValue();
+					}
+				}
+			},
+			{
+				key: "qualifiedAttribute",
+				get: function get() {
+					return this.qualifiedName(this.raws.attribute || this.attribute);
+				}
+			},
+			{
+				key: "insensitiveFlag",
+				get: function get() {
+					return this.insensitive ? "i" : "";
+				}
+			},
+			{
+				key: "value",
+				get: function get() {
+					return this._value;
+				},
+				set: function set(v) {
+					if (this._constructed) {
+						var _unescapeValue2 = unescapeValue(v), deprecatedUsage = _unescapeValue2.deprecatedUsage, unescaped = _unescapeValue2.unescaped, quoteMark = _unescapeValue2.quoteMark;
+						if (deprecatedUsage) warnOfDeprecatedValueAssignment();
+						if (unescaped === this._value && quoteMark === this._quoteMark) return;
+						this._value = unescaped;
+						this._quoteMark = quoteMark;
+						this._syncRawValue();
+					} else this._value = v;
+				}
+			},
+			{
+				key: "insensitive",
+				get: function get() {
+					return this._insensitive;
+				},
+				set: function set(insensitive) {
+					if (!insensitive) {
+						this._insensitive = false;
+						if (this.raws && (this.raws.insensitiveFlag === "I" || this.raws.insensitiveFlag === "i")) this.raws.insensitiveFlag = void 0;
+					}
+					this._insensitive = insensitive;
+				}
+			},
+			{
+				key: "attribute",
+				get: function get() {
+					return this._attribute;
+				},
+				set: function set(name) {
+					this._handleEscapes("attribute", name);
+					this._attribute = name;
+				}
+			}
+		]);
+		return Attribute;
+	}(_namespace["default"]);
+	exports["default"] = Attribute;
+	Attribute.NO_QUOTE = null;
+	Attribute.SINGLE_QUOTE = "'";
+	Attribute.DOUBLE_QUOTE = "\"";
+	var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = {
+		"'": {
+			quotes: "single",
+			wrap: true
+		},
+		"\"": {
+			quotes: "double",
+			wrap: true
+		}
+	}, _CSSESC_QUOTE_OPTIONS[null] = { isIdentifier: true }, _CSSESC_QUOTE_OPTIONS);
+	function defaultAttrConcat(attrValue, attrSpaces) {
+		return "" + attrSpaces.before + attrValue + attrSpaces.after;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/universal.js
+var require_universal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _namespace = _interopRequireDefault(require_namespace());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Namespace) {
+		_inheritsLoose(Universal, _Namespace);
+		function Universal(opts) {
+			var _this = _Namespace.call(this, opts) || this;
+			_this.type = _types.UNIVERSAL;
+			_this.value = "*";
+			return _this;
+		}
+		return Universal;
+	}(_namespace["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/combinator.js
+var require_combinator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(require_node$1());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose(Combinator, _Node);
+		function Combinator(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types.COMBINATOR;
+			return _this;
+		}
+		return Combinator;
+	}(_node["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/nesting.js
+var require_nesting = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(require_node$1());
+	var _types = require_types();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	exports["default"] = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose(Nesting, _Node);
+		function Nesting(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types.NESTING;
+			_this.value = "&";
+			return _this;
+		}
+		return Nesting;
+	}(_node["default"]);
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/sortAscending.js
+var require_sortAscending = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = sortAscending;
+	function sortAscending(list) {
+		return list.sort(function(a, b) {
+			return a - b;
+		});
+	}
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/tokenTypes.js
+var require_tokenTypes = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.word = exports.tilde = exports.tab = exports.str = exports.space = exports.slash = exports.singleQuote = exports.semicolon = exports.plus = exports.pipe = exports.openSquare = exports.openParenthesis = exports.newline = exports.greaterThan = exports.feed = exports.equals = exports.doubleQuote = exports.dollar = exports.cr = exports.comment = exports.comma = exports.combinator = exports.colon = exports.closeSquare = exports.closeParenthesis = exports.caret = exports.bang = exports.backslash = exports.at = exports.asterisk = exports.ampersand = void 0;
+	exports.ampersand = 38;
+	exports.asterisk = 42;
+	exports.at = 64;
+	exports.comma = 44;
+	exports.colon = 58;
+	exports.semicolon = 59;
+	exports.openParenthesis = 40;
+	exports.closeParenthesis = 41;
+	exports.openSquare = 91;
+	exports.closeSquare = 93;
+	exports.dollar = 36;
+	exports.tilde = 126;
+	exports.caret = 94;
+	exports.plus = 43;
+	exports.equals = 61;
+	exports.pipe = 124;
+	exports.greaterThan = 62;
+	exports.space = 32;
+	var singleQuote = 39;
+	exports.singleQuote = singleQuote;
+	exports.doubleQuote = 34;
+	exports.slash = 47;
+	exports.bang = 33;
+	exports.backslash = 92;
+	exports.cr = 13;
+	exports.feed = 12;
+	exports.newline = 10;
+	exports.tab = 9;
+	exports.str = singleQuote;
+	exports.comment = -1;
+	exports.word = -2;
+	exports.combinator = -3;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/tokenize.js
+var require_tokenize = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.FIELDS = void 0;
+	exports["default"] = tokenize;
+	var t = _interopRequireWildcard(require_tokenTypes());
+	var _unescapable, _wordDelimiters;
+	function _getRequireWildcardCache(nodeInterop) {
+		if (typeof WeakMap !== "function") return null;
+		var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+		var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+		return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
+			return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+		})(nodeInterop);
+	}
+	function _interopRequireWildcard(obj, nodeInterop) {
+		if (!nodeInterop && obj && obj.__esModule) return obj;
+		if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { "default": obj };
+		var cache = _getRequireWildcardCache(nodeInterop);
+		if (cache && cache.has(obj)) return cache.get(obj);
+		var newObj = {};
+		var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		for (var key in obj) if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+			var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+			if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+			else newObj[key] = obj[key];
+		}
+		newObj["default"] = obj;
+		if (cache) cache.set(obj, newObj);
+		return newObj;
+	}
+	var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
+	var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters);
+	var hex = {};
+	var hexChars = "0123456789abcdefABCDEF";
+	for (var i = 0; i < hexChars.length; i++) hex[hexChars.charCodeAt(i)] = true;
+	/**
+	*  Returns the last index of the bar css word
+	* @param {string} css The string in which the word begins
+	* @param {number} start The index into the string where word's first letter occurs
+	*/
+	function consumeWord(css, start) {
+		var next = start;
+		var code;
+		do {
+			code = css.charCodeAt(next);
+			if (wordDelimiters[code]) return next - 1;
+			else if (code === t.backslash) next = consumeEscape(css, next) + 1;
+			else next++;
+		} while (next < css.length);
+		return next - 1;
+	}
+	/**
+	*  Returns the last index of the escape sequence
+	* @param {string} css The string in which the sequence begins
+	* @param {number} start The index into the string where escape character (`\`) occurs.
+	*/
+	function consumeEscape(css, start) {
+		var next = start;
+		var code = css.charCodeAt(next + 1);
+		if (unescapable[code]) {} else if (hex[code]) {
+			var hexDigits = 0;
+			do {
+				next++;
+				hexDigits++;
+				code = css.charCodeAt(next + 1);
+			} while (hex[code] && hexDigits < 6);
+			if (hexDigits < 6 && code === t.space) next++;
+		} else next++;
+		return next;
+	}
+	exports.FIELDS = {
+		TYPE: 0,
+		START_LINE: 1,
+		START_COL: 2,
+		END_LINE: 3,
+		END_COL: 4,
+		START_POS: 5,
+		END_POS: 6
+	};
+	function tokenize(input) {
+		var tokens = [];
+		var css = input.css.valueOf();
+		var length = css.length;
+		var offset = -1;
+		var line = 1;
+		var start = 0;
+		var end = 0;
+		var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
+		function unclosed(what, fix) {
+			if (input.safe) {
+				css += fix;
+				next = css.length - 1;
+			} else throw input.error("Unclosed " + what, line, start - offset, start);
+		}
+		while (start < length) {
+			code = css.charCodeAt(start);
+			if (code === t.newline) {
+				offset = start;
+				line += 1;
+			}
+			switch (code) {
+				case t.space:
+				case t.tab:
+				case t.newline:
+				case t.cr:
+				case t.feed:
+					next = start;
+					do {
+						next += 1;
+						code = css.charCodeAt(next);
+						if (code === t.newline) {
+							offset = next;
+							line += 1;
+						}
+					} while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
+					tokenType = t.space;
+					endLine = line;
+					endColumn = next - offset - 1;
+					end = next;
+					break;
+				case t.plus:
+				case t.greaterThan:
+				case t.tilde:
+				case t.pipe:
+					next = start;
+					do {
+						next += 1;
+						code = css.charCodeAt(next);
+					} while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
+					tokenType = t.combinator;
+					endLine = line;
+					endColumn = start - offset;
+					end = next;
+					break;
+				case t.asterisk:
+				case t.ampersand:
+				case t.bang:
+				case t.comma:
+				case t.equals:
+				case t.dollar:
+				case t.caret:
+				case t.openSquare:
+				case t.closeSquare:
+				case t.colon:
+				case t.semicolon:
+				case t.openParenthesis:
+				case t.closeParenthesis:
+					next = start;
+					tokenType = code;
+					endLine = line;
+					endColumn = start - offset;
+					end = next + 1;
+					break;
+				case t.singleQuote:
+				case t.doubleQuote:
+					quote = code === t.singleQuote ? "'" : "\"";
+					next = start;
+					do {
+						escaped = false;
+						next = css.indexOf(quote, next + 1);
+						if (next === -1) unclosed("quote", quote);
+						escapePos = next;
+						while (css.charCodeAt(escapePos - 1) === t.backslash) {
+							escapePos -= 1;
+							escaped = !escaped;
+						}
+					} while (escaped);
+					tokenType = t.str;
+					endLine = line;
+					endColumn = start - offset;
+					end = next + 1;
+					break;
+				default:
+					if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
+						next = css.indexOf("*/", start + 2) + 1;
+						if (next === 0) unclosed("comment", "*/");
+						content = css.slice(start, next + 1);
+						lines = content.split("\n");
+						last = lines.length - 1;
+						if (last > 0) {
+							nextLine = line + last;
+							nextOffset = next - lines[last].length;
+						} else {
+							nextLine = line;
+							nextOffset = offset;
+						}
+						tokenType = t.comment;
+						line = nextLine;
+						endLine = nextLine;
+						endColumn = next - nextOffset;
+					} else if (code === t.slash) {
+						next = start;
+						tokenType = code;
+						endLine = line;
+						endColumn = start - offset;
+						end = next + 1;
+					} else {
+						next = consumeWord(css, start);
+						tokenType = t.word;
+						endLine = line;
+						endColumn = next - offset;
+					}
+					end = next + 1;
+					break;
+			}
+			tokens.push([
+				tokenType,
+				line,
+				start - offset,
+				endLine,
+				endColumn,
+				start,
+				end
+			]);
+			if (nextOffset) {
+				offset = nextOffset;
+				nextOffset = null;
+			}
+			start = end;
+		}
+		return tokens;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/parser.js
+var require_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _root = _interopRequireDefault(require_root());
+	var _selector = _interopRequireDefault(require_selector());
+	var _className = _interopRequireDefault(require_className());
+	var _comment = _interopRequireDefault(require_comment());
+	var _id = _interopRequireDefault(require_id());
+	var _tag = _interopRequireDefault(require_tag());
+	var _string = _interopRequireDefault(require_string());
+	var _pseudo = _interopRequireDefault(require_pseudo());
+	var _attribute = _interopRequireWildcard(require_attribute());
+	var _universal = _interopRequireDefault(require_universal());
+	var _combinator = _interopRequireDefault(require_combinator());
+	var _nesting = _interopRequireDefault(require_nesting());
+	var _sortAscending = _interopRequireDefault(require_sortAscending());
+	var _tokenize = _interopRequireWildcard(require_tokenize());
+	var tokens = _interopRequireWildcard(require_tokenTypes());
+	var types = _interopRequireWildcard(require_types());
+	var _util = require_util();
+	var _WHITESPACE_TOKENS, _Object$assign;
+	function _getRequireWildcardCache(nodeInterop) {
+		if (typeof WeakMap !== "function") return null;
+		var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+		var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+		return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
+			return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+		})(nodeInterop);
+	}
+	function _interopRequireWildcard(obj, nodeInterop) {
+		if (!nodeInterop && obj && obj.__esModule) return obj;
+		if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { "default": obj };
+		var cache = _getRequireWildcardCache(nodeInterop);
+		if (cache && cache.has(obj)) return cache.get(obj);
+		var newObj = {};
+		var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		for (var key in obj) if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+			var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+			if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+			else newObj[key] = obj[key];
+		}
+		newObj["default"] = obj;
+		if (cache) cache.set(obj, newObj);
+		return newObj;
+	}
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties(target, props) {
+		for (var i = 0; i < props.length; i++) {
+			var descriptor = props[i];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	var WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS);
+	var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign));
+	function tokenStart(token) {
+		return {
+			line: token[_tokenize.FIELDS.START_LINE],
+			column: token[_tokenize.FIELDS.START_COL]
+		};
+	}
+	function tokenEnd(token) {
+		return {
+			line: token[_tokenize.FIELDS.END_LINE],
+			column: token[_tokenize.FIELDS.END_COL]
+		};
+	}
+	function getSource(startLine, startColumn, endLine, endColumn) {
+		return {
+			start: {
+				line: startLine,
+				column: startColumn
+			},
+			end: {
+				line: endLine,
+				column: endColumn
+			}
+		};
+	}
+	function getTokenSource(token) {
+		return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
+	}
+	function getTokenSourceSpan(startToken, endToken) {
+		if (!startToken) return;
+		return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
+	}
+	function unescapeProp(node, prop) {
+		var value = node[prop];
+		if (typeof value !== "string") return;
+		if (value.indexOf("\\") !== -1) {
+			(0, _util.ensureObject)(node, "raws");
+			node[prop] = (0, _util.unesc)(value);
+			if (node.raws[prop] === void 0) node.raws[prop] = value;
+		}
+		return node;
+	}
+	function indexesOf(array, item) {
+		var i = -1;
+		var indexes = [];
+		while ((i = array.indexOf(item, i + 1)) !== -1) indexes.push(i);
+		return indexes;
+	}
+	function uniqs() {
+		var list = Array.prototype.concat.apply([], arguments);
+		return list.filter(function(item, i) {
+			return i === list.indexOf(item);
+		});
+	}
+	exports["default"] = /* @__PURE__ */ function() {
+		function Parser(rule, options) {
+			if (options === void 0) options = {};
+			this.rule = rule;
+			this.options = Object.assign({
+				lossy: false,
+				safe: false
+			}, options);
+			this.position = 0;
+			this.css = typeof this.rule === "string" ? this.rule : this.rule.selector;
+			this.tokens = (0, _tokenize["default"])({
+				css: this.css,
+				error: this._errorGenerator(),
+				safe: this.options.safe
+			});
+			var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]);
+			this.root = new _root["default"]({ source: rootSource });
+			this.root.errorGenerator = this._errorGenerator();
+			var selector = new _selector["default"]({
+				source: { start: {
+					line: 1,
+					column: 1
+				} },
+				sourceIndex: 0
+			});
+			this.root.append(selector);
+			this.current = selector;
+			this.loop();
+		}
+		var _proto = Parser.prototype;
+		_proto._errorGenerator = function _errorGenerator() {
+			var _this = this;
+			return function(message, errorOptions) {
+				if (typeof _this.rule === "string") return new Error(message);
+				return _this.rule.error(message, errorOptions);
+			};
+		};
+		_proto.attribute = function attribute() {
+			var attr = [];
+			var startingToken = this.currToken;
+			this.position++;
+			while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+				attr.push(this.currToken);
+				this.position++;
+			}
+			if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) return this.expected("closing square bracket", this.currToken[_tokenize.FIELDS.START_POS]);
+			var len = attr.length;
+			var node = {
+				source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]),
+				sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+			};
+			if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) return this.expected("attribute", attr[0][_tokenize.FIELDS.START_POS]);
+			var pos = 0;
+			var spaceBefore = "";
+			var commentBefore = "";
+			var lastAdded = null;
+			var spaceAfterMeaningfulToken = false;
+			while (pos < len) {
+				var token = attr[pos];
+				var content = this.content(token);
+				var next = attr[pos + 1];
+				switch (token[_tokenize.FIELDS.TYPE]) {
+					case tokens.space:
+						spaceAfterMeaningfulToken = true;
+						if (this.options.lossy) break;
+						if (lastAdded) {
+							(0, _util.ensureObject)(node, "spaces", lastAdded);
+							node.spaces[lastAdded].after = (node.spaces[lastAdded].after || "") + content;
+							var existingComment = (0, _util.getProp)(node, "raws", "spaces", lastAdded, "after") || null;
+							if (existingComment) node.raws.spaces[lastAdded].after = existingComment + content;
+						} else {
+							spaceBefore = spaceBefore + content;
+							commentBefore = commentBefore + content;
+						}
+						break;
+					case tokens.asterisk:
+						if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+							node.operator = content;
+							lastAdded = "operator";
+						} else if ((!node.namespace || lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) {
+							if (spaceBefore) {
+								(0, _util.ensureObject)(node, "spaces", "attribute");
+								node.spaces.attribute.before = spaceBefore;
+								spaceBefore = "";
+							}
+							if (commentBefore) {
+								(0, _util.ensureObject)(node, "raws", "spaces", "attribute");
+								node.raws.spaces.attribute.before = spaceBefore;
+								commentBefore = "";
+							}
+							node.namespace = (node.namespace || "") + content;
+							if ((0, _util.getProp)(node, "raws", "namespace") || null) node.raws.namespace += content;
+							lastAdded = "namespace";
+						}
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.dollar: if (lastAdded === "value") {
+						var oldRawValue = (0, _util.getProp)(node, "raws", "value");
+						node.value += "$";
+						if (oldRawValue) node.raws.value = oldRawValue + "$";
+						break;
+					}
+					case tokens.caret:
+						if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+							node.operator = content;
+							lastAdded = "operator";
+						}
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.combinator:
+						if (content === "~" && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+							node.operator = content;
+							lastAdded = "operator";
+						}
+						if (content !== "|") {
+							spaceAfterMeaningfulToken = false;
+							break;
+						}
+						if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+							node.operator = content;
+							lastAdded = "operator";
+						} else if (!node.namespace && !node.attribute) node.namespace = true;
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.word:
+						if (next && this.content(next) === "|" && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals && !node.operator && !node.namespace) {
+							node.namespace = content;
+							lastAdded = "namespace";
+						} else if (!node.attribute || lastAdded === "attribute" && !spaceAfterMeaningfulToken) {
+							if (spaceBefore) {
+								(0, _util.ensureObject)(node, "spaces", "attribute");
+								node.spaces.attribute.before = spaceBefore;
+								spaceBefore = "";
+							}
+							if (commentBefore) {
+								(0, _util.ensureObject)(node, "raws", "spaces", "attribute");
+								node.raws.spaces.attribute.before = commentBefore;
+								commentBefore = "";
+							}
+							node.attribute = (node.attribute || "") + content;
+							if ((0, _util.getProp)(node, "raws", "attribute") || null) node.raws.attribute += content;
+							lastAdded = "attribute";
+						} else if (!node.value && node.value !== "" || lastAdded === "value" && !(spaceAfterMeaningfulToken || node.quoteMark)) {
+							var _unescaped = (0, _util.unesc)(content);
+							var _oldRawValue = (0, _util.getProp)(node, "raws", "value") || "";
+							var oldValue = node.value || "";
+							node.value = oldValue + _unescaped;
+							node.quoteMark = null;
+							if (_unescaped !== content || _oldRawValue) {
+								(0, _util.ensureObject)(node, "raws");
+								node.raws.value = (_oldRawValue || oldValue) + content;
+							}
+							lastAdded = "value";
+						} else {
+							var insensitive = content === "i" || content === "I";
+							if ((node.value || node.value === "") && (node.quoteMark || spaceAfterMeaningfulToken)) {
+								node.insensitive = insensitive;
+								if (!insensitive || content === "I") {
+									(0, _util.ensureObject)(node, "raws");
+									node.raws.insensitiveFlag = content;
+								}
+								lastAdded = "insensitive";
+								if (spaceBefore) {
+									(0, _util.ensureObject)(node, "spaces", "insensitive");
+									node.spaces.insensitive.before = spaceBefore;
+									spaceBefore = "";
+								}
+								if (commentBefore) {
+									(0, _util.ensureObject)(node, "raws", "spaces", "insensitive");
+									node.raws.spaces.insensitive.before = commentBefore;
+									commentBefore = "";
+								}
+							} else if (node.value || node.value === "") {
+								lastAdded = "value";
+								node.value += content;
+								if (node.raws.value) node.raws.value += content;
+							}
+						}
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.str:
+						if (!node.attribute || !node.operator) return this.error("Expected an attribute followed by an operator preceding the string.", { index: token[_tokenize.FIELDS.START_POS] });
+						var _unescapeValue = (0, _attribute.unescapeValue)(content), unescaped = _unescapeValue.unescaped, quoteMark = _unescapeValue.quoteMark;
+						node.value = unescaped;
+						node.quoteMark = quoteMark;
+						lastAdded = "value";
+						(0, _util.ensureObject)(node, "raws");
+						node.raws.value = content;
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.equals:
+						if (!node.attribute) return this.expected("attribute", token[_tokenize.FIELDS.START_POS], content);
+						if (node.value) return this.error("Unexpected \"=\" found; an operator was already defined.", { index: token[_tokenize.FIELDS.START_POS] });
+						node.operator = node.operator ? node.operator + content : content;
+						lastAdded = "operator";
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.comment:
+						if (lastAdded) if (spaceAfterMeaningfulToken || next && next[_tokenize.FIELDS.TYPE] === tokens.space || lastAdded === "insensitive") {
+							var lastComment = (0, _util.getProp)(node, "spaces", lastAdded, "after") || "";
+							var rawLastComment = (0, _util.getProp)(node, "raws", "spaces", lastAdded, "after") || lastComment;
+							(0, _util.ensureObject)(node, "raws", "spaces", lastAdded);
+							node.raws.spaces[lastAdded].after = rawLastComment + content;
+						} else {
+							var lastValue = node[lastAdded] || "";
+							var rawLastValue = (0, _util.getProp)(node, "raws", lastAdded) || lastValue;
+							(0, _util.ensureObject)(node, "raws");
+							node.raws[lastAdded] = rawLastValue + content;
+						}
+						else commentBefore = commentBefore + content;
+						break;
+					default: return this.error("Unexpected \"" + content + "\" found.", { index: token[_tokenize.FIELDS.START_POS] });
+				}
+				pos++;
+			}
+			unescapeProp(node, "attribute");
+			unescapeProp(node, "namespace");
+			this.newNode(new _attribute["default"](node));
+			this.position++;
+		};
+		_proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
+			if (stopPosition < 0) stopPosition = this.tokens.length;
+			var startPosition = this.position;
+			var nodes = [];
+			var space = "";
+			var lastComment = void 0;
+			do
+				if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
+					if (!this.options.lossy) space += this.content();
+				} else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
+					var spaces = {};
+					if (space) {
+						spaces.before = space;
+						space = "";
+					}
+					lastComment = new _comment["default"]({
+						value: this.content(),
+						source: getTokenSource(this.currToken),
+						sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+						spaces
+					});
+					nodes.push(lastComment);
+				}
+			while (++this.position < stopPosition);
+			if (space) {
+				if (lastComment) lastComment.spaces.after = space;
+				else if (!this.options.lossy) {
+					var firstToken = this.tokens[startPosition];
+					var lastToken = this.tokens[this.position - 1];
+					nodes.push(new _string["default"]({
+						value: "",
+						source: getSource(firstToken[_tokenize.FIELDS.START_LINE], firstToken[_tokenize.FIELDS.START_COL], lastToken[_tokenize.FIELDS.END_LINE], lastToken[_tokenize.FIELDS.END_COL]),
+						sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+						spaces: {
+							before: space,
+							after: ""
+						}
+					}));
+				}
+			}
+			return nodes;
+		};
+		_proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) {
+			var _this2 = this;
+			if (requiredSpace === void 0) requiredSpace = false;
+			var space = "";
+			var rawSpace = "";
+			nodes.forEach(function(n) {
+				var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
+				var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
+				space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
+				rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
+			});
+			if (rawSpace === space) rawSpace = void 0;
+			return {
+				space,
+				rawSpace
+			};
+		};
+		_proto.isNamedCombinator = function isNamedCombinator(position) {
+			if (position === void 0) position = this.position;
+			return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash;
+		};
+		_proto.namedCombinator = function namedCombinator() {
+			if (this.isNamedCombinator()) {
+				var nameRaw = this.content(this.tokens[this.position + 1]);
+				var name = (0, _util.unesc)(nameRaw).toLowerCase();
+				var raws = {};
+				if (name !== nameRaw) raws.value = "/" + nameRaw + "/";
+				var node = new _combinator["default"]({
+					value: "/" + name + "/",
+					source: getSource(this.currToken[_tokenize.FIELDS.START_LINE], this.currToken[_tokenize.FIELDS.START_COL], this.tokens[this.position + 2][_tokenize.FIELDS.END_LINE], this.tokens[this.position + 2][_tokenize.FIELDS.END_COL]),
+					sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+					raws
+				});
+				this.position = this.position + 3;
+				return node;
+			} else this.unexpected();
+		};
+		_proto.combinator = function combinator() {
+			var _this3 = this;
+			if (this.content() === "|") return this.namespace();
+			var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
+			if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+				var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+				if (nodes.length > 0) {
+					var last = this.current.last;
+					if (last) {
+						var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes), space = _this$convertWhitespa.space, rawSpace = _this$convertWhitespa.rawSpace;
+						if (rawSpace !== void 0) last.rawSpaceAfter += rawSpace;
+						last.spaces.after += space;
+					} else nodes.forEach(function(n) {
+						return _this3.newNode(n);
+					});
+				}
+				return;
+			}
+			var firstToken = this.currToken;
+			var spaceOrDescendantSelectorNodes = void 0;
+			if (nextSigTokenPos > this.position) spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+			var node;
+			if (this.isNamedCombinator()) node = this.namedCombinator();
+			else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.combinator) {
+				node = new _combinator["default"]({
+					value: this.content(),
+					source: getTokenSource(this.currToken),
+					sourceIndex: this.currToken[_tokenize.FIELDS.START_POS]
+				});
+				this.position++;
+			} else if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {} else if (!spaceOrDescendantSelectorNodes) this.unexpected();
+			if (node) {
+				if (spaceOrDescendantSelectorNodes) {
+					var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes), _space = _this$convertWhitespa2.space, _rawSpace = _this$convertWhitespa2.rawSpace;
+					node.spaces.before = _space;
+					node.rawSpaceBefore = _rawSpace;
+				}
+			} else {
+				var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true), _space2 = _this$convertWhitespa3.space, _rawSpace2 = _this$convertWhitespa3.rawSpace;
+				if (!_rawSpace2) _rawSpace2 = _space2;
+				var spaces = {};
+				var raws = { spaces: {} };
+				if (_space2.endsWith(" ") && _rawSpace2.endsWith(" ")) {
+					spaces.before = _space2.slice(0, _space2.length - 1);
+					raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1);
+				} else if (_space2[0] === " " && _rawSpace2[0] === " ") {
+					spaces.after = _space2.slice(1);
+					raws.spaces.after = _rawSpace2.slice(1);
+				} else raws.value = _rawSpace2;
+				node = new _combinator["default"]({
+					value: " ",
+					source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]),
+					sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+					spaces,
+					raws
+				});
+			}
+			if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
+				node.spaces.after = this.optionalSpace(this.content());
+				this.position++;
+			}
+			return this.newNode(node);
+		};
+		_proto.comma = function comma() {
+			if (this.position === this.tokens.length - 1) {
+				this.root.trailingComma = true;
+				this.position++;
+				return;
+			}
+			this.current._inferEndPosition();
+			var selector = new _selector["default"]({
+				source: { start: tokenStart(this.tokens[this.position + 1]) },
+				sourceIndex: this.tokens[this.position + 1][_tokenize.FIELDS.START_POS]
+			});
+			this.current.parent.append(selector);
+			this.current = selector;
+			this.position++;
+		};
+		_proto.comment = function comment() {
+			var current = this.currToken;
+			this.newNode(new _comment["default"]({
+				value: this.content(),
+				source: getTokenSource(current),
+				sourceIndex: current[_tokenize.FIELDS.START_POS]
+			}));
+			this.position++;
+		};
+		_proto.error = function error(message, opts) {
+			throw this.root.error(message, opts);
+		};
+		_proto.missingBackslash = function missingBackslash() {
+			return this.error("Expected a backslash preceding the semicolon.", { index: this.currToken[_tokenize.FIELDS.START_POS] });
+		};
+		_proto.missingParenthesis = function missingParenthesis() {
+			return this.expected("opening parenthesis", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.missingSquareBracket = function missingSquareBracket() {
+			return this.expected("opening square bracket", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.unexpected = function unexpected() {
+			return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.unexpectedPipe = function unexpectedPipe() {
+			return this.error("Unexpected '|'.", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.namespace = function namespace() {
+			var before = this.prevToken && this.content(this.prevToken) || true;
+			if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+				this.position++;
+				return this.word(before);
+			} else if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.asterisk) {
+				this.position++;
+				return this.universal(before);
+			}
+			this.unexpectedPipe();
+		};
+		_proto.nesting = function nesting() {
+			if (this.nextToken) {
+				if (this.content(this.nextToken) === "|") {
+					this.position++;
+					return;
+				}
+			}
+			var current = this.currToken;
+			this.newNode(new _nesting["default"]({
+				value: this.content(),
+				source: getTokenSource(current),
+				sourceIndex: current[_tokenize.FIELDS.START_POS]
+			}));
+			this.position++;
+		};
+		_proto.parentheses = function parentheses() {
+			var last = this.current.last;
+			var unbalanced = 1;
+			this.position++;
+			if (last && last.type === types.PSEUDO) {
+				var selector = new _selector["default"]({
+					source: { start: tokenStart(this.tokens[this.position]) },
+					sourceIndex: this.tokens[this.position][_tokenize.FIELDS.START_POS]
+				});
+				var cache = this.current;
+				last.append(selector);
+				this.current = selector;
+				while (this.position < this.tokens.length && unbalanced) {
+					if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) unbalanced++;
+					if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) unbalanced--;
+					if (unbalanced) this.parse();
+					else {
+						this.current.source.end = tokenEnd(this.currToken);
+						this.current.parent.source.end = tokenEnd(this.currToken);
+						this.position++;
+					}
+				}
+				this.current = cache;
+			} else {
+				var parenStart = this.currToken;
+				var parenValue = "(";
+				var parenEnd;
+				while (this.position < this.tokens.length && unbalanced) {
+					if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) unbalanced++;
+					if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) unbalanced--;
+					parenEnd = this.currToken;
+					parenValue += this.parseParenthesisToken(this.currToken);
+					this.position++;
+				}
+				if (last) last.appendToPropertyAndEscape("value", parenValue, parenValue);
+				else this.newNode(new _string["default"]({
+					value: parenValue,
+					source: getSource(parenStart[_tokenize.FIELDS.START_LINE], parenStart[_tokenize.FIELDS.START_COL], parenEnd[_tokenize.FIELDS.END_LINE], parenEnd[_tokenize.FIELDS.END_COL]),
+					sourceIndex: parenStart[_tokenize.FIELDS.START_POS]
+				}));
+			}
+			if (unbalanced) return this.expected("closing parenthesis", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.pseudo = function pseudo() {
+			var _this4 = this;
+			var pseudoStr = "";
+			var startingToken = this.currToken;
+			while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
+				pseudoStr += this.content();
+				this.position++;
+			}
+			if (!this.currToken) return this.expected(["pseudo-class", "pseudo-element"], this.position - 1);
+			if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) this.splitWord(false, function(first, length) {
+				pseudoStr += first;
+				_this4.newNode(new _pseudo["default"]({
+					value: pseudoStr,
+					source: getTokenSourceSpan(startingToken, _this4.currToken),
+					sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+				}));
+				if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) _this4.error("Misplaced parenthesis.", { index: _this4.nextToken[_tokenize.FIELDS.START_POS] });
+			});
+			else return this.expected(["pseudo-class", "pseudo-element"], this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.space = function space() {
+			var content = this.content();
+			if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function(node) {
+				return node.type === "comment";
+			})) {
+				this.spaces = this.optionalSpace(content);
+				this.position++;
+			} else if (this.position === this.tokens.length - 1 || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+				this.current.last.spaces.after = this.optionalSpace(content);
+				this.position++;
+			} else this.combinator();
+		};
+		_proto.string = function string() {
+			var current = this.currToken;
+			this.newNode(new _string["default"]({
+				value: this.content(),
+				source: getTokenSource(current),
+				sourceIndex: current[_tokenize.FIELDS.START_POS]
+			}));
+			this.position++;
+		};
+		_proto.universal = function universal(namespace) {
+			var nextToken = this.nextToken;
+			if (nextToken && this.content(nextToken) === "|") {
+				this.position++;
+				return this.namespace();
+			}
+			var current = this.currToken;
+			this.newNode(new _universal["default"]({
+				value: this.content(),
+				source: getTokenSource(current),
+				sourceIndex: current[_tokenize.FIELDS.START_POS]
+			}), namespace);
+			this.position++;
+		};
+		_proto.splitWord = function splitWord(namespace, firstCallback) {
+			var _this5 = this;
+			var nextToken = this.nextToken;
+			var word = this.content();
+			while (nextToken && ~[
+				tokens.dollar,
+				tokens.caret,
+				tokens.equals,
+				tokens.word
+			].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
+				this.position++;
+				var current = this.content();
+				word += current;
+				if (current.lastIndexOf("\\") === current.length - 1) {
+					var next = this.nextToken;
+					if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
+						word += this.requiredSpace(this.content(next));
+						this.position++;
+					}
+				}
+				nextToken = this.nextToken;
+			}
+			var hasClass = indexesOf(word, ".").filter(function(i) {
+				var escapedDot = word[i - 1] === "\\";
+				var isKeyframesPercent = /^\d+\.\d+%$/.test(word);
+				return !escapedDot && !isKeyframesPercent;
+			});
+			var hasId = indexesOf(word, "#").filter(function(i) {
+				return word[i - 1] !== "\\";
+			});
+			var interpolations = indexesOf(word, "#{");
+			if (interpolations.length) hasId = hasId.filter(function(hashIndex) {
+				return !~interpolations.indexOf(hashIndex);
+			});
+			var indices = (0, _sortAscending["default"])(uniqs([0].concat(hasClass, hasId)));
+			indices.forEach(function(ind, i) {
+				var index = indices[i + 1] || word.length;
+				var value = word.slice(ind, index);
+				if (i === 0 && firstCallback) return firstCallback.call(_this5, value, indices.length);
+				var node;
+				var current = _this5.currToken;
+				var sourceIndex = current[_tokenize.FIELDS.START_POS] + indices[i];
+				var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1));
+				if (~hasClass.indexOf(ind)) {
+					var classNameOpts = {
+						value: value.slice(1),
+						source,
+						sourceIndex
+					};
+					node = new _className["default"](unescapeProp(classNameOpts, "value"));
+				} else if (~hasId.indexOf(ind)) {
+					var idOpts = {
+						value: value.slice(1),
+						source,
+						sourceIndex
+					};
+					node = new _id["default"](unescapeProp(idOpts, "value"));
+				} else {
+					var tagOpts = {
+						value,
+						source,
+						sourceIndex
+					};
+					unescapeProp(tagOpts, "value");
+					node = new _tag["default"](tagOpts);
+				}
+				_this5.newNode(node, namespace);
+				namespace = null;
+			});
+			this.position++;
+		};
+		_proto.word = function word(namespace) {
+			var nextToken = this.nextToken;
+			if (nextToken && this.content(nextToken) === "|") {
+				this.position++;
+				return this.namespace();
+			}
+			return this.splitWord(namespace);
+		};
+		_proto.loop = function loop() {
+			while (this.position < this.tokens.length) this.parse(true);
+			this.current._inferEndPosition();
+			return this.root;
+		};
+		_proto.parse = function parse(throwOnParenthesis) {
+			switch (this.currToken[_tokenize.FIELDS.TYPE]) {
+				case tokens.space:
+					this.space();
+					break;
+				case tokens.comment:
+					this.comment();
+					break;
+				case tokens.openParenthesis:
+					this.parentheses();
+					break;
+				case tokens.closeParenthesis:
+					if (throwOnParenthesis) this.missingParenthesis();
+					break;
+				case tokens.openSquare:
+					this.attribute();
+					break;
+				case tokens.dollar:
+				case tokens.caret:
+				case tokens.equals:
+				case tokens.word:
+					this.word();
+					break;
+				case tokens.colon:
+					this.pseudo();
+					break;
+				case tokens.comma:
+					this.comma();
+					break;
+				case tokens.asterisk:
+					this.universal();
+					break;
+				case tokens.ampersand:
+					this.nesting();
+					break;
+				case tokens.slash:
+				case tokens.combinator:
+					this.combinator();
+					break;
+				case tokens.str:
+					this.string();
+					break;
+				case tokens.closeSquare: this.missingSquareBracket();
+				case tokens.semicolon: this.missingBackslash();
+				default: this.unexpected();
+			}
+		};
+		_proto.expected = function expected(description, index, found) {
+			if (Array.isArray(description)) {
+				var last = description.pop();
+				description = description.join(", ") + " or " + last;
+			}
+			var an = /^[aeiou]/.test(description[0]) ? "an" : "a";
+			if (!found) return this.error("Expected " + an + " " + description + ".", { index });
+			return this.error("Expected " + an + " " + description + ", found \"" + found + "\" instead.", { index });
+		};
+		_proto.requiredSpace = function requiredSpace(space) {
+			return this.options.lossy ? " " : space;
+		};
+		_proto.optionalSpace = function optionalSpace(space) {
+			return this.options.lossy ? "" : space;
+		};
+		_proto.lossySpace = function lossySpace(space, required) {
+			if (this.options.lossy) return required ? " " : "";
+			else return space;
+		};
+		_proto.parseParenthesisToken = function parseParenthesisToken(token) {
+			var content = this.content(token);
+			if (token[_tokenize.FIELDS.TYPE] === tokens.space) return this.requiredSpace(content);
+			else return content;
+		};
+		_proto.newNode = function newNode(node, namespace) {
+			if (namespace) {
+				if (/^ +$/.test(namespace)) {
+					if (!this.options.lossy) this.spaces = (this.spaces || "") + namespace;
+					namespace = true;
+				}
+				node.namespace = namespace;
+				unescapeProp(node, "namespace");
+			}
+			if (this.spaces) {
+				node.spaces.before = this.spaces;
+				this.spaces = "";
+			}
+			return this.current.append(node);
+		};
+		_proto.content = function content(token) {
+			if (token === void 0) token = this.currToken;
+			return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
+		};
+		/**
+		* returns the index of the next non-whitespace, non-comment token.
+		* returns -1 if no meaningful token is found.
+		*/
+		_proto.locateNextMeaningfulToken = function locateNextMeaningfulToken(startPosition) {
+			if (startPosition === void 0) startPosition = this.position + 1;
+			var searchPosition = startPosition;
+			while (searchPosition < this.tokens.length) if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
+				searchPosition++;
+				continue;
+			} else return searchPosition;
+			return -1;
+		};
+		_createClass(Parser, [
+			{
+				key: "currToken",
+				get: function get() {
+					return this.tokens[this.position];
+				}
+			},
+			{
+				key: "nextToken",
+				get: function get() {
+					return this.tokens[this.position + 1];
+				}
+			},
+			{
+				key: "prevToken",
+				get: function get() {
+					return this.tokens[this.position - 1];
+				}
+			}
+		]);
+		return Parser;
+	}();
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/processor.js
+var require_processor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _parser = _interopRequireDefault(require_parser());
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	exports["default"] = /* @__PURE__ */ function() {
+		function Processor(func, options) {
+			this.func = func || function noop() {};
+			this.funcRes = null;
+			this.options = options;
+		}
+		var _proto = Processor.prototype;
+		_proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
+			if (options === void 0) options = {};
+			if (Object.assign({}, this.options, options).updateSelector === false) return false;
+			else return typeof rule !== "string";
+		};
+		_proto._isLossy = function _isLossy(options) {
+			if (options === void 0) options = {};
+			if (Object.assign({}, this.options, options).lossless === false) return true;
+			else return false;
+		};
+		_proto._root = function _root(rule, options) {
+			if (options === void 0) options = {};
+			return new _parser["default"](rule, this._parseOptions(options)).root;
+		};
+		_proto._parseOptions = function _parseOptions(options) {
+			return { lossy: this._isLossy(options) };
+		};
+		_proto._run = function _run(rule, options) {
+			var _this = this;
+			if (options === void 0) options = {};
+			return new Promise(function(resolve, reject) {
+				try {
+					var root = _this._root(rule, options);
+					Promise.resolve(_this.func(root)).then(function(transform) {
+						var string = void 0;
+						if (_this._shouldUpdateSelector(rule, options)) {
+							string = root.toString();
+							rule.selector = string;
+						}
+						return {
+							transform,
+							root,
+							string
+						};
+					}).then(resolve, reject);
+				} catch (e) {
+					reject(e);
+					return;
+				}
+			});
+		};
+		_proto._runSync = function _runSync(rule, options) {
+			if (options === void 0) options = {};
+			var root = this._root(rule, options);
+			var transform = this.func(root);
+			if (transform && typeof transform.then === "function") throw new Error("Selector processor returned a promise to a synchronous call.");
+			var string = void 0;
+			if (options.updateSelector && typeof rule !== "string") {
+				string = root.toString();
+				rule.selector = string;
+			}
+			return {
+				transform,
+				root,
+				string
+			};
+		};
+		_proto.ast = function ast(rule, options) {
+			return this._run(rule, options).then(function(result) {
+				return result.root;
+			});
+		};
+		_proto.astSync = function astSync(rule, options) {
+			return this._runSync(rule, options).root;
+		};
+		_proto.transform = function transform(rule, options) {
+			return this._run(rule, options).then(function(result) {
+				return result.transform;
+			});
+		};
+		_proto.transformSync = function transformSync(rule, options) {
+			return this._runSync(rule, options).transform;
+		};
+		_proto.process = function process(rule, options) {
+			return this._run(rule, options).then(function(result) {
+				return result.string || result.root.toString();
+			});
+		};
+		_proto.processSync = function processSync(rule, options) {
+			var result = this._runSync(rule, options);
+			return result.string || result.root.toString();
+		};
+		return Processor;
+	}();
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/constructors.js
+var require_constructors = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.universal = exports.tag = exports.string = exports.selector = exports.root = exports.pseudo = exports.nesting = exports.id = exports.comment = exports.combinator = exports.className = exports.attribute = void 0;
+	var _attribute = _interopRequireDefault(require_attribute());
+	var _className = _interopRequireDefault(require_className());
+	var _combinator = _interopRequireDefault(require_combinator());
+	var _comment = _interopRequireDefault(require_comment());
+	var _id = _interopRequireDefault(require_id());
+	var _nesting = _interopRequireDefault(require_nesting());
+	var _pseudo = _interopRequireDefault(require_pseudo());
+	var _root = _interopRequireDefault(require_root());
+	var _selector = _interopRequireDefault(require_selector());
+	var _string = _interopRequireDefault(require_string());
+	var _tag = _interopRequireDefault(require_tag());
+	var _universal = _interopRequireDefault(require_universal());
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	exports.attribute = function attribute(opts) {
+		return new _attribute["default"](opts);
+	};
+	exports.className = function className(opts) {
+		return new _className["default"](opts);
+	};
+	exports.combinator = function combinator(opts) {
+		return new _combinator["default"](opts);
+	};
+	exports.comment = function comment(opts) {
+		return new _comment["default"](opts);
+	};
+	exports.id = function id(opts) {
+		return new _id["default"](opts);
+	};
+	exports.nesting = function nesting(opts) {
+		return new _nesting["default"](opts);
+	};
+	exports.pseudo = function pseudo(opts) {
+		return new _pseudo["default"](opts);
+	};
+	exports.root = function root(opts) {
+		return new _root["default"](opts);
+	};
+	exports.selector = function selector(opts) {
+		return new _selector["default"](opts);
+	};
+	exports.string = function string(opts) {
+		return new _string["default"](opts);
+	};
+	exports.tag = function tag(opts) {
+		return new _tag["default"](opts);
+	};
+	exports.universal = function universal(opts) {
+		return new _universal["default"](opts);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/guards.js
+var require_guards = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.isComment = exports.isCombinator = exports.isClassName = exports.isAttribute = void 0;
+	exports.isContainer = isContainer;
+	exports.isIdentifier = void 0;
+	exports.isNamespace = isNamespace;
+	exports.isNesting = void 0;
+	exports.isNode = isNode;
+	exports.isPseudo = void 0;
+	exports.isPseudoClass = isPseudoClass;
+	exports.isPseudoElement = isPseudoElement;
+	exports.isUniversal = exports.isTag = exports.isString = exports.isSelector = exports.isRoot = void 0;
+	var _types = require_types();
+	var _IS_TYPE;
+	var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE);
+	function isNode(node) {
+		return typeof node === "object" && IS_TYPE[node.type];
+	}
+	function isNodeType(type, node) {
+		return isNode(node) && node.type === type;
+	}
+	var isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
+	exports.isAttribute = isAttribute;
+	exports.isClassName = isNodeType.bind(null, _types.CLASS);
+	exports.isCombinator = isNodeType.bind(null, _types.COMBINATOR);
+	exports.isComment = isNodeType.bind(null, _types.COMMENT);
+	exports.isIdentifier = isNodeType.bind(null, _types.ID);
+	exports.isNesting = isNodeType.bind(null, _types.NESTING);
+	var isPseudo = isNodeType.bind(null, _types.PSEUDO);
+	exports.isPseudo = isPseudo;
+	exports.isRoot = isNodeType.bind(null, _types.ROOT);
+	exports.isSelector = isNodeType.bind(null, _types.SELECTOR);
+	exports.isString = isNodeType.bind(null, _types.STRING);
+	var isTag = isNodeType.bind(null, _types.TAG);
+	exports.isTag = isTag;
+	exports.isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
+	function isPseudoElement(node) {
+		return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after" || node.value.toLowerCase() === ":first-letter" || node.value.toLowerCase() === ":first-line");
+	}
+	function isPseudoClass(node) {
+		return isPseudo(node) && !isPseudoElement(node);
+	}
+	function isContainer(node) {
+		return !!(isNode(node) && node.walk);
+	}
+	function isNamespace(node) {
+		return isAttribute(node) || isTag(node);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/selectors/index.js
+var require_selectors = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	var _types = require_types();
+	Object.keys(_types).forEach(function(key) {
+		if (key === "default" || key === "__esModule") return;
+		if (key in exports && exports[key] === _types[key]) return;
+		exports[key] = _types[key];
+	});
+	var _constructors = require_constructors();
+	Object.keys(_constructors).forEach(function(key) {
+		if (key === "default" || key === "__esModule") return;
+		if (key in exports && exports[key] === _constructors[key]) return;
+		exports[key] = _constructors[key];
+	});
+	var _guards = require_guards();
+	Object.keys(_guards).forEach(function(key) {
+		if (key === "default" || key === "__esModule") return;
+		if (key in exports && exports[key] === _guards[key]) return;
+		exports[key] = _guards[key];
+	});
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.1/node_modules/postcss-selector-parser/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _processor = _interopRequireDefault(require_processor());
+	var selectors = _interopRequireWildcard(require_selectors());
+	function _getRequireWildcardCache(nodeInterop) {
+		if (typeof WeakMap !== "function") return null;
+		var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+		var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+		return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
+			return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+		})(nodeInterop);
+	}
+	function _interopRequireWildcard(obj, nodeInterop) {
+		if (!nodeInterop && obj && obj.__esModule) return obj;
+		if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { "default": obj };
+		var cache = _getRequireWildcardCache(nodeInterop);
+		if (cache && cache.has(obj)) return cache.get(obj);
+		var newObj = {};
+		var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		for (var key in obj) if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+			var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+			if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+			else newObj[key] = obj[key];
+		}
+		newObj["default"] = obj;
+		if (cache) cache.set(obj, newObj);
+		return newObj;
+	}
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	var parser = function parser(processor) {
+		return new _processor["default"](processor);
+	};
+	Object.assign(parser, selectors);
+	delete parser.__esModule;
+	exports["default"] = parser;
+	module.exports = exports.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-local-by-default@4.2.0_postcss@8.5.14/node_modules/postcss-modules-local-by-default/src/index.js
+var require_src$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const selectorParser = require_dist();
+	const valueParser = require_lib();
+	const { extractICSS } = require_src$4();
+	const IGNORE_FILE_MARKER = "cssmodules-pure-no-check";
+	const IGNORE_NEXT_LINE_MARKER = "cssmodules-pure-ignore";
+	const isSpacing = (node) => node.type === "combinator" && node.value === " ";
+	const isPureCheckDisabled = (root) => {
+		for (const node of root.nodes) {
+			if (node.type !== "comment") return false;
+			if (node.text.trim().startsWith(IGNORE_FILE_MARKER)) return true;
+		}
+		return false;
+	};
+	function getIgnoreComment(node) {
+		if (!node.parent) return;
+		const indexInParent = node.parent.index(node);
+		for (let i = indexInParent - 1; i >= 0; i--) {
+			const prevNode = node.parent.nodes[i];
+			if (prevNode.type === "comment") {
+				if (prevNode.text.trimStart().startsWith(IGNORE_NEXT_LINE_MARKER)) return prevNode;
+			} else break;
+		}
+	}
+	function normalizeNodeArray(nodes) {
+		const array = [];
+		nodes.forEach((x) => {
+			if (Array.isArray(x)) normalizeNodeArray(x).forEach((item) => {
+				array.push(item);
+			});
+			else if (x) array.push(x);
+		});
+		if (array.length > 0 && isSpacing(array[array.length - 1])) array.pop();
+		return array;
+	}
+	const isPureSelectorSymbol = Symbol("is-pure-selector");
+	function localizeNode(rule, mode, localAliasMap) {
+		const transform = (node, context) => {
+			if (context.ignoreNextSpacing && !isSpacing(node)) throw new Error("Missing whitespace after " + context.ignoreNextSpacing);
+			if (context.enforceNoSpacing && isSpacing(node)) throw new Error("Missing whitespace before " + context.enforceNoSpacing);
+			let newNodes;
+			switch (node.type) {
+				case "root": {
+					let resultingGlobal;
+					context.hasPureGlobals = false;
+					newNodes = node.nodes.map((n) => {
+						const nContext = {
+							global: context.global,
+							lastWasSpacing: true,
+							hasLocals: false,
+							explicit: false
+						};
+						n = transform(n, nContext);
+						if (typeof resultingGlobal === "undefined") resultingGlobal = nContext.global;
+						else if (resultingGlobal !== nContext.global) throw new Error("Inconsistent rule global/local result in rule \"" + node + "\" (multiple selectors must result in the same mode for the rule)");
+						if (!nContext.hasLocals) context.hasPureGlobals = true;
+						return n;
+					});
+					context.global = resultingGlobal;
+					node.nodes = normalizeNodeArray(newNodes);
+					break;
+				}
+				case "selector":
+					newNodes = node.map((childNode) => transform(childNode, context));
+					node = node.clone();
+					node.nodes = normalizeNodeArray(newNodes);
+					break;
+				case "combinator":
+					if (isSpacing(node)) {
+						if (context.ignoreNextSpacing) {
+							context.ignoreNextSpacing = false;
+							context.lastWasSpacing = false;
+							context.enforceNoSpacing = false;
+							return null;
+						}
+						context.lastWasSpacing = true;
+						return node;
+					}
+					break;
+				case "pseudo": {
+					let childContext;
+					const isNested = !!node.length;
+					const isScoped = node.value === ":local" || node.value === ":global";
+					if (node.value === ":import" || node.value === ":export") context.hasLocals = true;
+					else if (isNested) {
+						if (isScoped) {
+							if (node.nodes.length === 0) throw new Error(`${node.value}() can't be empty`);
+							if (context.inside) throw new Error(`A ${node.value} is not allowed inside of a ${context.inside}(...)`);
+							childContext = {
+								global: node.value === ":global",
+								inside: node.value,
+								hasLocals: false,
+								explicit: true
+							};
+							newNodes = node.map((childNode) => transform(childNode, childContext)).reduce((acc, next) => acc.concat(next.nodes), []);
+							if (newNodes.length) {
+								const { before, after } = node.spaces;
+								const first = newNodes[0];
+								const last = newNodes[newNodes.length - 1];
+								first.spaces = {
+									before,
+									after: first.spaces.after
+								};
+								last.spaces = {
+									before: last.spaces.before,
+									after
+								};
+							}
+							node = newNodes;
+							break;
+						} else {
+							childContext = {
+								global: context.global,
+								inside: context.inside,
+								lastWasSpacing: true,
+								hasLocals: false,
+								explicit: context.explicit
+							};
+							newNodes = node.map((childNode) => {
+								const newContext = {
+									...childContext,
+									enforceNoSpacing: false
+								};
+								const result = transform(childNode, newContext);
+								childContext.global = newContext.global;
+								childContext.hasLocals = newContext.hasLocals;
+								return result;
+							});
+							node = node.clone();
+							node.nodes = normalizeNodeArray(newNodes);
+							if (childContext.hasLocals) context.hasLocals = true;
+						}
+						break;
+					} else if (isScoped) {
+						if (context.inside) throw new Error(`A ${node.value} is not allowed inside of a ${context.inside}(...)`);
+						const addBackSpacing = !!node.spaces.before;
+						context.ignoreNextSpacing = context.lastWasSpacing ? node.value : false;
+						context.enforceNoSpacing = context.lastWasSpacing ? false : node.value;
+						context.global = node.value === ":global";
+						context.explicit = true;
+						return addBackSpacing ? selectorParser.combinator({ value: " " }) : null;
+					}
+					break;
+				}
+				case "id":
+				case "class": {
+					if (!node.value) throw new Error("Invalid class or id selector syntax");
+					if (context.global) break;
+					const isImportedValue = localAliasMap.has(node.value);
+					if (!isImportedValue || isImportedValue && context.explicit) {
+						const innerNode = node.clone();
+						innerNode.spaces = {
+							before: "",
+							after: ""
+						};
+						node = selectorParser.pseudo({
+							value: ":local",
+							nodes: [innerNode],
+							spaces: node.spaces
+						});
+						context.hasLocals = true;
+					}
+					break;
+				}
+				case "nesting": if (node.value === "&") context.hasLocals = rule.parent[isPureSelectorSymbol];
+			}
+			context.lastWasSpacing = false;
+			context.ignoreNextSpacing = false;
+			context.enforceNoSpacing = false;
+			return node;
+		};
+		const rootContext = {
+			global: mode === "global",
+			hasPureGlobals: false
+		};
+		rootContext.selector = selectorParser((root) => {
+			transform(root, rootContext);
+		}).processSync(rule, {
+			updateSelector: false,
+			lossless: true
+		});
+		return rootContext;
+	}
+	function localizeDeclNode(node, context) {
+		switch (node.type) {
+			case "word":
+				if (context.localizeNextItem) {
+					if (!context.localAliasMap.has(node.value)) {
+						node.value = ":local(" + node.value + ")";
+						context.localizeNextItem = false;
+					}
+				}
+				break;
+			case "function":
+				if (context.options && context.options.rewriteUrl && node.value.toLowerCase() === "url") node.nodes.map((nestedNode) => {
+					if (nestedNode.type !== "string" && nestedNode.type !== "word") return;
+					let newUrl = context.options.rewriteUrl(context.global, nestedNode.value);
+					switch (nestedNode.type) {
+						case "string":
+							if (nestedNode.quote === "'") newUrl = newUrl.replace(/(\\)/g, "\\$1").replace(/'/g, "\\'");
+							if (nestedNode.quote === "\"") newUrl = newUrl.replace(/(\\)/g, "\\$1").replace(/"/g, "\\\"");
+							break;
+						case "word":
+							newUrl = newUrl.replace(/("|'|\)|\\)/g, "\\$1");
+							break;
+					}
+					nestedNode.value = newUrl;
+				});
+				break;
+		}
+		return node;
+	}
+	const specialKeywords = [
+		"none",
+		"inherit",
+		"initial",
+		"revert",
+		"revert-layer",
+		"unset"
+	];
+	function localizeDeclarationValues(localize, declaration, context) {
+		const valueNodes = valueParser(declaration.value);
+		valueNodes.walk((node, index, nodes) => {
+			if (node.type === "function" && (node.value.toLowerCase() === "var" || node.value.toLowerCase() === "env")) return false;
+			if (node.type === "word" && specialKeywords.includes(node.value.toLowerCase())) return;
+			nodes[index] = localizeDeclNode(node, {
+				options: context.options,
+				global: context.global,
+				localizeNextItem: localize && !context.global,
+				localAliasMap: context.localAliasMap
+			});
+		});
+		declaration.value = valueNodes.toString();
+	}
+	const validIdent = /^-?([a-z\u0080-\uFFFF_]|(\\[^\r\n\f])|-(?![0-9]))((\\[^\r\n\f])|[a-z\u0080-\uFFFF_0-9-])*$/i;
+	const animationKeywords = {
+		$normal: 1,
+		$reverse: 1,
+		$alternate: 1,
+		"$alternate-reverse": 1,
+		$forwards: 1,
+		$backwards: 1,
+		$both: 1,
+		$infinite: 1,
+		$paused: 1,
+		$running: 1,
+		$ease: 1,
+		"$ease-in": 1,
+		"$ease-out": 1,
+		"$ease-in-out": 1,
+		$linear: 1,
+		"$step-end": 1,
+		"$step-start": 1,
+		$none: Infinity,
+		$initial: Infinity,
+		$inherit: Infinity,
+		$unset: Infinity,
+		$revert: Infinity,
+		"$revert-layer": Infinity
+	};
+	function localizeDeclaration(declaration, context) {
+		if (/animation(-name)?$/i.test(declaration.prop)) {
+			let parsedAnimationKeywords = {};
+			declaration.value = valueParser(declaration.value).walk((node) => {
+				if (node.type === "div") {
+					parsedAnimationKeywords = {};
+					return;
+				} else if (node.type === "function" && node.value.toLowerCase() === "local" && node.nodes.length === 1) {
+					node.type = "word";
+					node.value = node.nodes[0].value;
+					return localizeDeclNode(node, {
+						options: context.options,
+						global: context.global,
+						localizeNextItem: true,
+						localAliasMap: context.localAliasMap
+					});
+				} else if (node.type === "function") {
+					if (node.value.toLowerCase() === "global" && node.nodes.length === 1) {
+						node.type = "word";
+						node.value = node.nodes[0].value;
+					}
+					return false;
+				} else if (node.type !== "word") return;
+				const value = node.type === "word" ? node.value.toLowerCase() : null;
+				let shouldParseAnimationName = false;
+				if (value && validIdent.test(value)) if ("$" + value in animationKeywords) {
+					parsedAnimationKeywords["$" + value] = "$" + value in parsedAnimationKeywords ? parsedAnimationKeywords["$" + value] + 1 : 0;
+					shouldParseAnimationName = parsedAnimationKeywords["$" + value] >= animationKeywords["$" + value];
+				} else shouldParseAnimationName = true;
+				return localizeDeclNode(node, {
+					options: context.options,
+					global: context.global,
+					localizeNextItem: shouldParseAnimationName && !context.global,
+					localAliasMap: context.localAliasMap
+				});
+			}).toString();
+			return;
+		}
+		if (/url\(/i.test(declaration.value)) return localizeDeclarationValues(false, declaration, context);
+	}
+	const isPureSelector = (context, rule) => {
+		if (!rule.parent || rule.type === "root") return !context.hasPureGlobals;
+		if (rule.type === "rule" && rule[isPureSelectorSymbol]) return rule[isPureSelectorSymbol] || isPureSelector(context, rule.parent);
+		return !context.hasPureGlobals || isPureSelector(context, rule.parent);
+	};
+	const isNodeWithoutDeclarations = (rule) => {
+		if (rule.nodes.length > 0) return !rule.nodes.every((item) => item.type === "rule" || item.type === "atrule" && !isNodeWithoutDeclarations(item));
+		return true;
+	};
+	module.exports = (options = {}) => {
+		if (options && options.mode && options.mode !== "global" && options.mode !== "local" && options.mode !== "pure") throw new Error("options.mode must be either \"global\", \"local\" or \"pure\" (default \"local\")");
+		const pureMode = options && options.mode === "pure";
+		const globalMode = options && options.mode === "global";
+		return {
+			postcssPlugin: "postcss-modules-local-by-default",
+			prepare() {
+				const localAliasMap = /* @__PURE__ */ new Map();
+				return { Once(root) {
+					const { icssImports } = extractICSS(root, false);
+					const enforcePureMode = pureMode && !isPureCheckDisabled(root);
+					Object.keys(icssImports).forEach((key) => {
+						Object.keys(icssImports[key]).forEach((prop) => {
+							localAliasMap.set(prop, icssImports[key][prop]);
+						});
+					});
+					root.walkAtRules((atRule) => {
+						if (/keyframes$/i.test(atRule.name)) {
+							const globalMatch = /^\s*:global\s*\((.+)\)\s*$/.exec(atRule.params);
+							const localMatch = /^\s*:local\s*\((.+)\)\s*$/.exec(atRule.params);
+							let globalKeyframes = globalMode;
+							if (globalMatch) {
+								if (enforcePureMode) {
+									const ignoreComment = getIgnoreComment(atRule);
+									if (!ignoreComment) throw atRule.error("@keyframes :global(...) is not allowed in pure mode");
+									else ignoreComment.remove();
+								}
+								atRule.params = globalMatch[1];
+								globalKeyframes = true;
+							} else if (localMatch) {
+								atRule.params = localMatch[0];
+								globalKeyframes = false;
+							} else if (atRule.params && !globalMode && !localAliasMap.has(atRule.params)) atRule.params = ":local(" + atRule.params + ")";
+							atRule.walkDecls((declaration) => {
+								localizeDeclaration(declaration, {
+									localAliasMap,
+									options,
+									global: globalKeyframes
+								});
+							});
+						} else if (/scope$/i.test(atRule.name)) {
+							if (atRule.params) {
+								const ignoreComment = pureMode ? getIgnoreComment(atRule) : void 0;
+								if (ignoreComment) ignoreComment.remove();
+								atRule.params = atRule.params.split("to").map((item) => {
+									const selector = item.trim().slice(1, -1).trim();
+									const context = localizeNode(selector, options.mode, localAliasMap);
+									context.options = options;
+									context.localAliasMap = localAliasMap;
+									if (enforcePureMode && context.hasPureGlobals && !ignoreComment) throw atRule.error("Selector in at-rule\"" + selector + "\" is not pure (pure selectors must contain at least one local class or id)");
+									return `(${context.selector})`;
+								}).join(" to ");
+							}
+							atRule.nodes.forEach((declaration) => {
+								if (declaration.type === "decl") localizeDeclaration(declaration, {
+									localAliasMap,
+									options,
+									global: globalMode
+								});
+							});
+						} else if (atRule.nodes) atRule.nodes.forEach((declaration) => {
+							if (declaration.type === "decl") localizeDeclaration(declaration, {
+								localAliasMap,
+								options,
+								global: globalMode
+							});
+						});
+					});
+					root.walkRules((rule) => {
+						if (rule.parent && rule.parent.type === "atrule" && /keyframes$/i.test(rule.parent.name)) return;
+						const context = localizeNode(rule, options.mode, localAliasMap);
+						context.options = options;
+						context.localAliasMap = localAliasMap;
+						const ignoreComment = enforcePureMode ? getIgnoreComment(rule) : void 0;
+						const isNotPure = enforcePureMode && !isPureSelector(context, rule);
+						if (isNotPure && isNodeWithoutDeclarations(rule) && !ignoreComment) throw rule.error("Selector \"" + rule.selector + "\" is not pure (pure selectors must contain at least one local class or id)");
+						else if (ignoreComment) ignoreComment.remove();
+						if (pureMode) rule[isPureSelectorSymbol] = !isNotPure;
+						rule.selector = context.selector;
+						if (rule.nodes) rule.nodes.forEach((declaration) => localizeDeclaration(declaration, context));
+					});
+				} };
+			}
+		};
+	};
+	module.exports.postcss = true;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-scope@3.2.1_postcss@8.5.14/node_modules/postcss-modules-scope/src/index.js
+var require_src$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const selectorParser = require_dist();
+	const hasOwnProperty = Object.prototype.hasOwnProperty;
+	function isNestedRule(rule) {
+		if (!rule.parent || rule.parent.type === "root") return false;
+		if (rule.parent.type === "rule") return true;
+		return isNestedRule(rule.parent);
+	}
+	function getSingleLocalNamesForComposes(root, rule) {
+		if (isNestedRule(rule)) throw new Error(`composition is not allowed in nested rule \n\n${rule}`);
+		return root.nodes.map((node) => {
+			if (node.type !== "selector" || node.nodes.length !== 1) throw new Error(`composition is only allowed when selector is single :local class name not in "${root}"`);
+			node = node.nodes[0];
+			if (node.type !== "pseudo" || node.value !== ":local" || node.nodes.length !== 1) throw new Error("composition is only allowed when selector is single :local class name not in \"" + root + "\", \"" + node + "\" is weird");
+			node = node.first;
+			if (node.type !== "selector" || node.length !== 1) throw new Error("composition is only allowed when selector is single :local class name not in \"" + root + "\", \"" + node + "\" is weird");
+			node = node.first;
+			if (node.type !== "class") throw new Error("composition is only allowed when selector is single :local class name not in \"" + root + "\", \"" + node + "\" is weird");
+			return node.value;
+		});
+	}
+	const unescapeRegExp = /* @__PURE__ */ new RegExp("\\\\([\\da-f]{1,6}[\\x20\\t\\r\\n\\f]?|([\\x20\\t\\r\\n\\f])|.)", "ig");
+	function unescape(str) {
+		return str.replace(unescapeRegExp, (_, escaped, escapedWhitespace) => {
+			const high = "0x" + escaped - 65536;
+			return high !== high || escapedWhitespace ? escaped : high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320);
+		});
+	}
+	const plugin = (options = {}) => {
+		const generateScopedName = options && options.generateScopedName || plugin.generateScopedName;
+		const generateExportEntry = options && options.generateExportEntry || plugin.generateExportEntry;
+		const exportGlobals = options && options.exportGlobals;
+		return {
+			postcssPlugin: "postcss-modules-scope",
+			Once(root, { rule }) {
+				const exports$1 = Object.create(null);
+				function exportScopedName(name, rawName, node) {
+					const scopedName = generateScopedName(rawName ? rawName : name, root.source.input.from, root.source.input.css, node);
+					const { key, value } = generateExportEntry(rawName ? rawName : name, scopedName, root.source.input.from, root.source.input.css, node);
+					exports$1[key] = exports$1[key] || [];
+					if (exports$1[key].indexOf(value) < 0) exports$1[key].push(value);
+					return scopedName;
+				}
+				function localizeNode(node) {
+					switch (node.type) {
+						case "selector":
+							node.nodes = node.map((item) => localizeNode(item));
+							return node;
+						case "class": return selectorParser.className({ value: exportScopedName(node.value, node.raws && node.raws.value ? node.raws.value : null, node) });
+						case "id": return selectorParser.id({ value: exportScopedName(node.value, node.raws && node.raws.value ? node.raws.value : null, node) });
+						case "attribute": if (node.attribute === "class" && node.operator === "=") return selectorParser.attribute({
+							attribute: node.attribute,
+							operator: node.operator,
+							quoteMark: "'",
+							value: exportScopedName(node.value, null, null)
+						});
+					}
+					throw new Error(`${node.type} ("${node}") is not allowed in a :local block`);
+				}
+				function traverseNode(node) {
+					switch (node.type) {
+						case "pseudo": if (node.value === ":local") {
+							if (node.nodes.length !== 1) throw new Error("Unexpected comma (\",\") in :local block");
+							const selector = localizeNode(node.first);
+							selector.first.spaces = node.spaces;
+							const nextNode = node.next();
+							if (nextNode && nextNode.type === "combinator" && nextNode.value === " " && /\\[A-F0-9]{1,6}$/.test(selector.last.value)) selector.last.spaces.after = " ";
+							node.replaceWith(selector);
+							return;
+						}
+						case "root":
+						case "selector":
+							node.each((item) => traverseNode(item));
+							break;
+						case "id":
+						case "class":
+							if (exportGlobals) exports$1[node.value] = [node.value];
+							break;
+					}
+					return node;
+				}
+				const importedNames = {};
+				root.walkRules(/^:import\(.+\)$/, (rule) => {
+					rule.walkDecls((decl) => {
+						importedNames[decl.prop] = true;
+					});
+				});
+				root.walkRules((rule) => {
+					let parsedSelector = selectorParser().astSync(rule);
+					rule.selector = traverseNode(parsedSelector.clone()).toString();
+					rule.walkDecls(/^(composes|compose-with)$/i, (decl) => {
+						const localNames = getSingleLocalNamesForComposes(parsedSelector, decl.parent);
+						decl.value.split(",").forEach((value) => {
+							value.trim().split(/\s+/).forEach((className) => {
+								const global = /^global\(([^)]+)\)$/.exec(className);
+								if (global) localNames.forEach((exportedName) => {
+									exports$1[exportedName].push(global[1]);
+								});
+								else if (hasOwnProperty.call(importedNames, className)) localNames.forEach((exportedName) => {
+									exports$1[exportedName].push(className);
+								});
+								else if (hasOwnProperty.call(exports$1, className)) localNames.forEach((exportedName) => {
+									exports$1[className].forEach((item) => {
+										exports$1[exportedName].push(item);
+									});
+								});
+								else throw decl.error(`referenced class name "${className}" in ${decl.prop} not found`);
+							});
+						});
+						decl.remove();
+					});
+					rule.walkDecls((decl) => {
+						if (!/:local\s*\((.+?)\)/.test(decl.value)) return;
+						let tokens = decl.value.split(/(,|'[^']*'|"[^"]*")/);
+						tokens = tokens.map((token, idx) => {
+							if (idx === 0 || tokens[idx - 1] === ",") {
+								let result = token;
+								const localMatch = /:local\s*\((.+?)\)/.exec(token);
+								if (localMatch) {
+									const input = localMatch.input;
+									const matchPattern = localMatch[0];
+									const matchVal = localMatch[1];
+									const newVal = exportScopedName(matchVal);
+									result = input.replace(matchPattern, newVal);
+								} else return token;
+								return result;
+							} else return token;
+						});
+						decl.value = tokens.join("");
+					});
+				});
+				root.walkAtRules(/keyframes$/i, (atRule) => {
+					const localMatch = /^\s*:local\s*\((.+?)\)\s*$/.exec(atRule.params);
+					if (!localMatch) return;
+					atRule.params = exportScopedName(localMatch[1]);
+				});
+				root.walkAtRules(/scope$/i, (atRule) => {
+					if (atRule.params) atRule.params = atRule.params.split("to").map((item) => {
+						const selector = item.trim().slice(1, -1).trim();
+						if (!/^\s*:local\s*\((.+?)\)\s*$/.exec(selector)) return `(${selector})`;
+						return `(${traverseNode(selectorParser().astSync(selector)).toString()})`;
+					}).join(" to ");
+				});
+				const exportedNames = Object.keys(exports$1);
+				if (exportedNames.length > 0) {
+					const exportRule = rule({ selector: ":export" });
+					exportedNames.forEach((exportedName) => exportRule.append({
+						prop: exportedName,
+						value: exports$1[exportedName].join(" "),
+						raws: { before: "\n  " }
+					}));
+					root.append(exportRule);
+				}
+			}
+		};
+	};
+	plugin.postcss = true;
+	plugin.generateScopedName = function(name, path) {
+		return `_${path.replace(/\.[^./\\]+$/, "").replace(/[\W_]+/g, "_").replace(/^_|_$/g, "")}__${name}`.trim();
+	};
+	plugin.generateExportEntry = function(name, scopedName) {
+		return {
+			key: unescape(name),
+			value: unescape(scopedName)
+		};
+	};
+	module.exports = plugin;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/string-hash@1.1.3/node_modules/string-hash/index.js
+var require_string_hash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function hash(str) {
+		var hash = 5381, i = str.length;
+		while (i) hash = hash * 33 ^ str.charCodeAt(--i);
+		return hash >>> 0;
+	}
+	module.exports = hash;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-values@4.0.0_postcss@8.5.14/node_modules/postcss-modules-values/src/index.js
+var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const ICSSUtils = require_src$4();
+	const matchImports = /^(.+?|\([\s\S]+?\))\s+from\s+("[^"]*"|'[^']*'|[\w-]+)$/;
+	const matchValueDefinition = /(?:\s+|^)([\w-]+):?(.*?)$/;
+	const matchImport = /^([\w-]+)(?:\s+as\s+([\w-]+))?/;
+	module.exports = (options) => {
+		let importIndex = 0;
+		const createImportedName = options && options.createImportedName || ((importName) => `i__const_${importName.replace(/\W/g, "_")}_${importIndex++}`);
+		return {
+			postcssPlugin: "postcss-modules-values",
+			prepare(result) {
+				const importAliases = [];
+				const definitions = {};
+				return { Once(root, postcss) {
+					root.walkAtRules(/value/i, (atRule) => {
+						const matches = atRule.params.match(matchImports);
+						if (matches) {
+							let [, aliases, path] = matches;
+							if (definitions[path]) path = definitions[path];
+							const imports = aliases.replace(/^\(\s*([\s\S]+)\s*\)$/, "$1").split(/\s*,\s*/).map((alias) => {
+								const tokens = matchImport.exec(alias);
+								if (tokens) {
+									const [, theirName, myName = theirName] = tokens;
+									const importedName = createImportedName(myName);
+									definitions[myName] = importedName;
+									return {
+										theirName,
+										importedName
+									};
+								} else throw new Error(`@import statement "${alias}" is invalid!`);
+							});
+							importAliases.push({
+								path,
+								imports
+							});
+							atRule.remove();
+							return;
+						}
+						if (atRule.params.indexOf("@value") !== -1) result.warn("Invalid value definition: " + atRule.params);
+						let [, key, value] = `${atRule.params}${atRule.raws.between}`.match(matchValueDefinition);
+						const normalizedValue = value.replace(/\/\*((?!\*\/).*?)\*\//g, "");
+						if (normalizedValue.length === 0) {
+							result.warn("Invalid value definition: " + atRule.params);
+							atRule.remove();
+							return;
+						}
+						if (!/^\s+$/.test(normalizedValue)) value = value.trim();
+						definitions[key] = ICSSUtils.replaceValueSymbols(value, definitions);
+						atRule.remove();
+					});
+					if (!Object.keys(definitions).length) return;
+					ICSSUtils.replaceSymbols(root, definitions);
+					const exportDeclarations = Object.keys(definitions).map((key) => postcss.decl({
+						value: definitions[key],
+						prop: key,
+						raws: { before: "\n  " }
+					}));
+					if (exportDeclarations.length > 0) {
+						const exportRule = postcss.rule({
+							selector: ":export",
+							raws: { after: "\n" }
+						});
+						exportRule.append(exportDeclarations);
+						root.prepend(exportRule);
+					}
+					importAliases.reverse().forEach(({ path, imports }) => {
+						const importRule = postcss.rule({
+							selector: `:import(${path})`,
+							raws: { after: "\n" }
+						});
+						imports.forEach(({ theirName, importedName }) => {
+							importRule.append({
+								value: theirName,
+								prop: importedName,
+								raws: { before: "\n  " }
+							});
+						});
+						root.prepend(importRule);
+					});
+				} };
+			}
+		};
+	};
+	module.exports.postcss = true;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.14/node_modules/postcss-modules/build/scoping.js
+var require_scoping = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.behaviours = void 0;
+	exports.getDefaultPlugins = getDefaultPlugins;
+	exports.getDefaultScopeBehaviour = getDefaultScopeBehaviour;
+	exports.getScopedNameGenerator = getScopedNameGenerator;
+	var _postcssModulesExtractImports = _interopRequireDefault(require_src$3());
+	var _genericNames = _interopRequireDefault(require_generic_names());
+	var _postcssModulesLocalByDefault = _interopRequireDefault(require_src$2());
+	var _postcssModulesScope = _interopRequireDefault(require_src$1());
+	var _stringHash = _interopRequireDefault(require_string_hash());
+	var _postcssModulesValues = _interopRequireDefault(require_src());
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	const behaviours = {
+		LOCAL: "local",
+		GLOBAL: "global"
+	};
+	exports.behaviours = behaviours;
+	function getDefaultPlugins({ behaviour, generateScopedName, exportGlobals }) {
+		const scope = (0, _postcssModulesScope.default)({
+			generateScopedName,
+			exportGlobals
+		});
+		return {
+			[behaviours.LOCAL]: [
+				_postcssModulesValues.default,
+				(0, _postcssModulesLocalByDefault.default)({ mode: "local" }),
+				_postcssModulesExtractImports.default,
+				scope
+			],
+			[behaviours.GLOBAL]: [
+				_postcssModulesValues.default,
+				(0, _postcssModulesLocalByDefault.default)({ mode: "global" }),
+				_postcssModulesExtractImports.default,
+				scope
+			]
+		}[behaviour];
+	}
+	function isValidBehaviour(behaviour) {
+		return Object.keys(behaviours).map((key) => behaviours[key]).indexOf(behaviour) > -1;
+	}
+	function getDefaultScopeBehaviour(scopeBehaviour) {
+		return scopeBehaviour && isValidBehaviour(scopeBehaviour) ? scopeBehaviour : behaviours.LOCAL;
+	}
+	function generateScopedNameDefault(name, filename, css) {
+		const i = css.indexOf(`.${name}`);
+		const lineNumber = css.substr(0, i).split(/[\r\n]/).length;
+		return `_${name}_${(0, _stringHash.default)(css).toString(36).substr(0, 5)}_${lineNumber}`;
+	}
+	function getScopedNameGenerator(generateScopedName, hashPrefix) {
+		const scopedNameGenerator = generateScopedName || generateScopedNameDefault;
+		if (typeof scopedNameGenerator === "function") return scopedNameGenerator;
+		return (0, _genericNames.default)(scopedNameGenerator, {
+			context: process.cwd(),
+			hashPrefix
+		});
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.14/node_modules/postcss-modules/build/pluginFactory.js
+var require_pluginFactory = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.makePlugin = makePlugin;
+	var _postcss = _interopRequireDefault(__require("postcss"));
+	var _unquote = _interopRequireDefault(require_unquote());
+	var _Parser = _interopRequireDefault(require_Parser());
+	var _saveJSON = _interopRequireDefault(require_saveJSON());
+	var _localsConvention = require_localsConvention();
+	var _FileSystemLoader = _interopRequireDefault(require_FileSystemLoader());
+	var _scoping = require_scoping();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	const PLUGIN_NAME = "postcss-modules";
+	function isGlobalModule(globalModules, inputFile) {
+		return globalModules.some((regex) => inputFile.match(regex));
+	}
+	function getDefaultPluginsList(opts, inputFile) {
+		const globalModulesList = opts.globalModulePaths || null;
+		const exportGlobals = opts.exportGlobals || false;
+		const defaultBehaviour = (0, _scoping.getDefaultScopeBehaviour)(opts.scopeBehaviour);
+		const generateScopedName = (0, _scoping.getScopedNameGenerator)(opts.generateScopedName, opts.hashPrefix);
+		if (globalModulesList && isGlobalModule(globalModulesList, inputFile)) return (0, _scoping.getDefaultPlugins)({
+			behaviour: _scoping.behaviours.GLOBAL,
+			generateScopedName,
+			exportGlobals
+		});
+		return (0, _scoping.getDefaultPlugins)({
+			behaviour: defaultBehaviour,
+			generateScopedName,
+			exportGlobals
+		});
+	}
+	function getLoader(opts, plugins) {
+		const root = typeof opts.root === "undefined" ? "/" : opts.root;
+		return typeof opts.Loader === "function" ? new opts.Loader(root, plugins, opts.resolve) : new _FileSystemLoader.default(root, plugins, opts.resolve);
+	}
+	function isOurPlugin(plugin) {
+		return plugin.postcssPlugin === PLUGIN_NAME;
+	}
+	function makePlugin(opts) {
+		return {
+			postcssPlugin: PLUGIN_NAME,
+			async OnceExit(css, { result }) {
+				const getJSON = opts.getJSON || _saveJSON.default;
+				const inputFile = css.source.input.file;
+				const pluginList = getDefaultPluginsList(opts, inputFile);
+				const resultPluginIndex = result.processor.plugins.findIndex((plugin) => isOurPlugin(plugin));
+				if (resultPluginIndex === -1) throw new Error("Plugin missing from options.");
+				const loader = getLoader(opts, [...result.processor.plugins.slice(0, resultPluginIndex), ...pluginList]);
+				const fetcher = async (file, relativeTo, depTrace) => {
+					const unquoteFile = (0, _unquote.default)(file);
+					return loader.fetch.call(loader, unquoteFile, relativeTo, depTrace);
+				};
+				const parser = new _Parser.default(fetcher);
+				await (0, _postcss.default)([...pluginList, parser.plugin()]).process(css, { from: inputFile });
+				const out = loader.finalSource;
+				if (out) css.prepend(out);
+				if (opts.localsConvention) {
+					const reducer = (0, _localsConvention.makeLocalsConventionReducer)(opts.localsConvention, inputFile);
+					parser.exportTokens = Object.entries(parser.exportTokens).reduce(reducer, {});
+				}
+				result.messages.push({
+					type: "export",
+					plugin: "postcss-modules",
+					exportTokens: parser.exportTokens
+				});
+				return getJSON(css.source.input.file, parser.exportTokens, result.opts.to);
+			}
+		};
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.14/node_modules/postcss-modules/build/index.js
+var require_build = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var _fs = __require("fs");
+	var _fs2 = require_fs();
+	var _pluginFactory = require_pluginFactory();
+	(0, _fs2.setFileSystem)({
+		readFile: _fs.readFile,
+		writeFile: _fs.writeFile
+	});
+	module.exports = (opts = {}) => (0, _pluginFactory.makePlugin)(opts);
+	module.exports.postcss = true;
+}));
+//#endregion
+export default require_build();
+export {};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/dist.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/dist.js
new file mode 100644
index 0000000..ef0d746
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/dist.js
@@ -0,0 +1,6784 @@
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/common/unicode.js
+const UNDEFINED_CODE_POINTS = new Set([
+	65534,
+	65535,
+	131070,
+	131071,
+	196606,
+	196607,
+	262142,
+	262143,
+	327678,
+	327679,
+	393214,
+	393215,
+	458750,
+	458751,
+	524286,
+	524287,
+	589822,
+	589823,
+	655358,
+	655359,
+	720894,
+	720895,
+	786430,
+	786431,
+	851966,
+	851967,
+	917502,
+	917503,
+	983038,
+	983039,
+	1048574,
+	1048575,
+	1114110,
+	1114111
+]);
+var CODE_POINTS;
+(function(CODE_POINTS) {
+	CODE_POINTS[CODE_POINTS["EOF"] = -1] = "EOF";
+	CODE_POINTS[CODE_POINTS["NULL"] = 0] = "NULL";
+	CODE_POINTS[CODE_POINTS["TABULATION"] = 9] = "TABULATION";
+	CODE_POINTS[CODE_POINTS["CARRIAGE_RETURN"] = 13] = "CARRIAGE_RETURN";
+	CODE_POINTS[CODE_POINTS["LINE_FEED"] = 10] = "LINE_FEED";
+	CODE_POINTS[CODE_POINTS["FORM_FEED"] = 12] = "FORM_FEED";
+	CODE_POINTS[CODE_POINTS["SPACE"] = 32] = "SPACE";
+	CODE_POINTS[CODE_POINTS["EXCLAMATION_MARK"] = 33] = "EXCLAMATION_MARK";
+	CODE_POINTS[CODE_POINTS["QUOTATION_MARK"] = 34] = "QUOTATION_MARK";
+	CODE_POINTS[CODE_POINTS["AMPERSAND"] = 38] = "AMPERSAND";
+	CODE_POINTS[CODE_POINTS["APOSTROPHE"] = 39] = "APOSTROPHE";
+	CODE_POINTS[CODE_POINTS["HYPHEN_MINUS"] = 45] = "HYPHEN_MINUS";
+	CODE_POINTS[CODE_POINTS["SOLIDUS"] = 47] = "SOLIDUS";
+	CODE_POINTS[CODE_POINTS["DIGIT_0"] = 48] = "DIGIT_0";
+	CODE_POINTS[CODE_POINTS["DIGIT_9"] = 57] = "DIGIT_9";
+	CODE_POINTS[CODE_POINTS["SEMICOLON"] = 59] = "SEMICOLON";
+	CODE_POINTS[CODE_POINTS["LESS_THAN_SIGN"] = 60] = "LESS_THAN_SIGN";
+	CODE_POINTS[CODE_POINTS["EQUALS_SIGN"] = 61] = "EQUALS_SIGN";
+	CODE_POINTS[CODE_POINTS["GREATER_THAN_SIGN"] = 62] = "GREATER_THAN_SIGN";
+	CODE_POINTS[CODE_POINTS["QUESTION_MARK"] = 63] = "QUESTION_MARK";
+	CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_A"] = 65] = "LATIN_CAPITAL_A";
+	CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_Z"] = 90] = "LATIN_CAPITAL_Z";
+	CODE_POINTS[CODE_POINTS["RIGHT_SQUARE_BRACKET"] = 93] = "RIGHT_SQUARE_BRACKET";
+	CODE_POINTS[CODE_POINTS["GRAVE_ACCENT"] = 96] = "GRAVE_ACCENT";
+	CODE_POINTS[CODE_POINTS["LATIN_SMALL_A"] = 97] = "LATIN_SMALL_A";
+	CODE_POINTS[CODE_POINTS["LATIN_SMALL_Z"] = 122] = "LATIN_SMALL_Z";
+})(CODE_POINTS || (CODE_POINTS = {}));
+const SEQUENCES = {
+	DASH_DASH: "--",
+	CDATA_START: "[CDATA[",
+	DOCTYPE: "doctype",
+	SCRIPT: "script",
+	PUBLIC: "public",
+	SYSTEM: "system"
+};
+function isSurrogate(cp) {
+	return cp >= 55296 && cp <= 57343;
+}
+function isSurrogatePair(cp) {
+	return cp >= 56320 && cp <= 57343;
+}
+function getSurrogatePairCodePoint(cp1, cp2) {
+	return (cp1 - 55296) * 1024 + 9216 + cp2;
+}
+function isControlCodePoint(cp) {
+	return cp !== 32 && cp !== 10 && cp !== 13 && cp !== 9 && cp !== 12 && cp >= 1 && cp <= 31 || cp >= 127 && cp <= 159;
+}
+function isUndefinedCodePoint(cp) {
+	return cp >= 64976 && cp <= 65007 || UNDEFINED_CODE_POINTS.has(cp);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/common/error-codes.js
+var ERR;
+(function(ERR) {
+	ERR["controlCharacterInInputStream"] = "control-character-in-input-stream";
+	ERR["noncharacterInInputStream"] = "noncharacter-in-input-stream";
+	ERR["surrogateInInputStream"] = "surrogate-in-input-stream";
+	ERR["nonVoidHtmlElementStartTagWithTrailingSolidus"] = "non-void-html-element-start-tag-with-trailing-solidus";
+	ERR["endTagWithAttributes"] = "end-tag-with-attributes";
+	ERR["endTagWithTrailingSolidus"] = "end-tag-with-trailing-solidus";
+	ERR["unexpectedSolidusInTag"] = "unexpected-solidus-in-tag";
+	ERR["unexpectedNullCharacter"] = "unexpected-null-character";
+	ERR["unexpectedQuestionMarkInsteadOfTagName"] = "unexpected-question-mark-instead-of-tag-name";
+	ERR["invalidFirstCharacterOfTagName"] = "invalid-first-character-of-tag-name";
+	ERR["unexpectedEqualsSignBeforeAttributeName"] = "unexpected-equals-sign-before-attribute-name";
+	ERR["missingEndTagName"] = "missing-end-tag-name";
+	ERR["unexpectedCharacterInAttributeName"] = "unexpected-character-in-attribute-name";
+	ERR["unknownNamedCharacterReference"] = "unknown-named-character-reference";
+	ERR["missingSemicolonAfterCharacterReference"] = "missing-semicolon-after-character-reference";
+	ERR["unexpectedCharacterAfterDoctypeSystemIdentifier"] = "unexpected-character-after-doctype-system-identifier";
+	ERR["unexpectedCharacterInUnquotedAttributeValue"] = "unexpected-character-in-unquoted-attribute-value";
+	ERR["eofBeforeTagName"] = "eof-before-tag-name";
+	ERR["eofInTag"] = "eof-in-tag";
+	ERR["missingAttributeValue"] = "missing-attribute-value";
+	ERR["missingWhitespaceBetweenAttributes"] = "missing-whitespace-between-attributes";
+	ERR["missingWhitespaceAfterDoctypePublicKeyword"] = "missing-whitespace-after-doctype-public-keyword";
+	ERR["missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers"] = "missing-whitespace-between-doctype-public-and-system-identifiers";
+	ERR["missingWhitespaceAfterDoctypeSystemKeyword"] = "missing-whitespace-after-doctype-system-keyword";
+	ERR["missingQuoteBeforeDoctypePublicIdentifier"] = "missing-quote-before-doctype-public-identifier";
+	ERR["missingQuoteBeforeDoctypeSystemIdentifier"] = "missing-quote-before-doctype-system-identifier";
+	ERR["missingDoctypePublicIdentifier"] = "missing-doctype-public-identifier";
+	ERR["missingDoctypeSystemIdentifier"] = "missing-doctype-system-identifier";
+	ERR["abruptDoctypePublicIdentifier"] = "abrupt-doctype-public-identifier";
+	ERR["abruptDoctypeSystemIdentifier"] = "abrupt-doctype-system-identifier";
+	ERR["cdataInHtmlContent"] = "cdata-in-html-content";
+	ERR["incorrectlyOpenedComment"] = "incorrectly-opened-comment";
+	ERR["eofInScriptHtmlCommentLikeText"] = "eof-in-script-html-comment-like-text";
+	ERR["eofInDoctype"] = "eof-in-doctype";
+	ERR["nestedComment"] = "nested-comment";
+	ERR["abruptClosingOfEmptyComment"] = "abrupt-closing-of-empty-comment";
+	ERR["eofInComment"] = "eof-in-comment";
+	ERR["incorrectlyClosedComment"] = "incorrectly-closed-comment";
+	ERR["eofInCdata"] = "eof-in-cdata";
+	ERR["absenceOfDigitsInNumericCharacterReference"] = "absence-of-digits-in-numeric-character-reference";
+	ERR["nullCharacterReference"] = "null-character-reference";
+	ERR["surrogateCharacterReference"] = "surrogate-character-reference";
+	ERR["characterReferenceOutsideUnicodeRange"] = "character-reference-outside-unicode-range";
+	ERR["controlCharacterReference"] = "control-character-reference";
+	ERR["noncharacterCharacterReference"] = "noncharacter-character-reference";
+	ERR["missingWhitespaceBeforeDoctypeName"] = "missing-whitespace-before-doctype-name";
+	ERR["missingDoctypeName"] = "missing-doctype-name";
+	ERR["invalidCharacterSequenceAfterDoctypeName"] = "invalid-character-sequence-after-doctype-name";
+	ERR["duplicateAttribute"] = "duplicate-attribute";
+	ERR["nonConformingDoctype"] = "non-conforming-doctype";
+	ERR["missingDoctype"] = "missing-doctype";
+	ERR["misplacedDoctype"] = "misplaced-doctype";
+	ERR["endTagWithoutMatchingOpenElement"] = "end-tag-without-matching-open-element";
+	ERR["closingOfElementWithOpenChildElements"] = "closing-of-element-with-open-child-elements";
+	ERR["disallowedContentInNoscriptInHead"] = "disallowed-content-in-noscript-in-head";
+	ERR["openElementsLeftAfterEof"] = "open-elements-left-after-eof";
+	ERR["abandonedHeadElementChild"] = "abandoned-head-element-child";
+	ERR["misplacedStartTagForHeadElement"] = "misplaced-start-tag-for-head-element";
+	ERR["nestedNoscriptInHead"] = "nested-noscript-in-head";
+	ERR["eofInElementThatCanContainOnlyText"] = "eof-in-element-that-can-contain-only-text";
+})(ERR || (ERR = {}));
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/tokenizer/preprocessor.js
+const DEFAULT_BUFFER_WATERLINE = 65536;
+var Preprocessor = class {
+	constructor(handler) {
+		this.handler = handler;
+		this.html = "";
+		this.pos = -1;
+		this.lastGapPos = -2;
+		this.gapStack = [];
+		this.skipNextNewLine = false;
+		this.lastChunkWritten = false;
+		this.endOfChunkHit = false;
+		this.bufferWaterline = DEFAULT_BUFFER_WATERLINE;
+		this.isEol = false;
+		this.lineStartPos = 0;
+		this.droppedBufferSize = 0;
+		this.line = 1;
+		this.lastErrOffset = -1;
+	}
+	/** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */
+	get col() {
+		return this.pos - this.lineStartPos + Number(this.lastGapPos !== this.pos);
+	}
+	get offset() {
+		return this.droppedBufferSize + this.pos;
+	}
+	getError(code, cpOffset) {
+		const { line, col, offset } = this;
+		const startCol = col + cpOffset;
+		const startOffset = offset + cpOffset;
+		return {
+			code,
+			startLine: line,
+			endLine: line,
+			startCol,
+			endCol: startCol,
+			startOffset,
+			endOffset: startOffset
+		};
+	}
+	_err(code) {
+		if (this.handler.onParseError && this.lastErrOffset !== this.offset) {
+			this.lastErrOffset = this.offset;
+			this.handler.onParseError(this.getError(code, 0));
+		}
+	}
+	_addGap() {
+		this.gapStack.push(this.lastGapPos);
+		this.lastGapPos = this.pos;
+	}
+	_processSurrogate(cp) {
+		if (this.pos !== this.html.length - 1) {
+			const nextCp = this.html.charCodeAt(this.pos + 1);
+			if (isSurrogatePair(nextCp)) {
+				this.pos++;
+				this._addGap();
+				return getSurrogatePairCodePoint(cp, nextCp);
+			}
+		} else if (!this.lastChunkWritten) {
+			this.endOfChunkHit = true;
+			return CODE_POINTS.EOF;
+		}
+		this._err(ERR.surrogateInInputStream);
+		return cp;
+	}
+	willDropParsedChunk() {
+		return this.pos > this.bufferWaterline;
+	}
+	dropParsedChunk() {
+		if (this.willDropParsedChunk()) {
+			this.html = this.html.substring(this.pos);
+			this.lineStartPos -= this.pos;
+			this.droppedBufferSize += this.pos;
+			this.pos = 0;
+			this.lastGapPos = -2;
+			this.gapStack.length = 0;
+		}
+	}
+	write(chunk, isLastChunk) {
+		if (this.html.length > 0) this.html += chunk;
+		else this.html = chunk;
+		this.endOfChunkHit = false;
+		this.lastChunkWritten = isLastChunk;
+	}
+	insertHtmlAtCurrentPos(chunk) {
+		this.html = this.html.substring(0, this.pos + 1) + chunk + this.html.substring(this.pos + 1);
+		this.endOfChunkHit = false;
+	}
+	startsWith(pattern, caseSensitive) {
+		if (this.pos + pattern.length > this.html.length) {
+			this.endOfChunkHit = !this.lastChunkWritten;
+			return false;
+		}
+		if (caseSensitive) return this.html.startsWith(pattern, this.pos);
+		for (let i = 0; i < pattern.length; i++) if ((this.html.charCodeAt(this.pos + i) | 32) !== pattern.charCodeAt(i)) return false;
+		return true;
+	}
+	peek(offset) {
+		const pos = this.pos + offset;
+		if (pos >= this.html.length) {
+			this.endOfChunkHit = !this.lastChunkWritten;
+			return CODE_POINTS.EOF;
+		}
+		const code = this.html.charCodeAt(pos);
+		return code === CODE_POINTS.CARRIAGE_RETURN ? CODE_POINTS.LINE_FEED : code;
+	}
+	advance() {
+		this.pos++;
+		if (this.isEol) {
+			this.isEol = false;
+			this.line++;
+			this.lineStartPos = this.pos;
+		}
+		if (this.pos >= this.html.length) {
+			this.endOfChunkHit = !this.lastChunkWritten;
+			return CODE_POINTS.EOF;
+		}
+		let cp = this.html.charCodeAt(this.pos);
+		if (cp === CODE_POINTS.CARRIAGE_RETURN) {
+			this.isEol = true;
+			this.skipNextNewLine = true;
+			return CODE_POINTS.LINE_FEED;
+		}
+		if (cp === CODE_POINTS.LINE_FEED) {
+			this.isEol = true;
+			if (this.skipNextNewLine) {
+				this.line--;
+				this.skipNextNewLine = false;
+				this._addGap();
+				return this.advance();
+			}
+		}
+		this.skipNextNewLine = false;
+		if (isSurrogate(cp)) cp = this._processSurrogate(cp);
+		if (!(this.handler.onParseError === null || cp > 31 && cp < 127 || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.CARRIAGE_RETURN || cp > 159 && cp < 64976)) this._checkForProblematicCharacters(cp);
+		return cp;
+	}
+	_checkForProblematicCharacters(cp) {
+		if (isControlCodePoint(cp)) this._err(ERR.controlCharacterInInputStream);
+		else if (isUndefinedCodePoint(cp)) this._err(ERR.noncharacterInInputStream);
+	}
+	retreat(count) {
+		this.pos -= count;
+		while (this.pos < this.lastGapPos) {
+			this.lastGapPos = this.gapStack.pop();
+			this.pos--;
+		}
+		this.isEol = false;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/common/token.js
+var TokenType;
+(function(TokenType) {
+	TokenType[TokenType["CHARACTER"] = 0] = "CHARACTER";
+	TokenType[TokenType["NULL_CHARACTER"] = 1] = "NULL_CHARACTER";
+	TokenType[TokenType["WHITESPACE_CHARACTER"] = 2] = "WHITESPACE_CHARACTER";
+	TokenType[TokenType["START_TAG"] = 3] = "START_TAG";
+	TokenType[TokenType["END_TAG"] = 4] = "END_TAG";
+	TokenType[TokenType["COMMENT"] = 5] = "COMMENT";
+	TokenType[TokenType["DOCTYPE"] = 6] = "DOCTYPE";
+	TokenType[TokenType["EOF"] = 7] = "EOF";
+	TokenType[TokenType["HIBERNATION"] = 8] = "HIBERNATION";
+})(TokenType || (TokenType = {}));
+function getTokenAttr(token, attrName) {
+	for (let i = token.attrs.length - 1; i >= 0; i--) if (token.attrs[i].name === attrName) return token.attrs[i].value;
+	return null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/decode-codepoint.js
+const decodeMap = new Map([
+	[0, 65533],
+	[128, 8364],
+	[130, 8218],
+	[131, 402],
+	[132, 8222],
+	[133, 8230],
+	[134, 8224],
+	[135, 8225],
+	[136, 710],
+	[137, 8240],
+	[138, 352],
+	[139, 8249],
+	[140, 338],
+	[142, 381],
+	[145, 8216],
+	[146, 8217],
+	[147, 8220],
+	[148, 8221],
+	[149, 8226],
+	[150, 8211],
+	[151, 8212],
+	[152, 732],
+	[153, 8482],
+	[154, 353],
+	[155, 8250],
+	[156, 339],
+	[158, 382],
+	[159, 376]
+]);
+/**
+* Replace the given code point with a replacement character if it is a
+* surrogate or is outside the valid range. Otherwise return the code
+* point unchanged.
+* @param codePoint Unicode code point to convert.
+*/
+function replaceCodePoint(codePoint) {
+	if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) return 65533;
+	return decodeMap.get(codePoint) ?? codePoint;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/internal/decode-shared.js
+/**
+* Shared base64 decode helper for generated decode data.
+* Assumes global atob is available.
+* @param input Input string to encode or decode.
+*/
+function decodeBase64(input) {
+	const binary = atob(input);
+	const evenLength = binary.length & -2;
+	const out = new Uint16Array(evenLength / 2);
+	for (let index = 0, outIndex = 0; index < evenLength; index += 2) {
+		const lo = binary.charCodeAt(index);
+		const hi = binary.charCodeAt(index + 1);
+		out[outIndex++] = lo | hi << 8;
+	}
+	return out;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/generated/decode-data-html.js
+/** Packed HTML decode trie data. */
+const htmlDecodeTree = /* @__PURE__ */ decodeBase64("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");
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/internal/bin-trie-flags.js
+/**
+* Bit flags & masks for the binary trie encoding used for entity decoding.
+*
+* Bit layout (16 bits total):
+* 15..14 VALUE_LENGTH   (+1 encoding; 0 => no value)
+* 13     FLAG13.        If valueLength>0: semicolon required flag (implicit ';').
+*                       If valueLength==0: compact run flag.
+* 12..7  BRANCH_LENGTH  Branch length (0 => single branch in 6..0 if jumpOffset==char) OR run length (when compact run)
+* 6..0   JUMP_TABLE     Jump offset (jump table) OR single-branch char code OR first run char
+*/
+var BinTrieFlags;
+(function(BinTrieFlags) {
+	BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
+	BinTrieFlags[BinTrieFlags["FLAG13"] = 8192] = "FLAG13";
+	BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 8064] = "BRANCH_LENGTH";
+	BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
+})(BinTrieFlags || (BinTrieFlags = {}));
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/decode.js
+var CharCodes;
+(function(CharCodes) {
+	CharCodes[CharCodes["NUM"] = 35] = "NUM";
+	CharCodes[CharCodes["SEMI"] = 59] = "SEMI";
+	CharCodes[CharCodes["EQUALS"] = 61] = "EQUALS";
+	CharCodes[CharCodes["ZERO"] = 48] = "ZERO";
+	CharCodes[CharCodes["NINE"] = 57] = "NINE";
+	CharCodes[CharCodes["LOWER_A"] = 97] = "LOWER_A";
+	CharCodes[CharCodes["LOWER_F"] = 102] = "LOWER_F";
+	CharCodes[CharCodes["LOWER_X"] = 120] = "LOWER_X";
+	CharCodes[CharCodes["LOWER_Z"] = 122] = "LOWER_Z";
+	CharCodes[CharCodes["UPPER_A"] = 65] = "UPPER_A";
+	CharCodes[CharCodes["UPPER_F"] = 70] = "UPPER_F";
+	CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z";
+})(CharCodes || (CharCodes = {}));
+/** Bit that needs to be set to convert an upper case ASCII character to lower case */
+const TO_LOWER_BIT = 32;
+function isNumber(code) {
+	return code >= CharCodes.ZERO && code <= CharCodes.NINE;
+}
+function isHexadecimalCharacter(code) {
+	return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F;
+}
+function isAsciiAlphaNumeric$1(code) {
+	return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z || isNumber(code);
+}
+/**
+* Checks if the given character is a valid end character for an entity in an attribute.
+*
+* Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
+* See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
+* @param code Code point to decode.
+*/
+function isEntityInAttributeInvalidEnd(code) {
+	return code === CharCodes.EQUALS || isAsciiAlphaNumeric$1(code);
+}
+var EntityDecoderState;
+(function(EntityDecoderState) {
+	EntityDecoderState[EntityDecoderState["EntityStart"] = 0] = "EntityStart";
+	EntityDecoderState[EntityDecoderState["NumericStart"] = 1] = "NumericStart";
+	EntityDecoderState[EntityDecoderState["NumericDecimal"] = 2] = "NumericDecimal";
+	EntityDecoderState[EntityDecoderState["NumericHex"] = 3] = "NumericHex";
+	EntityDecoderState[EntityDecoderState["NamedEntity"] = 4] = "NamedEntity";
+})(EntityDecoderState || (EntityDecoderState = {}));
+/**
+* Decoding mode for named entities.
+*/
+var DecodingMode;
+(function(DecodingMode) {
+	/** Entities in text nodes that can end with any character. */
+	DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy";
+	/** Only allow entities terminated with a semicolon. */
+	DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
+	/** Entities in attributes have limitations on ending characters. */
+	DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
+})(DecodingMode || (DecodingMode = {}));
+/**
+* Token decoder with support of writing partial entities.
+*/
+var EntityDecoder = class {
+	decodeTree;
+	emitCodePoint;
+	errors;
+	constructor(decodeTree, emitCodePoint, errors) {
+		this.decodeTree = decodeTree;
+		this.emitCodePoint = emitCodePoint;
+		this.errors = errors;
+	}
+	/** The current state of the decoder. */
+	state = EntityDecoderState.EntityStart;
+	/** Characters that were consumed while parsing an entity. */
+	consumed = 1;
+	/**
+	* The result of the entity.
+	*
+	* Either the result index of a numeric entity, or the codepoint of a
+	* numeric entity.
+	*/
+	result = 0;
+	/** The current index in the decode tree. */
+	treeIndex = 0;
+	/** The number of characters that were consumed in excess. */
+	excess = 1;
+	/** The mode in which the decoder is operating. */
+	decodeMode = DecodingMode.Strict;
+	/** The number of characters that have been consumed in the current run. */
+	runConsumed = 0;
+	/**
+	* Resets the instance to make it reusable.
+	* @param decodeMode Entity decoding mode to use.
+	*/
+	startEntity(decodeMode) {
+		this.decodeMode = decodeMode;
+		this.state = EntityDecoderState.EntityStart;
+		this.result = 0;
+		this.treeIndex = 0;
+		this.excess = 1;
+		this.consumed = 1;
+		this.runConsumed = 0;
+	}
+	/**
+	* Write an entity to the decoder. This can be called multiple times with partial entities.
+	* If the entity is incomplete, the decoder will return -1.
+	*
+	* Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
+	* entity is incomplete, and resume when the next string is written.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	write(input, offset) {
+		switch (this.state) {
+			case EntityDecoderState.EntityStart:
+				if (input.charCodeAt(offset) === CharCodes.NUM) {
+					this.state = EntityDecoderState.NumericStart;
+					this.consumed += 1;
+					return this.stateNumericStart(input, offset + 1);
+				}
+				this.state = EntityDecoderState.NamedEntity;
+				return this.stateNamedEntity(input, offset);
+			case EntityDecoderState.NumericStart: return this.stateNumericStart(input, offset);
+			case EntityDecoderState.NumericDecimal: return this.stateNumericDecimal(input, offset);
+			case EntityDecoderState.NumericHex: return this.stateNumericHex(input, offset);
+			case EntityDecoderState.NamedEntity: return this.stateNamedEntity(input, offset);
+		}
+	}
+	/**
+	* Switches between the numeric decimal and hexadecimal states.
+	*
+	* Equivalent to the `Numeric character reference state` in the HTML spec.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNumericStart(input, offset) {
+		if (offset >= input.length) return -1;
+		if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
+			this.state = EntityDecoderState.NumericHex;
+			this.consumed += 1;
+			return this.stateNumericHex(input, offset + 1);
+		}
+		this.state = EntityDecoderState.NumericDecimal;
+		return this.stateNumericDecimal(input, offset);
+	}
+	/**
+	* Parses a hexadecimal numeric entity.
+	*
+	* Equivalent to the `Hexademical character reference state` in the HTML spec.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNumericHex(input, offset) {
+		while (offset < input.length) {
+			const char = input.charCodeAt(offset);
+			if (isNumber(char) || isHexadecimalCharacter(char)) {
+				const digit = char <= CharCodes.NINE ? char - CharCodes.ZERO : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;
+				this.result = this.result * 16 + digit;
+				this.consumed++;
+				offset++;
+			} else return this.emitNumericEntity(char, 3);
+		}
+		return -1;
+	}
+	/**
+	* Parses a decimal numeric entity.
+	*
+	* Equivalent to the `Decimal character reference state` in the HTML spec.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNumericDecimal(input, offset) {
+		while (offset < input.length) {
+			const char = input.charCodeAt(offset);
+			if (isNumber(char)) {
+				this.result = this.result * 10 + (char - CharCodes.ZERO);
+				this.consumed++;
+				offset++;
+			} else return this.emitNumericEntity(char, 2);
+		}
+		return -1;
+	}
+	/**
+	* Validate and emit a numeric entity.
+	*
+	* Implements the logic from the `Hexademical character reference start
+	* state` and `Numeric character reference end state` in the HTML spec.
+	* @param lastCp The last code point of the entity. Used to see if the
+	*               entity was terminated with a semicolon.
+	* @param expectedLength The minimum number of characters that should be
+	*                       consumed. Used to validate that at least one digit
+	*                       was consumed.
+	* @returns The number of characters that were consumed.
+	*/
+	emitNumericEntity(lastCp, expectedLength) {
+		if (this.consumed <= expectedLength) {
+			this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);
+			return 0;
+		}
+		if (lastCp === CharCodes.SEMI) this.consumed += 1;
+		else if (this.decodeMode === DecodingMode.Strict) return 0;
+		this.emitCodePoint(replaceCodePoint(this.result), this.consumed);
+		if (this.errors) {
+			if (lastCp !== CharCodes.SEMI) this.errors.missingSemicolonAfterCharacterReference();
+			this.errors.validateNumericCharacterReference(this.result);
+		}
+		return this.consumed;
+	}
+	/**
+	* Parses a named entity.
+	*
+	* Equivalent to the `Named character reference state` in the HTML spec.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNamedEntity(input, offset) {
+		const { decodeTree } = this;
+		let current = decodeTree[this.treeIndex];
+		let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+		while (offset < input.length) {
+			if (valueLength === 0 && (current & BinTrieFlags.FLAG13) !== 0) {
+				const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+				if (this.runConsumed === 0) {
+					const firstChar = current & BinTrieFlags.JUMP_TABLE;
+					if (input.charCodeAt(offset) !== firstChar) return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
+					offset++;
+					this.excess++;
+					this.runConsumed++;
+				}
+				while (this.runConsumed < runLength) {
+					if (offset >= input.length) return -1;
+					const charIndexInPacked = this.runConsumed - 1;
+					const packedWord = decodeTree[this.treeIndex + 1 + (charIndexInPacked >> 1)];
+					const expectedChar = charIndexInPacked % 2 === 0 ? packedWord & 255 : packedWord >> 8 & 255;
+					if (input.charCodeAt(offset) !== expectedChar) {
+						this.runConsumed = 0;
+						return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
+					}
+					offset++;
+					this.excess++;
+					this.runConsumed++;
+				}
+				this.runConsumed = 0;
+				this.treeIndex += 1 + (runLength >> 1);
+				current = decodeTree[this.treeIndex];
+				valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+			}
+			if (offset >= input.length) break;
+			const char = input.charCodeAt(offset);
+			if (char === CharCodes.SEMI && valueLength !== 0 && (current & BinTrieFlags.FLAG13) !== 0) return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+			this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
+			if (this.treeIndex < 0) return this.result === 0 || this.decodeMode === DecodingMode.Attribute && (valueLength === 0 || isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();
+			current = decodeTree[this.treeIndex];
+			valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+			if (valueLength !== 0) {
+				if (char === CharCodes.SEMI) return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+				if (this.decodeMode !== DecodingMode.Strict && (current & BinTrieFlags.FLAG13) === 0) {
+					this.result = this.treeIndex;
+					this.consumed += this.excess;
+					this.excess = 0;
+				}
+			}
+			offset++;
+			this.excess++;
+		}
+		return -1;
+	}
+	/**
+	* Emit a named entity that was not terminated with a semicolon.
+	* @returns The number of characters consumed.
+	*/
+	emitNotTerminatedNamedEntity() {
+		const { result, decodeTree } = this;
+		const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
+		this.emitNamedEntityData(result, valueLength, this.consumed);
+		this.errors?.missingSemicolonAfterCharacterReference();
+		return this.consumed;
+	}
+	/**
+	* Emit a named entity.
+	* @param result The index of the entity in the decode tree.
+	* @param valueLength The number of bytes in the entity.
+	* @param consumed The number of characters consumed.
+	* @returns The number of characters consumed.
+	*/
+	emitNamedEntityData(result, valueLength, consumed) {
+		const { decodeTree } = this;
+		this.emitCodePoint(valueLength === 1 ? decodeTree[result] & ~(BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13) : decodeTree[result + 1], consumed);
+		if (valueLength === 3) this.emitCodePoint(decodeTree[result + 2], consumed);
+		return consumed;
+	}
+	/**
+	* Signal to the parser that the end of the input was reached.
+	*
+	* Remaining data will be emitted and relevant errors will be produced.
+	* @returns The number of characters consumed.
+	*/
+	end() {
+		switch (this.state) {
+			case EntityDecoderState.NamedEntity: return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
+			case EntityDecoderState.NumericDecimal: return this.emitNumericEntity(0, 2);
+			case EntityDecoderState.NumericHex: return this.emitNumericEntity(0, 3);
+			case EntityDecoderState.NumericStart:
+				this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);
+				return 0;
+			case EntityDecoderState.EntityStart: return 0;
+		}
+	}
+};
+/**
+* Determines the branch of the current node that is taken given the current
+* character. This function is used to traverse the trie.
+* @param decodeTree The trie.
+* @param current The current node.
+* @param nodeIndex Index immediately after the current node header.
+* @param char The current character.
+* @returns The index of the next node, or -1 if no branch is taken.
+*/
+function determineBranch(decodeTree, current, nodeIndex, char) {
+	const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+	const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
+	if (branchCount === 0) return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;
+	if (jumpOffset) {
+		const value = char - jumpOffset;
+		return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIndex + value] - 1;
+	}
+	const packedKeySlots = branchCount + 1 >> 1;
+	let lo = 0;
+	let hi = branchCount - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >>> 1;
+		const midKey = decodeTree[nodeIndex + (mid >> 1)] >> (mid & 1) * 8 & 255;
+		if (midKey < char) lo = mid + 1;
+		else if (midKey > char) hi = mid - 1;
+		else return decodeTree[nodeIndex + packedKeySlots + mid];
+	}
+	return -1;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/common/html.js
+/** All valid namespaces in HTML. */
+var NS;
+(function(NS) {
+	NS["HTML"] = "http://www.w3.org/1999/xhtml";
+	NS["MATHML"] = "http://www.w3.org/1998/Math/MathML";
+	NS["SVG"] = "http://www.w3.org/2000/svg";
+	NS["XLINK"] = "http://www.w3.org/1999/xlink";
+	NS["XML"] = "http://www.w3.org/XML/1998/namespace";
+	NS["XMLNS"] = "http://www.w3.org/2000/xmlns/";
+})(NS || (NS = {}));
+var ATTRS;
+(function(ATTRS) {
+	ATTRS["TYPE"] = "type";
+	ATTRS["ACTION"] = "action";
+	ATTRS["ENCODING"] = "encoding";
+	ATTRS["PROMPT"] = "prompt";
+	ATTRS["NAME"] = "name";
+	ATTRS["COLOR"] = "color";
+	ATTRS["FACE"] = "face";
+	ATTRS["SIZE"] = "size";
+})(ATTRS || (ATTRS = {}));
+/**
+* The mode of the document.
+*
+* @see {@link https://dom.spec.whatwg.org/#concept-document-limited-quirks}
+*/
+var DOCUMENT_MODE;
+(function(DOCUMENT_MODE) {
+	DOCUMENT_MODE["NO_QUIRKS"] = "no-quirks";
+	DOCUMENT_MODE["QUIRKS"] = "quirks";
+	DOCUMENT_MODE["LIMITED_QUIRKS"] = "limited-quirks";
+})(DOCUMENT_MODE || (DOCUMENT_MODE = {}));
+var TAG_NAMES;
+(function(TAG_NAMES) {
+	TAG_NAMES["A"] = "a";
+	TAG_NAMES["ADDRESS"] = "address";
+	TAG_NAMES["ANNOTATION_XML"] = "annotation-xml";
+	TAG_NAMES["APPLET"] = "applet";
+	TAG_NAMES["AREA"] = "area";
+	TAG_NAMES["ARTICLE"] = "article";
+	TAG_NAMES["ASIDE"] = "aside";
+	TAG_NAMES["B"] = "b";
+	TAG_NAMES["BASE"] = "base";
+	TAG_NAMES["BASEFONT"] = "basefont";
+	TAG_NAMES["BGSOUND"] = "bgsound";
+	TAG_NAMES["BIG"] = "big";
+	TAG_NAMES["BLOCKQUOTE"] = "blockquote";
+	TAG_NAMES["BODY"] = "body";
+	TAG_NAMES["BR"] = "br";
+	TAG_NAMES["BUTTON"] = "button";
+	TAG_NAMES["CAPTION"] = "caption";
+	TAG_NAMES["CENTER"] = "center";
+	TAG_NAMES["CODE"] = "code";
+	TAG_NAMES["COL"] = "col";
+	TAG_NAMES["COLGROUP"] = "colgroup";
+	TAG_NAMES["DD"] = "dd";
+	TAG_NAMES["DESC"] = "desc";
+	TAG_NAMES["DETAILS"] = "details";
+	TAG_NAMES["DIALOG"] = "dialog";
+	TAG_NAMES["DIR"] = "dir";
+	TAG_NAMES["DIV"] = "div";
+	TAG_NAMES["DL"] = "dl";
+	TAG_NAMES["DT"] = "dt";
+	TAG_NAMES["EM"] = "em";
+	TAG_NAMES["EMBED"] = "embed";
+	TAG_NAMES["FIELDSET"] = "fieldset";
+	TAG_NAMES["FIGCAPTION"] = "figcaption";
+	TAG_NAMES["FIGURE"] = "figure";
+	TAG_NAMES["FONT"] = "font";
+	TAG_NAMES["FOOTER"] = "footer";
+	TAG_NAMES["FOREIGN_OBJECT"] = "foreignObject";
+	TAG_NAMES["FORM"] = "form";
+	TAG_NAMES["FRAME"] = "frame";
+	TAG_NAMES["FRAMESET"] = "frameset";
+	TAG_NAMES["H1"] = "h1";
+	TAG_NAMES["H2"] = "h2";
+	TAG_NAMES["H3"] = "h3";
+	TAG_NAMES["H4"] = "h4";
+	TAG_NAMES["H5"] = "h5";
+	TAG_NAMES["H6"] = "h6";
+	TAG_NAMES["HEAD"] = "head";
+	TAG_NAMES["HEADER"] = "header";
+	TAG_NAMES["HGROUP"] = "hgroup";
+	TAG_NAMES["HR"] = "hr";
+	TAG_NAMES["HTML"] = "html";
+	TAG_NAMES["I"] = "i";
+	TAG_NAMES["IMG"] = "img";
+	TAG_NAMES["IMAGE"] = "image";
+	TAG_NAMES["INPUT"] = "input";
+	TAG_NAMES["IFRAME"] = "iframe";
+	TAG_NAMES["KEYGEN"] = "keygen";
+	TAG_NAMES["LABEL"] = "label";
+	TAG_NAMES["LI"] = "li";
+	TAG_NAMES["LINK"] = "link";
+	TAG_NAMES["LISTING"] = "listing";
+	TAG_NAMES["MAIN"] = "main";
+	TAG_NAMES["MALIGNMARK"] = "malignmark";
+	TAG_NAMES["MARQUEE"] = "marquee";
+	TAG_NAMES["MATH"] = "math";
+	TAG_NAMES["MENU"] = "menu";
+	TAG_NAMES["META"] = "meta";
+	TAG_NAMES["MGLYPH"] = "mglyph";
+	TAG_NAMES["MI"] = "mi";
+	TAG_NAMES["MO"] = "mo";
+	TAG_NAMES["MN"] = "mn";
+	TAG_NAMES["MS"] = "ms";
+	TAG_NAMES["MTEXT"] = "mtext";
+	TAG_NAMES["NAV"] = "nav";
+	TAG_NAMES["NOBR"] = "nobr";
+	TAG_NAMES["NOFRAMES"] = "noframes";
+	TAG_NAMES["NOEMBED"] = "noembed";
+	TAG_NAMES["NOSCRIPT"] = "noscript";
+	TAG_NAMES["OBJECT"] = "object";
+	TAG_NAMES["OL"] = "ol";
+	TAG_NAMES["OPTGROUP"] = "optgroup";
+	TAG_NAMES["OPTION"] = "option";
+	TAG_NAMES["P"] = "p";
+	TAG_NAMES["PARAM"] = "param";
+	TAG_NAMES["PLAINTEXT"] = "plaintext";
+	TAG_NAMES["PRE"] = "pre";
+	TAG_NAMES["RB"] = "rb";
+	TAG_NAMES["RP"] = "rp";
+	TAG_NAMES["RT"] = "rt";
+	TAG_NAMES["RTC"] = "rtc";
+	TAG_NAMES["RUBY"] = "ruby";
+	TAG_NAMES["S"] = "s";
+	TAG_NAMES["SCRIPT"] = "script";
+	TAG_NAMES["SEARCH"] = "search";
+	TAG_NAMES["SECTION"] = "section";
+	TAG_NAMES["SELECT"] = "select";
+	TAG_NAMES["SOURCE"] = "source";
+	TAG_NAMES["SMALL"] = "small";
+	TAG_NAMES["SPAN"] = "span";
+	TAG_NAMES["STRIKE"] = "strike";
+	TAG_NAMES["STRONG"] = "strong";
+	TAG_NAMES["STYLE"] = "style";
+	TAG_NAMES["SUB"] = "sub";
+	TAG_NAMES["SUMMARY"] = "summary";
+	TAG_NAMES["SUP"] = "sup";
+	TAG_NAMES["TABLE"] = "table";
+	TAG_NAMES["TBODY"] = "tbody";
+	TAG_NAMES["TEMPLATE"] = "template";
+	TAG_NAMES["TEXTAREA"] = "textarea";
+	TAG_NAMES["TFOOT"] = "tfoot";
+	TAG_NAMES["TD"] = "td";
+	TAG_NAMES["TH"] = "th";
+	TAG_NAMES["THEAD"] = "thead";
+	TAG_NAMES["TITLE"] = "title";
+	TAG_NAMES["TR"] = "tr";
+	TAG_NAMES["TRACK"] = "track";
+	TAG_NAMES["TT"] = "tt";
+	TAG_NAMES["U"] = "u";
+	TAG_NAMES["UL"] = "ul";
+	TAG_NAMES["SVG"] = "svg";
+	TAG_NAMES["VAR"] = "var";
+	TAG_NAMES["WBR"] = "wbr";
+	TAG_NAMES["XMP"] = "xmp";
+})(TAG_NAMES || (TAG_NAMES = {}));
+/**
+* Tag IDs are numeric IDs for known tag names.
+*
+* We use tag IDs to improve the performance of tag name comparisons.
+*/
+var TAG_ID;
+(function(TAG_ID) {
+	TAG_ID[TAG_ID["UNKNOWN"] = 0] = "UNKNOWN";
+	TAG_ID[TAG_ID["A"] = 1] = "A";
+	TAG_ID[TAG_ID["ADDRESS"] = 2] = "ADDRESS";
+	TAG_ID[TAG_ID["ANNOTATION_XML"] = 3] = "ANNOTATION_XML";
+	TAG_ID[TAG_ID["APPLET"] = 4] = "APPLET";
+	TAG_ID[TAG_ID["AREA"] = 5] = "AREA";
+	TAG_ID[TAG_ID["ARTICLE"] = 6] = "ARTICLE";
+	TAG_ID[TAG_ID["ASIDE"] = 7] = "ASIDE";
+	TAG_ID[TAG_ID["B"] = 8] = "B";
+	TAG_ID[TAG_ID["BASE"] = 9] = "BASE";
+	TAG_ID[TAG_ID["BASEFONT"] = 10] = "BASEFONT";
+	TAG_ID[TAG_ID["BGSOUND"] = 11] = "BGSOUND";
+	TAG_ID[TAG_ID["BIG"] = 12] = "BIG";
+	TAG_ID[TAG_ID["BLOCKQUOTE"] = 13] = "BLOCKQUOTE";
+	TAG_ID[TAG_ID["BODY"] = 14] = "BODY";
+	TAG_ID[TAG_ID["BR"] = 15] = "BR";
+	TAG_ID[TAG_ID["BUTTON"] = 16] = "BUTTON";
+	TAG_ID[TAG_ID["CAPTION"] = 17] = "CAPTION";
+	TAG_ID[TAG_ID["CENTER"] = 18] = "CENTER";
+	TAG_ID[TAG_ID["CODE"] = 19] = "CODE";
+	TAG_ID[TAG_ID["COL"] = 20] = "COL";
+	TAG_ID[TAG_ID["COLGROUP"] = 21] = "COLGROUP";
+	TAG_ID[TAG_ID["DD"] = 22] = "DD";
+	TAG_ID[TAG_ID["DESC"] = 23] = "DESC";
+	TAG_ID[TAG_ID["DETAILS"] = 24] = "DETAILS";
+	TAG_ID[TAG_ID["DIALOG"] = 25] = "DIALOG";
+	TAG_ID[TAG_ID["DIR"] = 26] = "DIR";
+	TAG_ID[TAG_ID["DIV"] = 27] = "DIV";
+	TAG_ID[TAG_ID["DL"] = 28] = "DL";
+	TAG_ID[TAG_ID["DT"] = 29] = "DT";
+	TAG_ID[TAG_ID["EM"] = 30] = "EM";
+	TAG_ID[TAG_ID["EMBED"] = 31] = "EMBED";
+	TAG_ID[TAG_ID["FIELDSET"] = 32] = "FIELDSET";
+	TAG_ID[TAG_ID["FIGCAPTION"] = 33] = "FIGCAPTION";
+	TAG_ID[TAG_ID["FIGURE"] = 34] = "FIGURE";
+	TAG_ID[TAG_ID["FONT"] = 35] = "FONT";
+	TAG_ID[TAG_ID["FOOTER"] = 36] = "FOOTER";
+	TAG_ID[TAG_ID["FOREIGN_OBJECT"] = 37] = "FOREIGN_OBJECT";
+	TAG_ID[TAG_ID["FORM"] = 38] = "FORM";
+	TAG_ID[TAG_ID["FRAME"] = 39] = "FRAME";
+	TAG_ID[TAG_ID["FRAMESET"] = 40] = "FRAMESET";
+	TAG_ID[TAG_ID["H1"] = 41] = "H1";
+	TAG_ID[TAG_ID["H2"] = 42] = "H2";
+	TAG_ID[TAG_ID["H3"] = 43] = "H3";
+	TAG_ID[TAG_ID["H4"] = 44] = "H4";
+	TAG_ID[TAG_ID["H5"] = 45] = "H5";
+	TAG_ID[TAG_ID["H6"] = 46] = "H6";
+	TAG_ID[TAG_ID["HEAD"] = 47] = "HEAD";
+	TAG_ID[TAG_ID["HEADER"] = 48] = "HEADER";
+	TAG_ID[TAG_ID["HGROUP"] = 49] = "HGROUP";
+	TAG_ID[TAG_ID["HR"] = 50] = "HR";
+	TAG_ID[TAG_ID["HTML"] = 51] = "HTML";
+	TAG_ID[TAG_ID["I"] = 52] = "I";
+	TAG_ID[TAG_ID["IMG"] = 53] = "IMG";
+	TAG_ID[TAG_ID["IMAGE"] = 54] = "IMAGE";
+	TAG_ID[TAG_ID["INPUT"] = 55] = "INPUT";
+	TAG_ID[TAG_ID["IFRAME"] = 56] = "IFRAME";
+	TAG_ID[TAG_ID["KEYGEN"] = 57] = "KEYGEN";
+	TAG_ID[TAG_ID["LABEL"] = 58] = "LABEL";
+	TAG_ID[TAG_ID["LI"] = 59] = "LI";
+	TAG_ID[TAG_ID["LINK"] = 60] = "LINK";
+	TAG_ID[TAG_ID["LISTING"] = 61] = "LISTING";
+	TAG_ID[TAG_ID["MAIN"] = 62] = "MAIN";
+	TAG_ID[TAG_ID["MALIGNMARK"] = 63] = "MALIGNMARK";
+	TAG_ID[TAG_ID["MARQUEE"] = 64] = "MARQUEE";
+	TAG_ID[TAG_ID["MATH"] = 65] = "MATH";
+	TAG_ID[TAG_ID["MENU"] = 66] = "MENU";
+	TAG_ID[TAG_ID["META"] = 67] = "META";
+	TAG_ID[TAG_ID["MGLYPH"] = 68] = "MGLYPH";
+	TAG_ID[TAG_ID["MI"] = 69] = "MI";
+	TAG_ID[TAG_ID["MO"] = 70] = "MO";
+	TAG_ID[TAG_ID["MN"] = 71] = "MN";
+	TAG_ID[TAG_ID["MS"] = 72] = "MS";
+	TAG_ID[TAG_ID["MTEXT"] = 73] = "MTEXT";
+	TAG_ID[TAG_ID["NAV"] = 74] = "NAV";
+	TAG_ID[TAG_ID["NOBR"] = 75] = "NOBR";
+	TAG_ID[TAG_ID["NOFRAMES"] = 76] = "NOFRAMES";
+	TAG_ID[TAG_ID["NOEMBED"] = 77] = "NOEMBED";
+	TAG_ID[TAG_ID["NOSCRIPT"] = 78] = "NOSCRIPT";
+	TAG_ID[TAG_ID["OBJECT"] = 79] = "OBJECT";
+	TAG_ID[TAG_ID["OL"] = 80] = "OL";
+	TAG_ID[TAG_ID["OPTGROUP"] = 81] = "OPTGROUP";
+	TAG_ID[TAG_ID["OPTION"] = 82] = "OPTION";
+	TAG_ID[TAG_ID["P"] = 83] = "P";
+	TAG_ID[TAG_ID["PARAM"] = 84] = "PARAM";
+	TAG_ID[TAG_ID["PLAINTEXT"] = 85] = "PLAINTEXT";
+	TAG_ID[TAG_ID["PRE"] = 86] = "PRE";
+	TAG_ID[TAG_ID["RB"] = 87] = "RB";
+	TAG_ID[TAG_ID["RP"] = 88] = "RP";
+	TAG_ID[TAG_ID["RT"] = 89] = "RT";
+	TAG_ID[TAG_ID["RTC"] = 90] = "RTC";
+	TAG_ID[TAG_ID["RUBY"] = 91] = "RUBY";
+	TAG_ID[TAG_ID["S"] = 92] = "S";
+	TAG_ID[TAG_ID["SCRIPT"] = 93] = "SCRIPT";
+	TAG_ID[TAG_ID["SEARCH"] = 94] = "SEARCH";
+	TAG_ID[TAG_ID["SECTION"] = 95] = "SECTION";
+	TAG_ID[TAG_ID["SELECT"] = 96] = "SELECT";
+	TAG_ID[TAG_ID["SOURCE"] = 97] = "SOURCE";
+	TAG_ID[TAG_ID["SMALL"] = 98] = "SMALL";
+	TAG_ID[TAG_ID["SPAN"] = 99] = "SPAN";
+	TAG_ID[TAG_ID["STRIKE"] = 100] = "STRIKE";
+	TAG_ID[TAG_ID["STRONG"] = 101] = "STRONG";
+	TAG_ID[TAG_ID["STYLE"] = 102] = "STYLE";
+	TAG_ID[TAG_ID["SUB"] = 103] = "SUB";
+	TAG_ID[TAG_ID["SUMMARY"] = 104] = "SUMMARY";
+	TAG_ID[TAG_ID["SUP"] = 105] = "SUP";
+	TAG_ID[TAG_ID["TABLE"] = 106] = "TABLE";
+	TAG_ID[TAG_ID["TBODY"] = 107] = "TBODY";
+	TAG_ID[TAG_ID["TEMPLATE"] = 108] = "TEMPLATE";
+	TAG_ID[TAG_ID["TEXTAREA"] = 109] = "TEXTAREA";
+	TAG_ID[TAG_ID["TFOOT"] = 110] = "TFOOT";
+	TAG_ID[TAG_ID["TD"] = 111] = "TD";
+	TAG_ID[TAG_ID["TH"] = 112] = "TH";
+	TAG_ID[TAG_ID["THEAD"] = 113] = "THEAD";
+	TAG_ID[TAG_ID["TITLE"] = 114] = "TITLE";
+	TAG_ID[TAG_ID["TR"] = 115] = "TR";
+	TAG_ID[TAG_ID["TRACK"] = 116] = "TRACK";
+	TAG_ID[TAG_ID["TT"] = 117] = "TT";
+	TAG_ID[TAG_ID["U"] = 118] = "U";
+	TAG_ID[TAG_ID["UL"] = 119] = "UL";
+	TAG_ID[TAG_ID["SVG"] = 120] = "SVG";
+	TAG_ID[TAG_ID["VAR"] = 121] = "VAR";
+	TAG_ID[TAG_ID["WBR"] = 122] = "WBR";
+	TAG_ID[TAG_ID["XMP"] = 123] = "XMP";
+})(TAG_ID || (TAG_ID = {}));
+const TAG_NAME_TO_ID = new Map([
+	[TAG_NAMES.A, TAG_ID.A],
+	[TAG_NAMES.ADDRESS, TAG_ID.ADDRESS],
+	[TAG_NAMES.ANNOTATION_XML, TAG_ID.ANNOTATION_XML],
+	[TAG_NAMES.APPLET, TAG_ID.APPLET],
+	[TAG_NAMES.AREA, TAG_ID.AREA],
+	[TAG_NAMES.ARTICLE, TAG_ID.ARTICLE],
+	[TAG_NAMES.ASIDE, TAG_ID.ASIDE],
+	[TAG_NAMES.B, TAG_ID.B],
+	[TAG_NAMES.BASE, TAG_ID.BASE],
+	[TAG_NAMES.BASEFONT, TAG_ID.BASEFONT],
+	[TAG_NAMES.BGSOUND, TAG_ID.BGSOUND],
+	[TAG_NAMES.BIG, TAG_ID.BIG],
+	[TAG_NAMES.BLOCKQUOTE, TAG_ID.BLOCKQUOTE],
+	[TAG_NAMES.BODY, TAG_ID.BODY],
+	[TAG_NAMES.BR, TAG_ID.BR],
+	[TAG_NAMES.BUTTON, TAG_ID.BUTTON],
+	[TAG_NAMES.CAPTION, TAG_ID.CAPTION],
+	[TAG_NAMES.CENTER, TAG_ID.CENTER],
+	[TAG_NAMES.CODE, TAG_ID.CODE],
+	[TAG_NAMES.COL, TAG_ID.COL],
+	[TAG_NAMES.COLGROUP, TAG_ID.COLGROUP],
+	[TAG_NAMES.DD, TAG_ID.DD],
+	[TAG_NAMES.DESC, TAG_ID.DESC],
+	[TAG_NAMES.DETAILS, TAG_ID.DETAILS],
+	[TAG_NAMES.DIALOG, TAG_ID.DIALOG],
+	[TAG_NAMES.DIR, TAG_ID.DIR],
+	[TAG_NAMES.DIV, TAG_ID.DIV],
+	[TAG_NAMES.DL, TAG_ID.DL],
+	[TAG_NAMES.DT, TAG_ID.DT],
+	[TAG_NAMES.EM, TAG_ID.EM],
+	[TAG_NAMES.EMBED, TAG_ID.EMBED],
+	[TAG_NAMES.FIELDSET, TAG_ID.FIELDSET],
+	[TAG_NAMES.FIGCAPTION, TAG_ID.FIGCAPTION],
+	[TAG_NAMES.FIGURE, TAG_ID.FIGURE],
+	[TAG_NAMES.FONT, TAG_ID.FONT],
+	[TAG_NAMES.FOOTER, TAG_ID.FOOTER],
+	[TAG_NAMES.FOREIGN_OBJECT, TAG_ID.FOREIGN_OBJECT],
+	[TAG_NAMES.FORM, TAG_ID.FORM],
+	[TAG_NAMES.FRAME, TAG_ID.FRAME],
+	[TAG_NAMES.FRAMESET, TAG_ID.FRAMESET],
+	[TAG_NAMES.H1, TAG_ID.H1],
+	[TAG_NAMES.H2, TAG_ID.H2],
+	[TAG_NAMES.H3, TAG_ID.H3],
+	[TAG_NAMES.H4, TAG_ID.H4],
+	[TAG_NAMES.H5, TAG_ID.H5],
+	[TAG_NAMES.H6, TAG_ID.H6],
+	[TAG_NAMES.HEAD, TAG_ID.HEAD],
+	[TAG_NAMES.HEADER, TAG_ID.HEADER],
+	[TAG_NAMES.HGROUP, TAG_ID.HGROUP],
+	[TAG_NAMES.HR, TAG_ID.HR],
+	[TAG_NAMES.HTML, TAG_ID.HTML],
+	[TAG_NAMES.I, TAG_ID.I],
+	[TAG_NAMES.IMG, TAG_ID.IMG],
+	[TAG_NAMES.IMAGE, TAG_ID.IMAGE],
+	[TAG_NAMES.INPUT, TAG_ID.INPUT],
+	[TAG_NAMES.IFRAME, TAG_ID.IFRAME],
+	[TAG_NAMES.KEYGEN, TAG_ID.KEYGEN],
+	[TAG_NAMES.LABEL, TAG_ID.LABEL],
+	[TAG_NAMES.LI, TAG_ID.LI],
+	[TAG_NAMES.LINK, TAG_ID.LINK],
+	[TAG_NAMES.LISTING, TAG_ID.LISTING],
+	[TAG_NAMES.MAIN, TAG_ID.MAIN],
+	[TAG_NAMES.MALIGNMARK, TAG_ID.MALIGNMARK],
+	[TAG_NAMES.MARQUEE, TAG_ID.MARQUEE],
+	[TAG_NAMES.MATH, TAG_ID.MATH],
+	[TAG_NAMES.MENU, TAG_ID.MENU],
+	[TAG_NAMES.META, TAG_ID.META],
+	[TAG_NAMES.MGLYPH, TAG_ID.MGLYPH],
+	[TAG_NAMES.MI, TAG_ID.MI],
+	[TAG_NAMES.MO, TAG_ID.MO],
+	[TAG_NAMES.MN, TAG_ID.MN],
+	[TAG_NAMES.MS, TAG_ID.MS],
+	[TAG_NAMES.MTEXT, TAG_ID.MTEXT],
+	[TAG_NAMES.NAV, TAG_ID.NAV],
+	[TAG_NAMES.NOBR, TAG_ID.NOBR],
+	[TAG_NAMES.NOFRAMES, TAG_ID.NOFRAMES],
+	[TAG_NAMES.NOEMBED, TAG_ID.NOEMBED],
+	[TAG_NAMES.NOSCRIPT, TAG_ID.NOSCRIPT],
+	[TAG_NAMES.OBJECT, TAG_ID.OBJECT],
+	[TAG_NAMES.OL, TAG_ID.OL],
+	[TAG_NAMES.OPTGROUP, TAG_ID.OPTGROUP],
+	[TAG_NAMES.OPTION, TAG_ID.OPTION],
+	[TAG_NAMES.P, TAG_ID.P],
+	[TAG_NAMES.PARAM, TAG_ID.PARAM],
+	[TAG_NAMES.PLAINTEXT, TAG_ID.PLAINTEXT],
+	[TAG_NAMES.PRE, TAG_ID.PRE],
+	[TAG_NAMES.RB, TAG_ID.RB],
+	[TAG_NAMES.RP, TAG_ID.RP],
+	[TAG_NAMES.RT, TAG_ID.RT],
+	[TAG_NAMES.RTC, TAG_ID.RTC],
+	[TAG_NAMES.RUBY, TAG_ID.RUBY],
+	[TAG_NAMES.S, TAG_ID.S],
+	[TAG_NAMES.SCRIPT, TAG_ID.SCRIPT],
+	[TAG_NAMES.SEARCH, TAG_ID.SEARCH],
+	[TAG_NAMES.SECTION, TAG_ID.SECTION],
+	[TAG_NAMES.SELECT, TAG_ID.SELECT],
+	[TAG_NAMES.SOURCE, TAG_ID.SOURCE],
+	[TAG_NAMES.SMALL, TAG_ID.SMALL],
+	[TAG_NAMES.SPAN, TAG_ID.SPAN],
+	[TAG_NAMES.STRIKE, TAG_ID.STRIKE],
+	[TAG_NAMES.STRONG, TAG_ID.STRONG],
+	[TAG_NAMES.STYLE, TAG_ID.STYLE],
+	[TAG_NAMES.SUB, TAG_ID.SUB],
+	[TAG_NAMES.SUMMARY, TAG_ID.SUMMARY],
+	[TAG_NAMES.SUP, TAG_ID.SUP],
+	[TAG_NAMES.TABLE, TAG_ID.TABLE],
+	[TAG_NAMES.TBODY, TAG_ID.TBODY],
+	[TAG_NAMES.TEMPLATE, TAG_ID.TEMPLATE],
+	[TAG_NAMES.TEXTAREA, TAG_ID.TEXTAREA],
+	[TAG_NAMES.TFOOT, TAG_ID.TFOOT],
+	[TAG_NAMES.TD, TAG_ID.TD],
+	[TAG_NAMES.TH, TAG_ID.TH],
+	[TAG_NAMES.THEAD, TAG_ID.THEAD],
+	[TAG_NAMES.TITLE, TAG_ID.TITLE],
+	[TAG_NAMES.TR, TAG_ID.TR],
+	[TAG_NAMES.TRACK, TAG_ID.TRACK],
+	[TAG_NAMES.TT, TAG_ID.TT],
+	[TAG_NAMES.U, TAG_ID.U],
+	[TAG_NAMES.UL, TAG_ID.UL],
+	[TAG_NAMES.SVG, TAG_ID.SVG],
+	[TAG_NAMES.VAR, TAG_ID.VAR],
+	[TAG_NAMES.WBR, TAG_ID.WBR],
+	[TAG_NAMES.XMP, TAG_ID.XMP]
+]);
+function getTagID(tagName) {
+	var _a;
+	return (_a = TAG_NAME_TO_ID.get(tagName)) !== null && _a !== void 0 ? _a : TAG_ID.UNKNOWN;
+}
+const $ = TAG_ID;
+const SPECIAL_ELEMENTS = {
+	[NS.HTML]: new Set([
+		$.ADDRESS,
+		$.APPLET,
+		$.AREA,
+		$.ARTICLE,
+		$.ASIDE,
+		$.BASE,
+		$.BASEFONT,
+		$.BGSOUND,
+		$.BLOCKQUOTE,
+		$.BODY,
+		$.BR,
+		$.BUTTON,
+		$.CAPTION,
+		$.CENTER,
+		$.COL,
+		$.COLGROUP,
+		$.DD,
+		$.DETAILS,
+		$.DIR,
+		$.DIV,
+		$.DL,
+		$.DT,
+		$.EMBED,
+		$.FIELDSET,
+		$.FIGCAPTION,
+		$.FIGURE,
+		$.FOOTER,
+		$.FORM,
+		$.FRAME,
+		$.FRAMESET,
+		$.H1,
+		$.H2,
+		$.H3,
+		$.H4,
+		$.H5,
+		$.H6,
+		$.HEAD,
+		$.HEADER,
+		$.HGROUP,
+		$.HR,
+		$.HTML,
+		$.IFRAME,
+		$.IMG,
+		$.INPUT,
+		$.LI,
+		$.LINK,
+		$.LISTING,
+		$.MAIN,
+		$.MARQUEE,
+		$.MENU,
+		$.META,
+		$.NAV,
+		$.NOEMBED,
+		$.NOFRAMES,
+		$.NOSCRIPT,
+		$.OBJECT,
+		$.OL,
+		$.P,
+		$.PARAM,
+		$.PLAINTEXT,
+		$.PRE,
+		$.SCRIPT,
+		$.SECTION,
+		$.SELECT,
+		$.SOURCE,
+		$.STYLE,
+		$.SUMMARY,
+		$.TABLE,
+		$.TBODY,
+		$.TD,
+		$.TEMPLATE,
+		$.TEXTAREA,
+		$.TFOOT,
+		$.TH,
+		$.THEAD,
+		$.TITLE,
+		$.TR,
+		$.TRACK,
+		$.UL,
+		$.WBR,
+		$.XMP
+	]),
+	[NS.MATHML]: new Set([
+		$.MI,
+		$.MO,
+		$.MN,
+		$.MS,
+		$.MTEXT,
+		$.ANNOTATION_XML
+	]),
+	[NS.SVG]: new Set([
+		$.TITLE,
+		$.FOREIGN_OBJECT,
+		$.DESC
+	]),
+	[NS.XLINK]: /* @__PURE__ */ new Set(),
+	[NS.XML]: /* @__PURE__ */ new Set(),
+	[NS.XMLNS]: /* @__PURE__ */ new Set()
+};
+const NUMBERED_HEADERS = new Set([
+	$.H1,
+	$.H2,
+	$.H3,
+	$.H4,
+	$.H5,
+	$.H6
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/tokenizer/index.js
+var State;
+(function(State) {
+	State[State["DATA"] = 0] = "DATA";
+	State[State["RCDATA"] = 1] = "RCDATA";
+	State[State["RAWTEXT"] = 2] = "RAWTEXT";
+	State[State["SCRIPT_DATA"] = 3] = "SCRIPT_DATA";
+	State[State["PLAINTEXT"] = 4] = "PLAINTEXT";
+	State[State["TAG_OPEN"] = 5] = "TAG_OPEN";
+	State[State["END_TAG_OPEN"] = 6] = "END_TAG_OPEN";
+	State[State["TAG_NAME"] = 7] = "TAG_NAME";
+	State[State["RCDATA_LESS_THAN_SIGN"] = 8] = "RCDATA_LESS_THAN_SIGN";
+	State[State["RCDATA_END_TAG_OPEN"] = 9] = "RCDATA_END_TAG_OPEN";
+	State[State["RCDATA_END_TAG_NAME"] = 10] = "RCDATA_END_TAG_NAME";
+	State[State["RAWTEXT_LESS_THAN_SIGN"] = 11] = "RAWTEXT_LESS_THAN_SIGN";
+	State[State["RAWTEXT_END_TAG_OPEN"] = 12] = "RAWTEXT_END_TAG_OPEN";
+	State[State["RAWTEXT_END_TAG_NAME"] = 13] = "RAWTEXT_END_TAG_NAME";
+	State[State["SCRIPT_DATA_LESS_THAN_SIGN"] = 14] = "SCRIPT_DATA_LESS_THAN_SIGN";
+	State[State["SCRIPT_DATA_END_TAG_OPEN"] = 15] = "SCRIPT_DATA_END_TAG_OPEN";
+	State[State["SCRIPT_DATA_END_TAG_NAME"] = 16] = "SCRIPT_DATA_END_TAG_NAME";
+	State[State["SCRIPT_DATA_ESCAPE_START"] = 17] = "SCRIPT_DATA_ESCAPE_START";
+	State[State["SCRIPT_DATA_ESCAPE_START_DASH"] = 18] = "SCRIPT_DATA_ESCAPE_START_DASH";
+	State[State["SCRIPT_DATA_ESCAPED"] = 19] = "SCRIPT_DATA_ESCAPED";
+	State[State["SCRIPT_DATA_ESCAPED_DASH"] = 20] = "SCRIPT_DATA_ESCAPED_DASH";
+	State[State["SCRIPT_DATA_ESCAPED_DASH_DASH"] = 21] = "SCRIPT_DATA_ESCAPED_DASH_DASH";
+	State[State["SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN"] = 22] = "SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN";
+	State[State["SCRIPT_DATA_ESCAPED_END_TAG_OPEN"] = 23] = "SCRIPT_DATA_ESCAPED_END_TAG_OPEN";
+	State[State["SCRIPT_DATA_ESCAPED_END_TAG_NAME"] = 24] = "SCRIPT_DATA_ESCAPED_END_TAG_NAME";
+	State[State["SCRIPT_DATA_DOUBLE_ESCAPE_START"] = 25] = "SCRIPT_DATA_DOUBLE_ESCAPE_START";
+	State[State["SCRIPT_DATA_DOUBLE_ESCAPED"] = 26] = "SCRIPT_DATA_DOUBLE_ESCAPED";
+	State[State["SCRIPT_DATA_DOUBLE_ESCAPED_DASH"] = 27] = "SCRIPT_DATA_DOUBLE_ESCAPED_DASH";
+	State[State["SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH"] = 28] = "SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH";
+	State[State["SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN"] = 29] = "SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN";
+	State[State["SCRIPT_DATA_DOUBLE_ESCAPE_END"] = 30] = "SCRIPT_DATA_DOUBLE_ESCAPE_END";
+	State[State["BEFORE_ATTRIBUTE_NAME"] = 31] = "BEFORE_ATTRIBUTE_NAME";
+	State[State["ATTRIBUTE_NAME"] = 32] = "ATTRIBUTE_NAME";
+	State[State["AFTER_ATTRIBUTE_NAME"] = 33] = "AFTER_ATTRIBUTE_NAME";
+	State[State["BEFORE_ATTRIBUTE_VALUE"] = 34] = "BEFORE_ATTRIBUTE_VALUE";
+	State[State["ATTRIBUTE_VALUE_DOUBLE_QUOTED"] = 35] = "ATTRIBUTE_VALUE_DOUBLE_QUOTED";
+	State[State["ATTRIBUTE_VALUE_SINGLE_QUOTED"] = 36] = "ATTRIBUTE_VALUE_SINGLE_QUOTED";
+	State[State["ATTRIBUTE_VALUE_UNQUOTED"] = 37] = "ATTRIBUTE_VALUE_UNQUOTED";
+	State[State["AFTER_ATTRIBUTE_VALUE_QUOTED"] = 38] = "AFTER_ATTRIBUTE_VALUE_QUOTED";
+	State[State["SELF_CLOSING_START_TAG"] = 39] = "SELF_CLOSING_START_TAG";
+	State[State["BOGUS_COMMENT"] = 40] = "BOGUS_COMMENT";
+	State[State["MARKUP_DECLARATION_OPEN"] = 41] = "MARKUP_DECLARATION_OPEN";
+	State[State["COMMENT_START"] = 42] = "COMMENT_START";
+	State[State["COMMENT_START_DASH"] = 43] = "COMMENT_START_DASH";
+	State[State["COMMENT"] = 44] = "COMMENT";
+	State[State["COMMENT_LESS_THAN_SIGN"] = 45] = "COMMENT_LESS_THAN_SIGN";
+	State[State["COMMENT_LESS_THAN_SIGN_BANG"] = 46] = "COMMENT_LESS_THAN_SIGN_BANG";
+	State[State["COMMENT_LESS_THAN_SIGN_BANG_DASH"] = 47] = "COMMENT_LESS_THAN_SIGN_BANG_DASH";
+	State[State["COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH"] = 48] = "COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH";
+	State[State["COMMENT_END_DASH"] = 49] = "COMMENT_END_DASH";
+	State[State["COMMENT_END"] = 50] = "COMMENT_END";
+	State[State["COMMENT_END_BANG"] = 51] = "COMMENT_END_BANG";
+	State[State["DOCTYPE"] = 52] = "DOCTYPE";
+	State[State["BEFORE_DOCTYPE_NAME"] = 53] = "BEFORE_DOCTYPE_NAME";
+	State[State["DOCTYPE_NAME"] = 54] = "DOCTYPE_NAME";
+	State[State["AFTER_DOCTYPE_NAME"] = 55] = "AFTER_DOCTYPE_NAME";
+	State[State["AFTER_DOCTYPE_PUBLIC_KEYWORD"] = 56] = "AFTER_DOCTYPE_PUBLIC_KEYWORD";
+	State[State["BEFORE_DOCTYPE_PUBLIC_IDENTIFIER"] = 57] = "BEFORE_DOCTYPE_PUBLIC_IDENTIFIER";
+	State[State["DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED"] = 58] = "DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED";
+	State[State["DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED"] = 59] = "DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED";
+	State[State["AFTER_DOCTYPE_PUBLIC_IDENTIFIER"] = 60] = "AFTER_DOCTYPE_PUBLIC_IDENTIFIER";
+	State[State["BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS"] = 61] = "BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS";
+	State[State["AFTER_DOCTYPE_SYSTEM_KEYWORD"] = 62] = "AFTER_DOCTYPE_SYSTEM_KEYWORD";
+	State[State["BEFORE_DOCTYPE_SYSTEM_IDENTIFIER"] = 63] = "BEFORE_DOCTYPE_SYSTEM_IDENTIFIER";
+	State[State["DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED"] = 64] = "DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED";
+	State[State["DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED"] = 65] = "DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED";
+	State[State["AFTER_DOCTYPE_SYSTEM_IDENTIFIER"] = 66] = "AFTER_DOCTYPE_SYSTEM_IDENTIFIER";
+	State[State["BOGUS_DOCTYPE"] = 67] = "BOGUS_DOCTYPE";
+	State[State["CDATA_SECTION"] = 68] = "CDATA_SECTION";
+	State[State["CDATA_SECTION_BRACKET"] = 69] = "CDATA_SECTION_BRACKET";
+	State[State["CDATA_SECTION_END"] = 70] = "CDATA_SECTION_END";
+	State[State["CHARACTER_REFERENCE"] = 71] = "CHARACTER_REFERENCE";
+	State[State["AMBIGUOUS_AMPERSAND"] = 72] = "AMBIGUOUS_AMPERSAND";
+})(State || (State = {}));
+const TokenizerMode = {
+	DATA: State.DATA,
+	RCDATA: State.RCDATA,
+	RAWTEXT: State.RAWTEXT,
+	SCRIPT_DATA: State.SCRIPT_DATA,
+	PLAINTEXT: State.PLAINTEXT,
+	CDATA_SECTION: State.CDATA_SECTION
+};
+function isAsciiDigit(cp) {
+	return cp >= CODE_POINTS.DIGIT_0 && cp <= CODE_POINTS.DIGIT_9;
+}
+function isAsciiUpper(cp) {
+	return cp >= CODE_POINTS.LATIN_CAPITAL_A && cp <= CODE_POINTS.LATIN_CAPITAL_Z;
+}
+function isAsciiLower(cp) {
+	return cp >= CODE_POINTS.LATIN_SMALL_A && cp <= CODE_POINTS.LATIN_SMALL_Z;
+}
+function isAsciiLetter(cp) {
+	return isAsciiLower(cp) || isAsciiUpper(cp);
+}
+function isAsciiAlphaNumeric(cp) {
+	return isAsciiLetter(cp) || isAsciiDigit(cp);
+}
+function toAsciiLower(cp) {
+	return cp + 32;
+}
+function isWhitespace(cp) {
+	return cp === CODE_POINTS.SPACE || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.TABULATION || cp === CODE_POINTS.FORM_FEED;
+}
+function isScriptDataDoubleEscapeSequenceEnd(cp) {
+	return isWhitespace(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN;
+}
+function getErrorForNumericCharacterReference(code) {
+	if (code === CODE_POINTS.NULL) return ERR.nullCharacterReference;
+	else if (code > 1114111) return ERR.characterReferenceOutsideUnicodeRange;
+	else if (isSurrogate(code)) return ERR.surrogateCharacterReference;
+	else if (isUndefinedCodePoint(code)) return ERR.noncharacterCharacterReference;
+	else if (isControlCodePoint(code) || code === CODE_POINTS.CARRIAGE_RETURN) return ERR.controlCharacterReference;
+	return null;
+}
+var Tokenizer = class {
+	constructor(options, handler) {
+		this.options = options;
+		this.handler = handler;
+		this.paused = false;
+		/** Ensures that the parsing loop isn't run multiple times at once. */
+		this.inLoop = false;
+		/**
+		* Indicates that the current adjusted node exists, is not an element in the HTML namespace,
+		* and that it is not an integration point for either MathML or HTML.
+		*
+		* @see {@link https://html.spec.whatwg.org/multipage/parsing.html#tree-construction}
+		*/
+		this.inForeignNode = false;
+		this.lastStartTagName = "";
+		this.active = false;
+		this.state = State.DATA;
+		this.returnState = State.DATA;
+		this.entityStartPos = 0;
+		this.consumedAfterSnapshot = -1;
+		this.currentCharacterToken = null;
+		this.currentToken = null;
+		this.currentAttr = {
+			name: "",
+			value: ""
+		};
+		this.preprocessor = new Preprocessor(handler);
+		this.currentLocation = this.getCurrentLocation(-1);
+		this.entityDecoder = new EntityDecoder(htmlDecodeTree, (cp, consumed) => {
+			this.preprocessor.pos = this.entityStartPos + consumed - 1;
+			this._flushCodePointConsumedAsCharacterReference(cp);
+		}, handler.onParseError ? {
+			missingSemicolonAfterCharacterReference: () => {
+				this._err(ERR.missingSemicolonAfterCharacterReference, 1);
+			},
+			absenceOfDigitsInNumericCharacterReference: (consumed) => {
+				this._err(ERR.absenceOfDigitsInNumericCharacterReference, this.entityStartPos - this.preprocessor.pos + consumed);
+			},
+			validateNumericCharacterReference: (code) => {
+				const error = getErrorForNumericCharacterReference(code);
+				if (error) this._err(error, 1);
+			}
+		} : void 0);
+	}
+	_err(code, cpOffset = 0) {
+		var _a, _b;
+		(_b = (_a = this.handler).onParseError) === null || _b === void 0 || _b.call(_a, this.preprocessor.getError(code, cpOffset));
+	}
+	getCurrentLocation(offset) {
+		if (!this.options.sourceCodeLocationInfo) return null;
+		return {
+			startLine: this.preprocessor.line,
+			startCol: this.preprocessor.col - offset,
+			startOffset: this.preprocessor.offset - offset,
+			endLine: -1,
+			endCol: -1,
+			endOffset: -1
+		};
+	}
+	_runParsingLoop() {
+		if (this.inLoop) return;
+		this.inLoop = true;
+		while (this.active && !this.paused) {
+			this.consumedAfterSnapshot = 0;
+			const cp = this._consume();
+			if (!this._ensureHibernation()) this._callState(cp);
+		}
+		this.inLoop = false;
+	}
+	pause() {
+		this.paused = true;
+	}
+	resume(writeCallback) {
+		if (!this.paused) throw new Error("Parser was already resumed");
+		this.paused = false;
+		if (this.inLoop) return;
+		this._runParsingLoop();
+		if (!this.paused) writeCallback === null || writeCallback === void 0 || writeCallback();
+	}
+	write(chunk, isLastChunk, writeCallback) {
+		this.active = true;
+		this.preprocessor.write(chunk, isLastChunk);
+		this._runParsingLoop();
+		if (!this.paused) writeCallback === null || writeCallback === void 0 || writeCallback();
+	}
+	insertHtmlAtCurrentPos(chunk) {
+		this.active = true;
+		this.preprocessor.insertHtmlAtCurrentPos(chunk);
+		this._runParsingLoop();
+	}
+	_ensureHibernation() {
+		if (this.preprocessor.endOfChunkHit) {
+			this.preprocessor.retreat(this.consumedAfterSnapshot);
+			this.consumedAfterSnapshot = 0;
+			this.active = false;
+			return true;
+		}
+		return false;
+	}
+	_consume() {
+		this.consumedAfterSnapshot++;
+		return this.preprocessor.advance();
+	}
+	_advanceBy(count) {
+		this.consumedAfterSnapshot += count;
+		for (let i = 0; i < count; i++) this.preprocessor.advance();
+	}
+	_consumeSequenceIfMatch(pattern, caseSensitive) {
+		if (this.preprocessor.startsWith(pattern, caseSensitive)) {
+			this._advanceBy(pattern.length - 1);
+			return true;
+		}
+		return false;
+	}
+	_createStartTagToken() {
+		this.currentToken = {
+			type: TokenType.START_TAG,
+			tagName: "",
+			tagID: TAG_ID.UNKNOWN,
+			selfClosing: false,
+			ackSelfClosing: false,
+			attrs: [],
+			location: this.getCurrentLocation(1)
+		};
+	}
+	_createEndTagToken() {
+		this.currentToken = {
+			type: TokenType.END_TAG,
+			tagName: "",
+			tagID: TAG_ID.UNKNOWN,
+			selfClosing: false,
+			ackSelfClosing: false,
+			attrs: [],
+			location: this.getCurrentLocation(2)
+		};
+	}
+	_createCommentToken(offset) {
+		this.currentToken = {
+			type: TokenType.COMMENT,
+			data: "",
+			location: this.getCurrentLocation(offset)
+		};
+	}
+	_createDoctypeToken(initialName) {
+		this.currentToken = {
+			type: TokenType.DOCTYPE,
+			name: initialName,
+			forceQuirks: false,
+			publicId: null,
+			systemId: null,
+			location: this.currentLocation
+		};
+	}
+	_createCharacterToken(type, chars) {
+		this.currentCharacterToken = {
+			type,
+			chars,
+			location: this.currentLocation
+		};
+	}
+	_createAttr(attrNameFirstCh) {
+		this.currentAttr = {
+			name: attrNameFirstCh,
+			value: ""
+		};
+		this.currentLocation = this.getCurrentLocation(0);
+	}
+	_leaveAttrName() {
+		var _a;
+		var _b;
+		const token = this.currentToken;
+		if (getTokenAttr(token, this.currentAttr.name) === null) {
+			token.attrs.push(this.currentAttr);
+			if (token.location && this.currentLocation) {
+				const attrLocations = (_a = (_b = token.location).attrs) !== null && _a !== void 0 ? _a : _b.attrs = Object.create(null);
+				attrLocations[this.currentAttr.name] = this.currentLocation;
+				this._leaveAttrValue();
+			}
+		} else this._err(ERR.duplicateAttribute);
+	}
+	_leaveAttrValue() {
+		if (this.currentLocation) {
+			this.currentLocation.endLine = this.preprocessor.line;
+			this.currentLocation.endCol = this.preprocessor.col;
+			this.currentLocation.endOffset = this.preprocessor.offset;
+		}
+	}
+	prepareToken(ct) {
+		this._emitCurrentCharacterToken(ct.location);
+		this.currentToken = null;
+		if (ct.location) {
+			ct.location.endLine = this.preprocessor.line;
+			ct.location.endCol = this.preprocessor.col + 1;
+			ct.location.endOffset = this.preprocessor.offset + 1;
+		}
+		this.currentLocation = this.getCurrentLocation(-1);
+	}
+	emitCurrentTagToken() {
+		const ct = this.currentToken;
+		this.prepareToken(ct);
+		ct.tagID = getTagID(ct.tagName);
+		if (ct.type === TokenType.START_TAG) {
+			this.lastStartTagName = ct.tagName;
+			this.handler.onStartTag(ct);
+		} else {
+			if (ct.attrs.length > 0) this._err(ERR.endTagWithAttributes);
+			if (ct.selfClosing) this._err(ERR.endTagWithTrailingSolidus);
+			this.handler.onEndTag(ct);
+		}
+		this.preprocessor.dropParsedChunk();
+	}
+	emitCurrentComment(ct) {
+		this.prepareToken(ct);
+		this.handler.onComment(ct);
+		this.preprocessor.dropParsedChunk();
+	}
+	emitCurrentDoctype(ct) {
+		this.prepareToken(ct);
+		this.handler.onDoctype(ct);
+		this.preprocessor.dropParsedChunk();
+	}
+	_emitCurrentCharacterToken(nextLocation) {
+		if (this.currentCharacterToken) {
+			if (nextLocation && this.currentCharacterToken.location) {
+				this.currentCharacterToken.location.endLine = nextLocation.startLine;
+				this.currentCharacterToken.location.endCol = nextLocation.startCol;
+				this.currentCharacterToken.location.endOffset = nextLocation.startOffset;
+			}
+			switch (this.currentCharacterToken.type) {
+				case TokenType.CHARACTER:
+					this.handler.onCharacter(this.currentCharacterToken);
+					break;
+				case TokenType.NULL_CHARACTER:
+					this.handler.onNullCharacter(this.currentCharacterToken);
+					break;
+				case TokenType.WHITESPACE_CHARACTER:
+					this.handler.onWhitespaceCharacter(this.currentCharacterToken);
+					break;
+			}
+			this.currentCharacterToken = null;
+		}
+	}
+	_emitEOFToken() {
+		const location = this.getCurrentLocation(0);
+		if (location) {
+			location.endLine = location.startLine;
+			location.endCol = location.startCol;
+			location.endOffset = location.startOffset;
+		}
+		this._emitCurrentCharacterToken(location);
+		this.handler.onEof({
+			type: TokenType.EOF,
+			location
+		});
+		this.active = false;
+	}
+	_appendCharToCurrentCharacterToken(type, ch) {
+		if (this.currentCharacterToken) if (this.currentCharacterToken.type === type) {
+			this.currentCharacterToken.chars += ch;
+			return;
+		} else {
+			this.currentLocation = this.getCurrentLocation(0);
+			this._emitCurrentCharacterToken(this.currentLocation);
+			this.preprocessor.dropParsedChunk();
+		}
+		this._createCharacterToken(type, ch);
+	}
+	_emitCodePoint(cp) {
+		const type = isWhitespace(cp) ? TokenType.WHITESPACE_CHARACTER : cp === CODE_POINTS.NULL ? TokenType.NULL_CHARACTER : TokenType.CHARACTER;
+		this._appendCharToCurrentCharacterToken(type, cp < 65536 ? String.fromCharCode(cp) : String.fromCodePoint(cp));
+	}
+	_emitChars(ch) {
+		this._appendCharToCurrentCharacterToken(TokenType.CHARACTER, ch);
+	}
+	_startCharacterReference() {
+		this.returnState = this.state;
+		this.state = State.CHARACTER_REFERENCE;
+		this.entityStartPos = this.preprocessor.pos;
+		this.entityDecoder.startEntity(this._isCharacterReferenceInAttribute() ? DecodingMode.Attribute : DecodingMode.Legacy);
+	}
+	_isCharacterReferenceInAttribute() {
+		return this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED || this.returnState === State.ATTRIBUTE_VALUE_SINGLE_QUOTED || this.returnState === State.ATTRIBUTE_VALUE_UNQUOTED;
+	}
+	_flushCodePointConsumedAsCharacterReference(cp) {
+		if (this._isCharacterReferenceInAttribute()) this.currentAttr.value += String.fromCodePoint(cp);
+		else this._emitCodePoint(cp);
+	}
+	_callState(cp) {
+		switch (this.state) {
+			case State.DATA:
+				this._stateData(cp);
+				break;
+			case State.RCDATA:
+				this._stateRcdata(cp);
+				break;
+			case State.RAWTEXT:
+				this._stateRawtext(cp);
+				break;
+			case State.SCRIPT_DATA:
+				this._stateScriptData(cp);
+				break;
+			case State.PLAINTEXT:
+				this._statePlaintext(cp);
+				break;
+			case State.TAG_OPEN:
+				this._stateTagOpen(cp);
+				break;
+			case State.END_TAG_OPEN:
+				this._stateEndTagOpen(cp);
+				break;
+			case State.TAG_NAME:
+				this._stateTagName(cp);
+				break;
+			case State.RCDATA_LESS_THAN_SIGN:
+				this._stateRcdataLessThanSign(cp);
+				break;
+			case State.RCDATA_END_TAG_OPEN:
+				this._stateRcdataEndTagOpen(cp);
+				break;
+			case State.RCDATA_END_TAG_NAME:
+				this._stateRcdataEndTagName(cp);
+				break;
+			case State.RAWTEXT_LESS_THAN_SIGN:
+				this._stateRawtextLessThanSign(cp);
+				break;
+			case State.RAWTEXT_END_TAG_OPEN:
+				this._stateRawtextEndTagOpen(cp);
+				break;
+			case State.RAWTEXT_END_TAG_NAME:
+				this._stateRawtextEndTagName(cp);
+				break;
+			case State.SCRIPT_DATA_LESS_THAN_SIGN:
+				this._stateScriptDataLessThanSign(cp);
+				break;
+			case State.SCRIPT_DATA_END_TAG_OPEN:
+				this._stateScriptDataEndTagOpen(cp);
+				break;
+			case State.SCRIPT_DATA_END_TAG_NAME:
+				this._stateScriptDataEndTagName(cp);
+				break;
+			case State.SCRIPT_DATA_ESCAPE_START:
+				this._stateScriptDataEscapeStart(cp);
+				break;
+			case State.SCRIPT_DATA_ESCAPE_START_DASH:
+				this._stateScriptDataEscapeStartDash(cp);
+				break;
+			case State.SCRIPT_DATA_ESCAPED:
+				this._stateScriptDataEscaped(cp);
+				break;
+			case State.SCRIPT_DATA_ESCAPED_DASH:
+				this._stateScriptDataEscapedDash(cp);
+				break;
+			case State.SCRIPT_DATA_ESCAPED_DASH_DASH:
+				this._stateScriptDataEscapedDashDash(cp);
+				break;
+			case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN:
+				this._stateScriptDataEscapedLessThanSign(cp);
+				break;
+			case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN:
+				this._stateScriptDataEscapedEndTagOpen(cp);
+				break;
+			case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME:
+				this._stateScriptDataEscapedEndTagName(cp);
+				break;
+			case State.SCRIPT_DATA_DOUBLE_ESCAPE_START:
+				this._stateScriptDataDoubleEscapeStart(cp);
+				break;
+			case State.SCRIPT_DATA_DOUBLE_ESCAPED:
+				this._stateScriptDataDoubleEscaped(cp);
+				break;
+			case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH:
+				this._stateScriptDataDoubleEscapedDash(cp);
+				break;
+			case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH:
+				this._stateScriptDataDoubleEscapedDashDash(cp);
+				break;
+			case State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN:
+				this._stateScriptDataDoubleEscapedLessThanSign(cp);
+				break;
+			case State.SCRIPT_DATA_DOUBLE_ESCAPE_END:
+				this._stateScriptDataDoubleEscapeEnd(cp);
+				break;
+			case State.BEFORE_ATTRIBUTE_NAME:
+				this._stateBeforeAttributeName(cp);
+				break;
+			case State.ATTRIBUTE_NAME:
+				this._stateAttributeName(cp);
+				break;
+			case State.AFTER_ATTRIBUTE_NAME:
+				this._stateAfterAttributeName(cp);
+				break;
+			case State.BEFORE_ATTRIBUTE_VALUE:
+				this._stateBeforeAttributeValue(cp);
+				break;
+			case State.ATTRIBUTE_VALUE_DOUBLE_QUOTED:
+				this._stateAttributeValueDoubleQuoted(cp);
+				break;
+			case State.ATTRIBUTE_VALUE_SINGLE_QUOTED:
+				this._stateAttributeValueSingleQuoted(cp);
+				break;
+			case State.ATTRIBUTE_VALUE_UNQUOTED:
+				this._stateAttributeValueUnquoted(cp);
+				break;
+			case State.AFTER_ATTRIBUTE_VALUE_QUOTED:
+				this._stateAfterAttributeValueQuoted(cp);
+				break;
+			case State.SELF_CLOSING_START_TAG:
+				this._stateSelfClosingStartTag(cp);
+				break;
+			case State.BOGUS_COMMENT:
+				this._stateBogusComment(cp);
+				break;
+			case State.MARKUP_DECLARATION_OPEN:
+				this._stateMarkupDeclarationOpen(cp);
+				break;
+			case State.COMMENT_START:
+				this._stateCommentStart(cp);
+				break;
+			case State.COMMENT_START_DASH:
+				this._stateCommentStartDash(cp);
+				break;
+			case State.COMMENT:
+				this._stateComment(cp);
+				break;
+			case State.COMMENT_LESS_THAN_SIGN:
+				this._stateCommentLessThanSign(cp);
+				break;
+			case State.COMMENT_LESS_THAN_SIGN_BANG:
+				this._stateCommentLessThanSignBang(cp);
+				break;
+			case State.COMMENT_LESS_THAN_SIGN_BANG_DASH:
+				this._stateCommentLessThanSignBangDash(cp);
+				break;
+			case State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH:
+				this._stateCommentLessThanSignBangDashDash(cp);
+				break;
+			case State.COMMENT_END_DASH:
+				this._stateCommentEndDash(cp);
+				break;
+			case State.COMMENT_END:
+				this._stateCommentEnd(cp);
+				break;
+			case State.COMMENT_END_BANG:
+				this._stateCommentEndBang(cp);
+				break;
+			case State.DOCTYPE:
+				this._stateDoctype(cp);
+				break;
+			case State.BEFORE_DOCTYPE_NAME:
+				this._stateBeforeDoctypeName(cp);
+				break;
+			case State.DOCTYPE_NAME:
+				this._stateDoctypeName(cp);
+				break;
+			case State.AFTER_DOCTYPE_NAME:
+				this._stateAfterDoctypeName(cp);
+				break;
+			case State.AFTER_DOCTYPE_PUBLIC_KEYWORD:
+				this._stateAfterDoctypePublicKeyword(cp);
+				break;
+			case State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER:
+				this._stateBeforeDoctypePublicIdentifier(cp);
+				break;
+			case State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED:
+				this._stateDoctypePublicIdentifierDoubleQuoted(cp);
+				break;
+			case State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED:
+				this._stateDoctypePublicIdentifierSingleQuoted(cp);
+				break;
+			case State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER:
+				this._stateAfterDoctypePublicIdentifier(cp);
+				break;
+			case State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS:
+				this._stateBetweenDoctypePublicAndSystemIdentifiers(cp);
+				break;
+			case State.AFTER_DOCTYPE_SYSTEM_KEYWORD:
+				this._stateAfterDoctypeSystemKeyword(cp);
+				break;
+			case State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER:
+				this._stateBeforeDoctypeSystemIdentifier(cp);
+				break;
+			case State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED:
+				this._stateDoctypeSystemIdentifierDoubleQuoted(cp);
+				break;
+			case State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED:
+				this._stateDoctypeSystemIdentifierSingleQuoted(cp);
+				break;
+			case State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER:
+				this._stateAfterDoctypeSystemIdentifier(cp);
+				break;
+			case State.BOGUS_DOCTYPE:
+				this._stateBogusDoctype(cp);
+				break;
+			case State.CDATA_SECTION:
+				this._stateCdataSection(cp);
+				break;
+			case State.CDATA_SECTION_BRACKET:
+				this._stateCdataSectionBracket(cp);
+				break;
+			case State.CDATA_SECTION_END:
+				this._stateCdataSectionEnd(cp);
+				break;
+			case State.CHARACTER_REFERENCE:
+				this._stateCharacterReference();
+				break;
+			case State.AMBIGUOUS_AMPERSAND:
+				this._stateAmbiguousAmpersand(cp);
+				break;
+			default: throw new Error("Unknown state");
+		}
+	}
+	_stateData(cp) {
+		switch (cp) {
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.TAG_OPEN;
+				break;
+			case CODE_POINTS.AMPERSAND:
+				this._startCharacterReference();
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this._emitCodePoint(cp);
+				break;
+			case CODE_POINTS.EOF:
+				this._emitEOFToken();
+				break;
+			default: this._emitCodePoint(cp);
+		}
+	}
+	_stateRcdata(cp) {
+		switch (cp) {
+			case CODE_POINTS.AMPERSAND:
+				this._startCharacterReference();
+				break;
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.RCDATA_LESS_THAN_SIGN;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._emitEOFToken();
+				break;
+			default: this._emitCodePoint(cp);
+		}
+	}
+	_stateRawtext(cp) {
+		switch (cp) {
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.RAWTEXT_LESS_THAN_SIGN;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._emitEOFToken();
+				break;
+			default: this._emitCodePoint(cp);
+		}
+	}
+	_stateScriptData(cp) {
+		switch (cp) {
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.SCRIPT_DATA_LESS_THAN_SIGN;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._emitEOFToken();
+				break;
+			default: this._emitCodePoint(cp);
+		}
+	}
+	_statePlaintext(cp) {
+		switch (cp) {
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._emitEOFToken();
+				break;
+			default: this._emitCodePoint(cp);
+		}
+	}
+	_stateTagOpen(cp) {
+		if (isAsciiLetter(cp)) {
+			this._createStartTagToken();
+			this.state = State.TAG_NAME;
+			this._stateTagName(cp);
+		} else switch (cp) {
+			case CODE_POINTS.EXCLAMATION_MARK:
+				this.state = State.MARKUP_DECLARATION_OPEN;
+				break;
+			case CODE_POINTS.SOLIDUS:
+				this.state = State.END_TAG_OPEN;
+				break;
+			case CODE_POINTS.QUESTION_MARK:
+				this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);
+				this._createCommentToken(1);
+				this.state = State.BOGUS_COMMENT;
+				this._stateBogusComment(cp);
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofBeforeTagName);
+				this._emitChars("<");
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.invalidFirstCharacterOfTagName);
+				this._emitChars("<");
+				this.state = State.DATA;
+				this._stateData(cp);
+		}
+	}
+	_stateEndTagOpen(cp) {
+		if (isAsciiLetter(cp)) {
+			this._createEndTagToken();
+			this.state = State.TAG_NAME;
+			this._stateTagName(cp);
+		} else switch (cp) {
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.missingEndTagName);
+				this.state = State.DATA;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofBeforeTagName);
+				this._emitChars("</");
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.invalidFirstCharacterOfTagName);
+				this._createCommentToken(2);
+				this.state = State.BOGUS_COMMENT;
+				this._stateBogusComment(cp);
+		}
+	}
+	_stateTagName(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+				this.state = State.BEFORE_ATTRIBUTE_NAME;
+				break;
+			case CODE_POINTS.SOLIDUS:
+				this.state = State.SELF_CLOSING_START_TAG;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.DATA;
+				this.emitCurrentTagToken();
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				token.tagName += "�";
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInTag);
+				this._emitEOFToken();
+				break;
+			default: token.tagName += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
+		}
+	}
+	_stateRcdataLessThanSign(cp) {
+		if (cp === CODE_POINTS.SOLIDUS) this.state = State.RCDATA_END_TAG_OPEN;
+		else {
+			this._emitChars("<");
+			this.state = State.RCDATA;
+			this._stateRcdata(cp);
+		}
+	}
+	_stateRcdataEndTagOpen(cp) {
+		if (isAsciiLetter(cp)) {
+			this.state = State.RCDATA_END_TAG_NAME;
+			this._stateRcdataEndTagName(cp);
+		} else {
+			this._emitChars("</");
+			this.state = State.RCDATA;
+			this._stateRcdata(cp);
+		}
+	}
+	handleSpecialEndTag(_cp) {
+		if (!this.preprocessor.startsWith(this.lastStartTagName, false)) return !this._ensureHibernation();
+		this._createEndTagToken();
+		const token = this.currentToken;
+		token.tagName = this.lastStartTagName;
+		switch (this.preprocessor.peek(this.lastStartTagName.length)) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+				this._advanceBy(this.lastStartTagName.length);
+				this.state = State.BEFORE_ATTRIBUTE_NAME;
+				return false;
+			case CODE_POINTS.SOLIDUS:
+				this._advanceBy(this.lastStartTagName.length);
+				this.state = State.SELF_CLOSING_START_TAG;
+				return false;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._advanceBy(this.lastStartTagName.length);
+				this.emitCurrentTagToken();
+				this.state = State.DATA;
+				return false;
+			default: return !this._ensureHibernation();
+		}
+	}
+	_stateRcdataEndTagName(cp) {
+		if (this.handleSpecialEndTag(cp)) {
+			this._emitChars("</");
+			this.state = State.RCDATA;
+			this._stateRcdata(cp);
+		}
+	}
+	_stateRawtextLessThanSign(cp) {
+		if (cp === CODE_POINTS.SOLIDUS) this.state = State.RAWTEXT_END_TAG_OPEN;
+		else {
+			this._emitChars("<");
+			this.state = State.RAWTEXT;
+			this._stateRawtext(cp);
+		}
+	}
+	_stateRawtextEndTagOpen(cp) {
+		if (isAsciiLetter(cp)) {
+			this.state = State.RAWTEXT_END_TAG_NAME;
+			this._stateRawtextEndTagName(cp);
+		} else {
+			this._emitChars("</");
+			this.state = State.RAWTEXT;
+			this._stateRawtext(cp);
+		}
+	}
+	_stateRawtextEndTagName(cp) {
+		if (this.handleSpecialEndTag(cp)) {
+			this._emitChars("</");
+			this.state = State.RAWTEXT;
+			this._stateRawtext(cp);
+		}
+	}
+	_stateScriptDataLessThanSign(cp) {
+		switch (cp) {
+			case CODE_POINTS.SOLIDUS:
+				this.state = State.SCRIPT_DATA_END_TAG_OPEN;
+				break;
+			case CODE_POINTS.EXCLAMATION_MARK:
+				this.state = State.SCRIPT_DATA_ESCAPE_START;
+				this._emitChars("<!");
+				break;
+			default:
+				this._emitChars("<");
+				this.state = State.SCRIPT_DATA;
+				this._stateScriptData(cp);
+		}
+	}
+	_stateScriptDataEndTagOpen(cp) {
+		if (isAsciiLetter(cp)) {
+			this.state = State.SCRIPT_DATA_END_TAG_NAME;
+			this._stateScriptDataEndTagName(cp);
+		} else {
+			this._emitChars("</");
+			this.state = State.SCRIPT_DATA;
+			this._stateScriptData(cp);
+		}
+	}
+	_stateScriptDataEndTagName(cp) {
+		if (this.handleSpecialEndTag(cp)) {
+			this._emitChars("</");
+			this.state = State.SCRIPT_DATA;
+			this._stateScriptData(cp);
+		}
+	}
+	_stateScriptDataEscapeStart(cp) {
+		if (cp === CODE_POINTS.HYPHEN_MINUS) {
+			this.state = State.SCRIPT_DATA_ESCAPE_START_DASH;
+			this._emitChars("-");
+		} else {
+			this.state = State.SCRIPT_DATA;
+			this._stateScriptData(cp);
+		}
+	}
+	_stateScriptDataEscapeStartDash(cp) {
+		if (cp === CODE_POINTS.HYPHEN_MINUS) {
+			this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;
+			this._emitChars("-");
+		} else {
+			this.state = State.SCRIPT_DATA;
+			this._stateScriptData(cp);
+		}
+	}
+	_stateScriptDataEscaped(cp) {
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this.state = State.SCRIPT_DATA_ESCAPED_DASH;
+				this._emitChars("-");
+				break;
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInScriptHtmlCommentLikeText);
+				this._emitEOFToken();
+				break;
+			default: this._emitCodePoint(cp);
+		}
+	}
+	_stateScriptDataEscapedDash(cp) {
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;
+				this._emitChars("-");
+				break;
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this.state = State.SCRIPT_DATA_ESCAPED;
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInScriptHtmlCommentLikeText);
+				this._emitEOFToken();
+				break;
+			default:
+				this.state = State.SCRIPT_DATA_ESCAPED;
+				this._emitCodePoint(cp);
+		}
+	}
+	_stateScriptDataEscapedDashDash(cp) {
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this._emitChars("-");
+				break;
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.SCRIPT_DATA;
+				this._emitChars(">");
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this.state = State.SCRIPT_DATA_ESCAPED;
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInScriptHtmlCommentLikeText);
+				this._emitEOFToken();
+				break;
+			default:
+				this.state = State.SCRIPT_DATA_ESCAPED;
+				this._emitCodePoint(cp);
+		}
+	}
+	_stateScriptDataEscapedLessThanSign(cp) {
+		if (cp === CODE_POINTS.SOLIDUS) this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN;
+		else if (isAsciiLetter(cp)) {
+			this._emitChars("<");
+			this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_START;
+			this._stateScriptDataDoubleEscapeStart(cp);
+		} else {
+			this._emitChars("<");
+			this.state = State.SCRIPT_DATA_ESCAPED;
+			this._stateScriptDataEscaped(cp);
+		}
+	}
+	_stateScriptDataEscapedEndTagOpen(cp) {
+		if (isAsciiLetter(cp)) {
+			this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_NAME;
+			this._stateScriptDataEscapedEndTagName(cp);
+		} else {
+			this._emitChars("</");
+			this.state = State.SCRIPT_DATA_ESCAPED;
+			this._stateScriptDataEscaped(cp);
+		}
+	}
+	_stateScriptDataEscapedEndTagName(cp) {
+		if (this.handleSpecialEndTag(cp)) {
+			this._emitChars("</");
+			this.state = State.SCRIPT_DATA_ESCAPED;
+			this._stateScriptDataEscaped(cp);
+		}
+	}
+	_stateScriptDataDoubleEscapeStart(cp) {
+		if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) && isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) {
+			this._emitCodePoint(cp);
+			for (let i = 0; i < SEQUENCES.SCRIPT.length; i++) this._emitCodePoint(this._consume());
+			this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+		} else if (!this._ensureHibernation()) {
+			this.state = State.SCRIPT_DATA_ESCAPED;
+			this._stateScriptDataEscaped(cp);
+		}
+	}
+	_stateScriptDataDoubleEscaped(cp) {
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH;
+				this._emitChars("-");
+				break;
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
+				this._emitChars("<");
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInScriptHtmlCommentLikeText);
+				this._emitEOFToken();
+				break;
+			default: this._emitCodePoint(cp);
+		}
+	}
+	_stateScriptDataDoubleEscapedDash(cp) {
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;
+				this._emitChars("-");
+				break;
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
+				this._emitChars("<");
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInScriptHtmlCommentLikeText);
+				this._emitEOFToken();
+				break;
+			default:
+				this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+				this._emitCodePoint(cp);
+		}
+	}
+	_stateScriptDataDoubleEscapedDashDash(cp) {
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this._emitChars("-");
+				break;
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
+				this._emitChars("<");
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.SCRIPT_DATA;
+				this._emitChars(">");
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+				this._emitChars("�");
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInScriptHtmlCommentLikeText);
+				this._emitEOFToken();
+				break;
+			default:
+				this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+				this._emitCodePoint(cp);
+		}
+	}
+	_stateScriptDataDoubleEscapedLessThanSign(cp) {
+		if (cp === CODE_POINTS.SOLIDUS) {
+			this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_END;
+			this._emitChars("/");
+		} else {
+			this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+			this._stateScriptDataDoubleEscaped(cp);
+		}
+	}
+	_stateScriptDataDoubleEscapeEnd(cp) {
+		if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) && isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) {
+			this._emitCodePoint(cp);
+			for (let i = 0; i < SEQUENCES.SCRIPT.length; i++) this._emitCodePoint(this._consume());
+			this.state = State.SCRIPT_DATA_ESCAPED;
+		} else if (!this._ensureHibernation()) {
+			this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+			this._stateScriptDataDoubleEscaped(cp);
+		}
+	}
+	_stateBeforeAttributeName(cp) {
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED: break;
+			case CODE_POINTS.SOLIDUS:
+			case CODE_POINTS.GREATER_THAN_SIGN:
+			case CODE_POINTS.EOF:
+				this.state = State.AFTER_ATTRIBUTE_NAME;
+				this._stateAfterAttributeName(cp);
+				break;
+			case CODE_POINTS.EQUALS_SIGN:
+				this._err(ERR.unexpectedEqualsSignBeforeAttributeName);
+				this._createAttr("=");
+				this.state = State.ATTRIBUTE_NAME;
+				break;
+			default:
+				this._createAttr("");
+				this.state = State.ATTRIBUTE_NAME;
+				this._stateAttributeName(cp);
+		}
+	}
+	_stateAttributeName(cp) {
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+			case CODE_POINTS.SOLIDUS:
+			case CODE_POINTS.GREATER_THAN_SIGN:
+			case CODE_POINTS.EOF:
+				this._leaveAttrName();
+				this.state = State.AFTER_ATTRIBUTE_NAME;
+				this._stateAfterAttributeName(cp);
+				break;
+			case CODE_POINTS.EQUALS_SIGN:
+				this._leaveAttrName();
+				this.state = State.BEFORE_ATTRIBUTE_VALUE;
+				break;
+			case CODE_POINTS.QUOTATION_MARK:
+			case CODE_POINTS.APOSTROPHE:
+			case CODE_POINTS.LESS_THAN_SIGN:
+				this._err(ERR.unexpectedCharacterInAttributeName);
+				this.currentAttr.name += String.fromCodePoint(cp);
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this.currentAttr.name += "�";
+				break;
+			default: this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
+		}
+	}
+	_stateAfterAttributeName(cp) {
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED: break;
+			case CODE_POINTS.SOLIDUS:
+				this.state = State.SELF_CLOSING_START_TAG;
+				break;
+			case CODE_POINTS.EQUALS_SIGN:
+				this.state = State.BEFORE_ATTRIBUTE_VALUE;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.DATA;
+				this.emitCurrentTagToken();
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInTag);
+				this._emitEOFToken();
+				break;
+			default:
+				this._createAttr("");
+				this.state = State.ATTRIBUTE_NAME;
+				this._stateAttributeName(cp);
+		}
+	}
+	_stateBeforeAttributeValue(cp) {
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED: break;
+			case CODE_POINTS.QUOTATION_MARK:
+				this.state = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;
+				break;
+			case CODE_POINTS.APOSTROPHE:
+				this.state = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.missingAttributeValue);
+				this.state = State.DATA;
+				this.emitCurrentTagToken();
+				break;
+			default:
+				this.state = State.ATTRIBUTE_VALUE_UNQUOTED;
+				this._stateAttributeValueUnquoted(cp);
+		}
+	}
+	_stateAttributeValueDoubleQuoted(cp) {
+		switch (cp) {
+			case CODE_POINTS.QUOTATION_MARK:
+				this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;
+				break;
+			case CODE_POINTS.AMPERSAND:
+				this._startCharacterReference();
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this.currentAttr.value += "�";
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInTag);
+				this._emitEOFToken();
+				break;
+			default: this.currentAttr.value += String.fromCodePoint(cp);
+		}
+	}
+	_stateAttributeValueSingleQuoted(cp) {
+		switch (cp) {
+			case CODE_POINTS.APOSTROPHE:
+				this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;
+				break;
+			case CODE_POINTS.AMPERSAND:
+				this._startCharacterReference();
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this.currentAttr.value += "�";
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInTag);
+				this._emitEOFToken();
+				break;
+			default: this.currentAttr.value += String.fromCodePoint(cp);
+		}
+	}
+	_stateAttributeValueUnquoted(cp) {
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+				this._leaveAttrValue();
+				this.state = State.BEFORE_ATTRIBUTE_NAME;
+				break;
+			case CODE_POINTS.AMPERSAND:
+				this._startCharacterReference();
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._leaveAttrValue();
+				this.state = State.DATA;
+				this.emitCurrentTagToken();
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this.currentAttr.value += "�";
+				break;
+			case CODE_POINTS.QUOTATION_MARK:
+			case CODE_POINTS.APOSTROPHE:
+			case CODE_POINTS.LESS_THAN_SIGN:
+			case CODE_POINTS.EQUALS_SIGN:
+			case CODE_POINTS.GRAVE_ACCENT:
+				this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);
+				this.currentAttr.value += String.fromCodePoint(cp);
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInTag);
+				this._emitEOFToken();
+				break;
+			default: this.currentAttr.value += String.fromCodePoint(cp);
+		}
+	}
+	_stateAfterAttributeValueQuoted(cp) {
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+				this._leaveAttrValue();
+				this.state = State.BEFORE_ATTRIBUTE_NAME;
+				break;
+			case CODE_POINTS.SOLIDUS:
+				this._leaveAttrValue();
+				this.state = State.SELF_CLOSING_START_TAG;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._leaveAttrValue();
+				this.state = State.DATA;
+				this.emitCurrentTagToken();
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInTag);
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.missingWhitespaceBetweenAttributes);
+				this.state = State.BEFORE_ATTRIBUTE_NAME;
+				this._stateBeforeAttributeName(cp);
+		}
+	}
+	_stateSelfClosingStartTag(cp) {
+		switch (cp) {
+			case CODE_POINTS.GREATER_THAN_SIGN: {
+				const token = this.currentToken;
+				token.selfClosing = true;
+				this.state = State.DATA;
+				this.emitCurrentTagToken();
+				break;
+			}
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInTag);
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.unexpectedSolidusInTag);
+				this.state = State.BEFORE_ATTRIBUTE_NAME;
+				this._stateBeforeAttributeName(cp);
+		}
+	}
+	_stateBogusComment(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.DATA;
+				this.emitCurrentComment(token);
+				break;
+			case CODE_POINTS.EOF:
+				this.emitCurrentComment(token);
+				this._emitEOFToken();
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				token.data += "�";
+				break;
+			default: token.data += String.fromCodePoint(cp);
+		}
+	}
+	_stateMarkupDeclarationOpen(cp) {
+		if (this._consumeSequenceIfMatch(SEQUENCES.DASH_DASH, true)) {
+			this._createCommentToken(SEQUENCES.DASH_DASH.length + 1);
+			this.state = State.COMMENT_START;
+		} else if (this._consumeSequenceIfMatch(SEQUENCES.DOCTYPE, false)) {
+			this.currentLocation = this.getCurrentLocation(SEQUENCES.DOCTYPE.length + 1);
+			this.state = State.DOCTYPE;
+		} else if (this._consumeSequenceIfMatch(SEQUENCES.CDATA_START, true)) if (this.inForeignNode) this.state = State.CDATA_SECTION;
+		else {
+			this._err(ERR.cdataInHtmlContent);
+			this._createCommentToken(SEQUENCES.CDATA_START.length + 1);
+			this.currentToken.data = "[CDATA[";
+			this.state = State.BOGUS_COMMENT;
+		}
+		else if (!this._ensureHibernation()) {
+			this._err(ERR.incorrectlyOpenedComment);
+			this._createCommentToken(2);
+			this.state = State.BOGUS_COMMENT;
+			this._stateBogusComment(cp);
+		}
+	}
+	_stateCommentStart(cp) {
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this.state = State.COMMENT_START_DASH;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN: {
+				this._err(ERR.abruptClosingOfEmptyComment);
+				this.state = State.DATA;
+				const token = this.currentToken;
+				this.emitCurrentComment(token);
+				break;
+			}
+			default:
+				this.state = State.COMMENT;
+				this._stateComment(cp);
+		}
+	}
+	_stateCommentStartDash(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this.state = State.COMMENT_END;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.abruptClosingOfEmptyComment);
+				this.state = State.DATA;
+				this.emitCurrentComment(token);
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInComment);
+				this.emitCurrentComment(token);
+				this._emitEOFToken();
+				break;
+			default:
+				token.data += "-";
+				this.state = State.COMMENT;
+				this._stateComment(cp);
+		}
+	}
+	_stateComment(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this.state = State.COMMENT_END_DASH;
+				break;
+			case CODE_POINTS.LESS_THAN_SIGN:
+				token.data += "<";
+				this.state = State.COMMENT_LESS_THAN_SIGN;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				token.data += "�";
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInComment);
+				this.emitCurrentComment(token);
+				this._emitEOFToken();
+				break;
+			default: token.data += String.fromCodePoint(cp);
+		}
+	}
+	_stateCommentLessThanSign(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.EXCLAMATION_MARK:
+				token.data += "!";
+				this.state = State.COMMENT_LESS_THAN_SIGN_BANG;
+				break;
+			case CODE_POINTS.LESS_THAN_SIGN:
+				token.data += "<";
+				break;
+			default:
+				this.state = State.COMMENT;
+				this._stateComment(cp);
+		}
+	}
+	_stateCommentLessThanSignBang(cp) {
+		if (cp === CODE_POINTS.HYPHEN_MINUS) this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH;
+		else {
+			this.state = State.COMMENT;
+			this._stateComment(cp);
+		}
+	}
+	_stateCommentLessThanSignBangDash(cp) {
+		if (cp === CODE_POINTS.HYPHEN_MINUS) this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH;
+		else {
+			this.state = State.COMMENT_END_DASH;
+			this._stateCommentEndDash(cp);
+		}
+	}
+	_stateCommentLessThanSignBangDashDash(cp) {
+		if (cp !== CODE_POINTS.GREATER_THAN_SIGN && cp !== CODE_POINTS.EOF) this._err(ERR.nestedComment);
+		this.state = State.COMMENT_END;
+		this._stateCommentEnd(cp);
+	}
+	_stateCommentEndDash(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				this.state = State.COMMENT_END;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInComment);
+				this.emitCurrentComment(token);
+				this._emitEOFToken();
+				break;
+			default:
+				token.data += "-";
+				this.state = State.COMMENT;
+				this._stateComment(cp);
+		}
+	}
+	_stateCommentEnd(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.DATA;
+				this.emitCurrentComment(token);
+				break;
+			case CODE_POINTS.EXCLAMATION_MARK:
+				this.state = State.COMMENT_END_BANG;
+				break;
+			case CODE_POINTS.HYPHEN_MINUS:
+				token.data += "-";
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInComment);
+				this.emitCurrentComment(token);
+				this._emitEOFToken();
+				break;
+			default:
+				token.data += "--";
+				this.state = State.COMMENT;
+				this._stateComment(cp);
+		}
+	}
+	_stateCommentEndBang(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.HYPHEN_MINUS:
+				token.data += "--!";
+				this.state = State.COMMENT_END_DASH;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.incorrectlyClosedComment);
+				this.state = State.DATA;
+				this.emitCurrentComment(token);
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInComment);
+				this.emitCurrentComment(token);
+				this._emitEOFToken();
+				break;
+			default:
+				token.data += "--!";
+				this.state = State.COMMENT;
+				this._stateComment(cp);
+		}
+	}
+	_stateDoctype(cp) {
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+				this.state = State.BEFORE_DOCTYPE_NAME;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.BEFORE_DOCTYPE_NAME;
+				this._stateBeforeDoctypeName(cp);
+				break;
+			case CODE_POINTS.EOF: {
+				this._err(ERR.eofInDoctype);
+				this._createDoctypeToken(null);
+				const token = this.currentToken;
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			}
+			default:
+				this._err(ERR.missingWhitespaceBeforeDoctypeName);
+				this.state = State.BEFORE_DOCTYPE_NAME;
+				this._stateBeforeDoctypeName(cp);
+		}
+	}
+	_stateBeforeDoctypeName(cp) {
+		if (isAsciiUpper(cp)) {
+			this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp)));
+			this.state = State.DOCTYPE_NAME;
+		} else switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED: break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				this._createDoctypeToken("�");
+				this.state = State.DOCTYPE_NAME;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN: {
+				this._err(ERR.missingDoctypeName);
+				this._createDoctypeToken(null);
+				const token = this.currentToken;
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this.state = State.DATA;
+				break;
+			}
+			case CODE_POINTS.EOF: {
+				this._err(ERR.eofInDoctype);
+				this._createDoctypeToken(null);
+				const token = this.currentToken;
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			}
+			default:
+				this._createDoctypeToken(String.fromCodePoint(cp));
+				this.state = State.DOCTYPE_NAME;
+		}
+	}
+	_stateDoctypeName(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+				this.state = State.AFTER_DOCTYPE_NAME;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.DATA;
+				this.emitCurrentDoctype(token);
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				token.name += "�";
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default: token.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
+		}
+	}
+	_stateAfterDoctypeName(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED: break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.DATA;
+				this.emitCurrentDoctype(token);
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default: if (this._consumeSequenceIfMatch(SEQUENCES.PUBLIC, false)) this.state = State.AFTER_DOCTYPE_PUBLIC_KEYWORD;
+			else if (this._consumeSequenceIfMatch(SEQUENCES.SYSTEM, false)) this.state = State.AFTER_DOCTYPE_SYSTEM_KEYWORD;
+			else if (!this._ensureHibernation()) {
+				this._err(ERR.invalidCharacterSequenceAfterDoctypeName);
+				token.forceQuirks = true;
+				this.state = State.BOGUS_DOCTYPE;
+				this._stateBogusDoctype(cp);
+			}
+		}
+	}
+	_stateAfterDoctypePublicKeyword(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+				this.state = State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER;
+				break;
+			case CODE_POINTS.QUOTATION_MARK:
+				this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
+				token.publicId = "";
+				this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
+				break;
+			case CODE_POINTS.APOSTROPHE:
+				this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
+				token.publicId = "";
+				this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.missingDoctypePublicIdentifier);
+				token.forceQuirks = true;
+				this.state = State.DATA;
+				this.emitCurrentDoctype(token);
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
+				token.forceQuirks = true;
+				this.state = State.BOGUS_DOCTYPE;
+				this._stateBogusDoctype(cp);
+		}
+	}
+	_stateBeforeDoctypePublicIdentifier(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED: break;
+			case CODE_POINTS.QUOTATION_MARK:
+				token.publicId = "";
+				this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
+				break;
+			case CODE_POINTS.APOSTROPHE:
+				token.publicId = "";
+				this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.missingDoctypePublicIdentifier);
+				token.forceQuirks = true;
+				this.state = State.DATA;
+				this.emitCurrentDoctype(token);
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
+				token.forceQuirks = true;
+				this.state = State.BOGUS_DOCTYPE;
+				this._stateBogusDoctype(cp);
+		}
+	}
+	_stateDoctypePublicIdentifierDoubleQuoted(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.QUOTATION_MARK:
+				this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				token.publicId += "�";
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.abruptDoctypePublicIdentifier);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this.state = State.DATA;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default: token.publicId += String.fromCodePoint(cp);
+		}
+	}
+	_stateDoctypePublicIdentifierSingleQuoted(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.APOSTROPHE:
+				this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				token.publicId += "�";
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.abruptDoctypePublicIdentifier);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this.state = State.DATA;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default: token.publicId += String.fromCodePoint(cp);
+		}
+	}
+	_stateAfterDoctypePublicIdentifier(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+				this.state = State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.DATA;
+				this.emitCurrentDoctype(token);
+				break;
+			case CODE_POINTS.QUOTATION_MARK:
+				this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
+				token.systemId = "";
+				this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
+				break;
+			case CODE_POINTS.APOSTROPHE:
+				this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
+				token.systemId = "";
+				this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+				token.forceQuirks = true;
+				this.state = State.BOGUS_DOCTYPE;
+				this._stateBogusDoctype(cp);
+		}
+	}
+	_stateBetweenDoctypePublicAndSystemIdentifiers(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED: break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.emitCurrentDoctype(token);
+				this.state = State.DATA;
+				break;
+			case CODE_POINTS.QUOTATION_MARK:
+				token.systemId = "";
+				this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
+				break;
+			case CODE_POINTS.APOSTROPHE:
+				token.systemId = "";
+				this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+				token.forceQuirks = true;
+				this.state = State.BOGUS_DOCTYPE;
+				this._stateBogusDoctype(cp);
+		}
+	}
+	_stateAfterDoctypeSystemKeyword(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED:
+				this.state = State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER;
+				break;
+			case CODE_POINTS.QUOTATION_MARK:
+				this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
+				token.systemId = "";
+				this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
+				break;
+			case CODE_POINTS.APOSTROPHE:
+				this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
+				token.systemId = "";
+				this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.missingDoctypeSystemIdentifier);
+				token.forceQuirks = true;
+				this.state = State.DATA;
+				this.emitCurrentDoctype(token);
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+				token.forceQuirks = true;
+				this.state = State.BOGUS_DOCTYPE;
+				this._stateBogusDoctype(cp);
+		}
+	}
+	_stateBeforeDoctypeSystemIdentifier(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED: break;
+			case CODE_POINTS.QUOTATION_MARK:
+				token.systemId = "";
+				this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
+				break;
+			case CODE_POINTS.APOSTROPHE:
+				token.systemId = "";
+				this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.missingDoctypeSystemIdentifier);
+				token.forceQuirks = true;
+				this.state = State.DATA;
+				this.emitCurrentDoctype(token);
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+				token.forceQuirks = true;
+				this.state = State.BOGUS_DOCTYPE;
+				this._stateBogusDoctype(cp);
+		}
+	}
+	_stateDoctypeSystemIdentifierDoubleQuoted(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.QUOTATION_MARK:
+				this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				token.systemId += "�";
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.abruptDoctypeSystemIdentifier);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this.state = State.DATA;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default: token.systemId += String.fromCodePoint(cp);
+		}
+	}
+	_stateDoctypeSystemIdentifierSingleQuoted(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.APOSTROPHE:
+				this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				token.systemId += "�";
+				break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this._err(ERR.abruptDoctypeSystemIdentifier);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this.state = State.DATA;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default: token.systemId += String.fromCodePoint(cp);
+		}
+	}
+	_stateAfterDoctypeSystemIdentifier(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.SPACE:
+			case CODE_POINTS.LINE_FEED:
+			case CODE_POINTS.TABULATION:
+			case CODE_POINTS.FORM_FEED: break;
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.emitCurrentDoctype(token);
+				this.state = State.DATA;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInDoctype);
+				token.forceQuirks = true;
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default:
+				this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);
+				this.state = State.BOGUS_DOCTYPE;
+				this._stateBogusDoctype(cp);
+		}
+	}
+	_stateBogusDoctype(cp) {
+		const token = this.currentToken;
+		switch (cp) {
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.emitCurrentDoctype(token);
+				this.state = State.DATA;
+				break;
+			case CODE_POINTS.NULL:
+				this._err(ERR.unexpectedNullCharacter);
+				break;
+			case CODE_POINTS.EOF:
+				this.emitCurrentDoctype(token);
+				this._emitEOFToken();
+				break;
+			default:
+		}
+	}
+	_stateCdataSection(cp) {
+		switch (cp) {
+			case CODE_POINTS.RIGHT_SQUARE_BRACKET:
+				this.state = State.CDATA_SECTION_BRACKET;
+				break;
+			case CODE_POINTS.EOF:
+				this._err(ERR.eofInCdata);
+				this._emitEOFToken();
+				break;
+			default: this._emitCodePoint(cp);
+		}
+	}
+	_stateCdataSectionBracket(cp) {
+		if (cp === CODE_POINTS.RIGHT_SQUARE_BRACKET) this.state = State.CDATA_SECTION_END;
+		else {
+			this._emitChars("]");
+			this.state = State.CDATA_SECTION;
+			this._stateCdataSection(cp);
+		}
+	}
+	_stateCdataSectionEnd(cp) {
+		switch (cp) {
+			case CODE_POINTS.GREATER_THAN_SIGN:
+				this.state = State.DATA;
+				break;
+			case CODE_POINTS.RIGHT_SQUARE_BRACKET:
+				this._emitChars("]");
+				break;
+			default:
+				this._emitChars("]]");
+				this.state = State.CDATA_SECTION;
+				this._stateCdataSection(cp);
+		}
+	}
+	_stateCharacterReference() {
+		let length = this.entityDecoder.write(this.preprocessor.html, this.preprocessor.pos);
+		if (length < 0) if (this.preprocessor.lastChunkWritten) length = this.entityDecoder.end();
+		else {
+			this.active = false;
+			this.preprocessor.pos = this.preprocessor.html.length - 1;
+			this.consumedAfterSnapshot = 0;
+			this.preprocessor.endOfChunkHit = true;
+			return;
+		}
+		if (length === 0) {
+			this.preprocessor.pos = this.entityStartPos;
+			this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND);
+			this.state = !this._isCharacterReferenceInAttribute() && isAsciiAlphaNumeric(this.preprocessor.peek(1)) ? State.AMBIGUOUS_AMPERSAND : this.returnState;
+		} else this.state = this.returnState;
+	}
+	_stateAmbiguousAmpersand(cp) {
+		if (isAsciiAlphaNumeric(cp)) this._flushCodePointConsumedAsCharacterReference(cp);
+		else {
+			if (cp === CODE_POINTS.SEMICOLON) this._err(ERR.unknownNamedCharacterReference);
+			this.state = this.returnState;
+			this._callState(cp);
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/parser/open-element-stack.js
+const IMPLICIT_END_TAG_REQUIRED = new Set([
+	TAG_ID.DD,
+	TAG_ID.DT,
+	TAG_ID.LI,
+	TAG_ID.OPTGROUP,
+	TAG_ID.OPTION,
+	TAG_ID.P,
+	TAG_ID.RB,
+	TAG_ID.RP,
+	TAG_ID.RT,
+	TAG_ID.RTC
+]);
+const IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([
+	...IMPLICIT_END_TAG_REQUIRED,
+	TAG_ID.CAPTION,
+	TAG_ID.COLGROUP,
+	TAG_ID.TBODY,
+	TAG_ID.TD,
+	TAG_ID.TFOOT,
+	TAG_ID.TH,
+	TAG_ID.THEAD,
+	TAG_ID.TR
+]);
+const SCOPING_ELEMENTS_HTML = new Set([
+	TAG_ID.APPLET,
+	TAG_ID.CAPTION,
+	TAG_ID.HTML,
+	TAG_ID.MARQUEE,
+	TAG_ID.OBJECT,
+	TAG_ID.TABLE,
+	TAG_ID.TD,
+	TAG_ID.TEMPLATE,
+	TAG_ID.TH
+]);
+const SCOPING_ELEMENTS_HTML_LIST = new Set([
+	...SCOPING_ELEMENTS_HTML,
+	TAG_ID.OL,
+	TAG_ID.UL
+]);
+const SCOPING_ELEMENTS_HTML_BUTTON = new Set([...SCOPING_ELEMENTS_HTML, TAG_ID.BUTTON]);
+const SCOPING_ELEMENTS_MATHML = new Set([
+	TAG_ID.ANNOTATION_XML,
+	TAG_ID.MI,
+	TAG_ID.MN,
+	TAG_ID.MO,
+	TAG_ID.MS,
+	TAG_ID.MTEXT
+]);
+const SCOPING_ELEMENTS_SVG = new Set([
+	TAG_ID.DESC,
+	TAG_ID.FOREIGN_OBJECT,
+	TAG_ID.TITLE
+]);
+const TABLE_ROW_CONTEXT = new Set([
+	TAG_ID.TR,
+	TAG_ID.TEMPLATE,
+	TAG_ID.HTML
+]);
+const TABLE_BODY_CONTEXT = new Set([
+	TAG_ID.TBODY,
+	TAG_ID.TFOOT,
+	TAG_ID.THEAD,
+	TAG_ID.TEMPLATE,
+	TAG_ID.HTML
+]);
+const TABLE_CONTEXT = new Set([
+	TAG_ID.TABLE,
+	TAG_ID.TEMPLATE,
+	TAG_ID.HTML
+]);
+const TABLE_CELLS = new Set([TAG_ID.TD, TAG_ID.TH]);
+var OpenElementStack = class {
+	get currentTmplContentOrNode() {
+		return this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : this.current;
+	}
+	constructor(document, treeAdapter, handler) {
+		this.treeAdapter = treeAdapter;
+		this.handler = handler;
+		this.items = [];
+		this.tagIDs = [];
+		this.stackTop = -1;
+		this.tmplCount = 0;
+		this.currentTagId = TAG_ID.UNKNOWN;
+		this.current = document;
+	}
+	_indexOf(element) {
+		return this.items.lastIndexOf(element, this.stackTop);
+	}
+	_isInTemplate() {
+		return this.currentTagId === TAG_ID.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML;
+	}
+	_updateCurrentElement() {
+		this.current = this.items[this.stackTop];
+		this.currentTagId = this.tagIDs[this.stackTop];
+	}
+	push(element, tagID) {
+		this.stackTop++;
+		this.items[this.stackTop] = element;
+		this.current = element;
+		this.tagIDs[this.stackTop] = tagID;
+		this.currentTagId = tagID;
+		if (this._isInTemplate()) this.tmplCount++;
+		this.handler.onItemPush(element, tagID, true);
+	}
+	pop() {
+		const popped = this.current;
+		if (this.tmplCount > 0 && this._isInTemplate()) this.tmplCount--;
+		this.stackTop--;
+		this._updateCurrentElement();
+		this.handler.onItemPop(popped, true);
+	}
+	replace(oldElement, newElement) {
+		const idx = this._indexOf(oldElement);
+		this.items[idx] = newElement;
+		if (idx === this.stackTop) this.current = newElement;
+	}
+	insertAfter(referenceElement, newElement, newElementID) {
+		const insertionIdx = this._indexOf(referenceElement) + 1;
+		this.items.splice(insertionIdx, 0, newElement);
+		this.tagIDs.splice(insertionIdx, 0, newElementID);
+		this.stackTop++;
+		if (insertionIdx === this.stackTop) this._updateCurrentElement();
+		if (this.current && this.currentTagId !== void 0) this.handler.onItemPush(this.current, this.currentTagId, insertionIdx === this.stackTop);
+	}
+	popUntilTagNamePopped(tagName) {
+		let targetIdx = this.stackTop + 1;
+		do
+			targetIdx = this.tagIDs.lastIndexOf(tagName, targetIdx - 1);
+		while (targetIdx > 0 && this.treeAdapter.getNamespaceURI(this.items[targetIdx]) !== NS.HTML);
+		this.shortenToLength(Math.max(targetIdx, 0));
+	}
+	shortenToLength(idx) {
+		while (this.stackTop >= idx) {
+			const popped = this.current;
+			if (this.tmplCount > 0 && this._isInTemplate()) this.tmplCount -= 1;
+			this.stackTop--;
+			this._updateCurrentElement();
+			this.handler.onItemPop(popped, this.stackTop < idx);
+		}
+	}
+	popUntilElementPopped(element) {
+		const idx = this._indexOf(element);
+		this.shortenToLength(Math.max(idx, 0));
+	}
+	popUntilPopped(tagNames, targetNS) {
+		const idx = this._indexOfTagNames(tagNames, targetNS);
+		this.shortenToLength(Math.max(idx, 0));
+	}
+	popUntilNumberedHeaderPopped() {
+		this.popUntilPopped(NUMBERED_HEADERS, NS.HTML);
+	}
+	popUntilTableCellPopped() {
+		this.popUntilPopped(TABLE_CELLS, NS.HTML);
+	}
+	popAllUpToHtmlElement() {
+		this.tmplCount = 0;
+		this.shortenToLength(1);
+	}
+	_indexOfTagNames(tagNames, namespace) {
+		for (let i = this.stackTop; i >= 0; i--) if (tagNames.has(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) return i;
+		return -1;
+	}
+	clearBackTo(tagNames, targetNS) {
+		const idx = this._indexOfTagNames(tagNames, targetNS);
+		this.shortenToLength(idx + 1);
+	}
+	clearBackToTableContext() {
+		this.clearBackTo(TABLE_CONTEXT, NS.HTML);
+	}
+	clearBackToTableBodyContext() {
+		this.clearBackTo(TABLE_BODY_CONTEXT, NS.HTML);
+	}
+	clearBackToTableRowContext() {
+		this.clearBackTo(TABLE_ROW_CONTEXT, NS.HTML);
+	}
+	remove(element) {
+		const idx = this._indexOf(element);
+		if (idx >= 0) if (idx === this.stackTop) this.pop();
+		else {
+			this.items.splice(idx, 1);
+			this.tagIDs.splice(idx, 1);
+			this.stackTop--;
+			this._updateCurrentElement();
+			this.handler.onItemPop(element, false);
+		}
+	}
+	tryPeekProperlyNestedBodyElement() {
+		return this.stackTop >= 1 && this.tagIDs[1] === TAG_ID.BODY ? this.items[1] : null;
+	}
+	contains(element) {
+		return this._indexOf(element) > -1;
+	}
+	getCommonAncestor(element) {
+		const elementIdx = this._indexOf(element) - 1;
+		return elementIdx >= 0 ? this.items[elementIdx] : null;
+	}
+	isRootHtmlElementCurrent() {
+		return this.stackTop === 0 && this.tagIDs[0] === TAG_ID.HTML;
+	}
+	hasInDynamicScope(tagName, htmlScope) {
+		for (let i = this.stackTop; i >= 0; i--) {
+			const tn = this.tagIDs[i];
+			switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
+				case NS.HTML:
+					if (tn === tagName) return true;
+					if (htmlScope.has(tn)) return false;
+					break;
+				case NS.SVG:
+					if (SCOPING_ELEMENTS_SVG.has(tn)) return false;
+					break;
+				case NS.MATHML:
+					if (SCOPING_ELEMENTS_MATHML.has(tn)) return false;
+					break;
+			}
+		}
+		return true;
+	}
+	hasInScope(tagName) {
+		return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML);
+	}
+	hasInListItemScope(tagName) {
+		return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML_LIST);
+	}
+	hasInButtonScope(tagName) {
+		return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML_BUTTON);
+	}
+	hasNumberedHeaderInScope() {
+		for (let i = this.stackTop; i >= 0; i--) {
+			const tn = this.tagIDs[i];
+			switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
+				case NS.HTML:
+					if (NUMBERED_HEADERS.has(tn)) return true;
+					if (SCOPING_ELEMENTS_HTML.has(tn)) return false;
+					break;
+				case NS.SVG:
+					if (SCOPING_ELEMENTS_SVG.has(tn)) return false;
+					break;
+				case NS.MATHML:
+					if (SCOPING_ELEMENTS_MATHML.has(tn)) return false;
+					break;
+			}
+		}
+		return true;
+	}
+	hasInTableScope(tagName) {
+		for (let i = this.stackTop; i >= 0; i--) {
+			if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) continue;
+			switch (this.tagIDs[i]) {
+				case tagName: return true;
+				case TAG_ID.TABLE:
+				case TAG_ID.HTML: return false;
+			}
+		}
+		return true;
+	}
+	hasTableBodyContextInTableScope() {
+		for (let i = this.stackTop; i >= 0; i--) {
+			if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) continue;
+			switch (this.tagIDs[i]) {
+				case TAG_ID.TBODY:
+				case TAG_ID.THEAD:
+				case TAG_ID.TFOOT: return true;
+				case TAG_ID.TABLE:
+				case TAG_ID.HTML: return false;
+			}
+		}
+		return true;
+	}
+	hasInSelectScope(tagName) {
+		for (let i = this.stackTop; i >= 0; i--) {
+			if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) continue;
+			switch (this.tagIDs[i]) {
+				case tagName: return true;
+				case TAG_ID.OPTION:
+				case TAG_ID.OPTGROUP: break;
+				default: return false;
+			}
+		}
+		return true;
+	}
+	generateImpliedEndTags() {
+		while (this.currentTagId !== void 0 && IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId)) this.pop();
+	}
+	generateImpliedEndTagsThoroughly() {
+		while (this.currentTagId !== void 0 && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) this.pop();
+	}
+	generateImpliedEndTagsWithExclusion(exclusionId) {
+		while (this.currentTagId !== void 0 && this.currentTagId !== exclusionId && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) this.pop();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/parser/formatting-element-list.js
+const NOAH_ARK_CAPACITY = 3;
+var EntryType;
+(function(EntryType) {
+	EntryType[EntryType["Marker"] = 0] = "Marker";
+	EntryType[EntryType["Element"] = 1] = "Element";
+})(EntryType || (EntryType = {}));
+const MARKER = { type: EntryType.Marker };
+var FormattingElementList = class {
+	constructor(treeAdapter) {
+		this.treeAdapter = treeAdapter;
+		this.entries = [];
+		this.bookmark = null;
+	}
+	_getNoahArkConditionCandidates(newElement, neAttrs) {
+		const candidates = [];
+		const neAttrsLength = neAttrs.length;
+		const neTagName = this.treeAdapter.getTagName(newElement);
+		const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);
+		for (let i = 0; i < this.entries.length; i++) {
+			const entry = this.entries[i];
+			if (entry.type === EntryType.Marker) break;
+			const { element } = entry;
+			if (this.treeAdapter.getTagName(element) === neTagName && this.treeAdapter.getNamespaceURI(element) === neNamespaceURI) {
+				const elementAttrs = this.treeAdapter.getAttrList(element);
+				if (elementAttrs.length === neAttrsLength) candidates.push({
+					idx: i,
+					attrs: elementAttrs
+				});
+			}
+		}
+		return candidates;
+	}
+	_ensureNoahArkCondition(newElement) {
+		if (this.entries.length < NOAH_ARK_CAPACITY) return;
+		const neAttrs = this.treeAdapter.getAttrList(newElement);
+		const candidates = this._getNoahArkConditionCandidates(newElement, neAttrs);
+		if (candidates.length < NOAH_ARK_CAPACITY) return;
+		const neAttrsMap = new Map(neAttrs.map((neAttr) => [neAttr.name, neAttr.value]));
+		let validCandidates = 0;
+		for (let i = 0; i < candidates.length; i++) {
+			const candidate = candidates[i];
+			if (candidate.attrs.every((cAttr) => neAttrsMap.get(cAttr.name) === cAttr.value)) {
+				validCandidates += 1;
+				if (validCandidates >= NOAH_ARK_CAPACITY) this.entries.splice(candidate.idx, 1);
+			}
+		}
+	}
+	insertMarker() {
+		this.entries.unshift(MARKER);
+	}
+	pushElement(element, token) {
+		this._ensureNoahArkCondition(element);
+		this.entries.unshift({
+			type: EntryType.Element,
+			element,
+			token
+		});
+	}
+	insertElementAfterBookmark(element, token) {
+		const bookmarkIdx = this.entries.indexOf(this.bookmark);
+		this.entries.splice(bookmarkIdx, 0, {
+			type: EntryType.Element,
+			element,
+			token
+		});
+	}
+	removeEntry(entry) {
+		const entryIndex = this.entries.indexOf(entry);
+		if (entryIndex !== -1) this.entries.splice(entryIndex, 1);
+	}
+	/**
+	* Clears the list of formatting elements up to the last marker.
+	*
+	* @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker
+	*/
+	clearToLastMarker() {
+		const markerIdx = this.entries.indexOf(MARKER);
+		if (markerIdx === -1) this.entries.length = 0;
+		else this.entries.splice(0, markerIdx + 1);
+	}
+	getElementEntryInScopeWithTagName(tagName) {
+		const entry = this.entries.find((entry) => entry.type === EntryType.Marker || this.treeAdapter.getTagName(entry.element) === tagName);
+		return entry && entry.type === EntryType.Element ? entry : null;
+	}
+	getElementEntry(element) {
+		return this.entries.find((entry) => entry.type === EntryType.Element && entry.element === element);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/tree-adapters/default.js
+const defaultTreeAdapter = {
+	createDocument() {
+		return {
+			nodeName: "#document",
+			mode: DOCUMENT_MODE.NO_QUIRKS,
+			childNodes: []
+		};
+	},
+	createDocumentFragment() {
+		return {
+			nodeName: "#document-fragment",
+			childNodes: []
+		};
+	},
+	createElement(tagName, namespaceURI, attrs) {
+		return {
+			nodeName: tagName,
+			tagName,
+			attrs,
+			namespaceURI,
+			childNodes: [],
+			parentNode: null
+		};
+	},
+	createCommentNode(data) {
+		return {
+			nodeName: "#comment",
+			data,
+			parentNode: null
+		};
+	},
+	createTextNode(value) {
+		return {
+			nodeName: "#text",
+			value,
+			parentNode: null
+		};
+	},
+	appendChild(parentNode, newNode) {
+		parentNode.childNodes.push(newNode);
+		newNode.parentNode = parentNode;
+	},
+	insertBefore(parentNode, newNode, referenceNode) {
+		const insertionIdx = parentNode.childNodes.indexOf(referenceNode);
+		parentNode.childNodes.splice(insertionIdx, 0, newNode);
+		newNode.parentNode = parentNode;
+	},
+	setTemplateContent(templateElement, contentElement) {
+		templateElement.content = contentElement;
+	},
+	getTemplateContent(templateElement) {
+		return templateElement.content;
+	},
+	setDocumentType(document, name, publicId, systemId) {
+		const doctypeNode = document.childNodes.find((node) => node.nodeName === "#documentType");
+		if (doctypeNode) {
+			doctypeNode.name = name;
+			doctypeNode.publicId = publicId;
+			doctypeNode.systemId = systemId;
+		} else defaultTreeAdapter.appendChild(document, {
+			nodeName: "#documentType",
+			name,
+			publicId,
+			systemId,
+			parentNode: null
+		});
+	},
+	setDocumentMode(document, mode) {
+		document.mode = mode;
+	},
+	getDocumentMode(document) {
+		return document.mode;
+	},
+	detachNode(node) {
+		if (node.parentNode) {
+			const idx = node.parentNode.childNodes.indexOf(node);
+			node.parentNode.childNodes.splice(idx, 1);
+			node.parentNode = null;
+		}
+	},
+	insertText(parentNode, text) {
+		if (parentNode.childNodes.length > 0) {
+			const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1];
+			if (defaultTreeAdapter.isTextNode(prevNode)) {
+				prevNode.value += text;
+				return;
+			}
+		}
+		defaultTreeAdapter.appendChild(parentNode, defaultTreeAdapter.createTextNode(text));
+	},
+	insertTextBefore(parentNode, text, referenceNode) {
+		const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];
+		if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) prevNode.value += text;
+		else defaultTreeAdapter.insertBefore(parentNode, defaultTreeAdapter.createTextNode(text), referenceNode);
+	},
+	adoptAttributes(recipient, attrs) {
+		const recipientAttrsMap = new Set(recipient.attrs.map((attr) => attr.name));
+		for (let j = 0; j < attrs.length; j++) if (!recipientAttrsMap.has(attrs[j].name)) recipient.attrs.push(attrs[j]);
+	},
+	getFirstChild(node) {
+		return node.childNodes[0];
+	},
+	getChildNodes(node) {
+		return node.childNodes;
+	},
+	getParentNode(node) {
+		return node.parentNode;
+	},
+	getAttrList(element) {
+		return element.attrs;
+	},
+	getTagName(element) {
+		return element.tagName;
+	},
+	getNamespaceURI(element) {
+		return element.namespaceURI;
+	},
+	getTextNodeContent(textNode) {
+		return textNode.value;
+	},
+	getCommentNodeContent(commentNode) {
+		return commentNode.data;
+	},
+	getDocumentTypeNodeName(doctypeNode) {
+		return doctypeNode.name;
+	},
+	getDocumentTypeNodePublicId(doctypeNode) {
+		return doctypeNode.publicId;
+	},
+	getDocumentTypeNodeSystemId(doctypeNode) {
+		return doctypeNode.systemId;
+	},
+	isTextNode(node) {
+		return node.nodeName === "#text";
+	},
+	isCommentNode(node) {
+		return node.nodeName === "#comment";
+	},
+	isDocumentTypeNode(node) {
+		return node.nodeName === "#documentType";
+	},
+	isElementNode(node) {
+		return Object.prototype.hasOwnProperty.call(node, "tagName");
+	},
+	setNodeSourceCodeLocation(node, location) {
+		node.sourceCodeLocation = location;
+	},
+	getNodeSourceCodeLocation(node) {
+		return node.sourceCodeLocation;
+	},
+	updateNodeSourceCodeLocation(node, endLocation) {
+		node.sourceCodeLocation = {
+			...node.sourceCodeLocation,
+			...endLocation
+		};
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/common/doctype.js
+const VALID_DOCTYPE_NAME = "html";
+const VALID_SYSTEM_ID = "about:legacy-compat";
+const QUIRKS_MODE_SYSTEM_ID = "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd";
+const QUIRKS_MODE_PUBLIC_ID_PREFIXES = [
+	"+//silmaril//dtd html pro v0r11 19970101//",
+	"-//as//dtd html 3.0 aswedit + extensions//",
+	"-//advasoft ltd//dtd html 3.0 aswedit + extensions//",
+	"-//ietf//dtd html 2.0 level 1//",
+	"-//ietf//dtd html 2.0 level 2//",
+	"-//ietf//dtd html 2.0 strict level 1//",
+	"-//ietf//dtd html 2.0 strict level 2//",
+	"-//ietf//dtd html 2.0 strict//",
+	"-//ietf//dtd html 2.0//",
+	"-//ietf//dtd html 2.1e//",
+	"-//ietf//dtd html 3.0//",
+	"-//ietf//dtd html 3.2 final//",
+	"-//ietf//dtd html 3.2//",
+	"-//ietf//dtd html 3//",
+	"-//ietf//dtd html level 0//",
+	"-//ietf//dtd html level 1//",
+	"-//ietf//dtd html level 2//",
+	"-//ietf//dtd html level 3//",
+	"-//ietf//dtd html strict level 0//",
+	"-//ietf//dtd html strict level 1//",
+	"-//ietf//dtd html strict level 2//",
+	"-//ietf//dtd html strict level 3//",
+	"-//ietf//dtd html strict//",
+	"-//ietf//dtd html//",
+	"-//metrius//dtd metrius presentational//",
+	"-//microsoft//dtd internet explorer 2.0 html strict//",
+	"-//microsoft//dtd internet explorer 2.0 html//",
+	"-//microsoft//dtd internet explorer 2.0 tables//",
+	"-//microsoft//dtd internet explorer 3.0 html strict//",
+	"-//microsoft//dtd internet explorer 3.0 html//",
+	"-//microsoft//dtd internet explorer 3.0 tables//",
+	"-//netscape comm. corp.//dtd html//",
+	"-//netscape comm. corp.//dtd strict html//",
+	"-//o'reilly and associates//dtd html 2.0//",
+	"-//o'reilly and associates//dtd html extended 1.0//",
+	"-//o'reilly and associates//dtd html extended relaxed 1.0//",
+	"-//sq//dtd html 2.0 hotmetal + extensions//",
+	"-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//",
+	"-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//",
+	"-//spyglass//dtd html 2.0 extended//",
+	"-//sun microsystems corp.//dtd hotjava html//",
+	"-//sun microsystems corp.//dtd hotjava strict html//",
+	"-//w3c//dtd html 3 1995-03-24//",
+	"-//w3c//dtd html 3.2 draft//",
+	"-//w3c//dtd html 3.2 final//",
+	"-//w3c//dtd html 3.2//",
+	"-//w3c//dtd html 3.2s draft//",
+	"-//w3c//dtd html 4.0 frameset//",
+	"-//w3c//dtd html 4.0 transitional//",
+	"-//w3c//dtd html experimental 19960712//",
+	"-//w3c//dtd html experimental 970421//",
+	"-//w3c//dtd w3 html//",
+	"-//w3o//dtd w3 html 3.0//",
+	"-//webtechs//dtd mozilla html 2.0//",
+	"-//webtechs//dtd mozilla html//"
+];
+const QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES = [
+	...QUIRKS_MODE_PUBLIC_ID_PREFIXES,
+	"-//w3c//dtd html 4.01 frameset//",
+	"-//w3c//dtd html 4.01 transitional//"
+];
+const QUIRKS_MODE_PUBLIC_IDS = new Set([
+	"-//w3o//dtd w3 html strict 3.0//en//",
+	"-/w3c/dtd html 4.0 transitional/en",
+	"html"
+]);
+const LIMITED_QUIRKS_PUBLIC_ID_PREFIXES = ["-//w3c//dtd xhtml 1.0 frameset//", "-//w3c//dtd xhtml 1.0 transitional//"];
+const LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES = [
+	...LIMITED_QUIRKS_PUBLIC_ID_PREFIXES,
+	"-//w3c//dtd html 4.01 frameset//",
+	"-//w3c//dtd html 4.01 transitional//"
+];
+function hasPrefix(publicId, prefixes) {
+	return prefixes.some((prefix) => publicId.startsWith(prefix));
+}
+function isConforming(token) {
+	return token.name === VALID_DOCTYPE_NAME && token.publicId === null && (token.systemId === null || token.systemId === VALID_SYSTEM_ID);
+}
+function getDocumentMode(token) {
+	if (token.name !== VALID_DOCTYPE_NAME) return DOCUMENT_MODE.QUIRKS;
+	const { systemId } = token;
+	if (systemId && systemId.toLowerCase() === QUIRKS_MODE_SYSTEM_ID) return DOCUMENT_MODE.QUIRKS;
+	let { publicId } = token;
+	if (publicId !== null) {
+		publicId = publicId.toLowerCase();
+		if (QUIRKS_MODE_PUBLIC_IDS.has(publicId)) return DOCUMENT_MODE.QUIRKS;
+		let prefixes = systemId === null ? QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES : QUIRKS_MODE_PUBLIC_ID_PREFIXES;
+		if (hasPrefix(publicId, prefixes)) return DOCUMENT_MODE.QUIRKS;
+		prefixes = systemId === null ? LIMITED_QUIRKS_PUBLIC_ID_PREFIXES : LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES;
+		if (hasPrefix(publicId, prefixes)) return DOCUMENT_MODE.LIMITED_QUIRKS;
+	}
+	return DOCUMENT_MODE.NO_QUIRKS;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/common/foreign-content.js
+const MIME_TYPES = {
+	TEXT_HTML: "text/html",
+	APPLICATION_XML: "application/xhtml+xml"
+};
+const DEFINITION_URL_ATTR = "definitionurl";
+const ADJUSTED_DEFINITION_URL_ATTR = "definitionURL";
+const SVG_ATTRS_ADJUSTMENT_MAP = new Map([
+	"attributeName",
+	"attributeType",
+	"baseFrequency",
+	"baseProfile",
+	"calcMode",
+	"clipPathUnits",
+	"diffuseConstant",
+	"edgeMode",
+	"filterUnits",
+	"glyphRef",
+	"gradientTransform",
+	"gradientUnits",
+	"kernelMatrix",
+	"kernelUnitLength",
+	"keyPoints",
+	"keySplines",
+	"keyTimes",
+	"lengthAdjust",
+	"limitingConeAngle",
+	"markerHeight",
+	"markerUnits",
+	"markerWidth",
+	"maskContentUnits",
+	"maskUnits",
+	"numOctaves",
+	"pathLength",
+	"patternContentUnits",
+	"patternTransform",
+	"patternUnits",
+	"pointsAtX",
+	"pointsAtY",
+	"pointsAtZ",
+	"preserveAlpha",
+	"preserveAspectRatio",
+	"primitiveUnits",
+	"refX",
+	"refY",
+	"repeatCount",
+	"repeatDur",
+	"requiredExtensions",
+	"requiredFeatures",
+	"specularConstant",
+	"specularExponent",
+	"spreadMethod",
+	"startOffset",
+	"stdDeviation",
+	"stitchTiles",
+	"surfaceScale",
+	"systemLanguage",
+	"tableValues",
+	"targetX",
+	"targetY",
+	"textLength",
+	"viewBox",
+	"viewTarget",
+	"xChannelSelector",
+	"yChannelSelector",
+	"zoomAndPan"
+].map((attr) => [attr.toLowerCase(), attr]));
+const XML_ATTRS_ADJUSTMENT_MAP = new Map([
+	["xlink:actuate", {
+		prefix: "xlink",
+		name: "actuate",
+		namespace: NS.XLINK
+	}],
+	["xlink:arcrole", {
+		prefix: "xlink",
+		name: "arcrole",
+		namespace: NS.XLINK
+	}],
+	["xlink:href", {
+		prefix: "xlink",
+		name: "href",
+		namespace: NS.XLINK
+	}],
+	["xlink:role", {
+		prefix: "xlink",
+		name: "role",
+		namespace: NS.XLINK
+	}],
+	["xlink:show", {
+		prefix: "xlink",
+		name: "show",
+		namespace: NS.XLINK
+	}],
+	["xlink:title", {
+		prefix: "xlink",
+		name: "title",
+		namespace: NS.XLINK
+	}],
+	["xlink:type", {
+		prefix: "xlink",
+		name: "type",
+		namespace: NS.XLINK
+	}],
+	["xml:lang", {
+		prefix: "xml",
+		name: "lang",
+		namespace: NS.XML
+	}],
+	["xml:space", {
+		prefix: "xml",
+		name: "space",
+		namespace: NS.XML
+	}],
+	["xmlns", {
+		prefix: "",
+		name: "xmlns",
+		namespace: NS.XMLNS
+	}],
+	["xmlns:xlink", {
+		prefix: "xmlns",
+		name: "xlink",
+		namespace: NS.XMLNS
+	}]
+]);
+const SVG_TAG_NAMES_ADJUSTMENT_MAP = new Map([
+	"altGlyph",
+	"altGlyphDef",
+	"altGlyphItem",
+	"animateColor",
+	"animateMotion",
+	"animateTransform",
+	"clipPath",
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDiffuseLighting",
+	"feDisplacementMap",
+	"feDistantLight",
+	"feFlood",
+	"feFuncA",
+	"feFuncB",
+	"feFuncG",
+	"feFuncR",
+	"feGaussianBlur",
+	"feImage",
+	"feMerge",
+	"feMergeNode",
+	"feMorphology",
+	"feOffset",
+	"fePointLight",
+	"feSpecularLighting",
+	"feSpotLight",
+	"feTile",
+	"feTurbulence",
+	"foreignObject",
+	"glyphRef",
+	"linearGradient",
+	"radialGradient",
+	"textPath"
+].map((tn) => [tn.toLowerCase(), tn]));
+const EXITS_FOREIGN_CONTENT = new Set([
+	TAG_ID.B,
+	TAG_ID.BIG,
+	TAG_ID.BLOCKQUOTE,
+	TAG_ID.BODY,
+	TAG_ID.BR,
+	TAG_ID.CENTER,
+	TAG_ID.CODE,
+	TAG_ID.DD,
+	TAG_ID.DIV,
+	TAG_ID.DL,
+	TAG_ID.DT,
+	TAG_ID.EM,
+	TAG_ID.EMBED,
+	TAG_ID.H1,
+	TAG_ID.H2,
+	TAG_ID.H3,
+	TAG_ID.H4,
+	TAG_ID.H5,
+	TAG_ID.H6,
+	TAG_ID.HEAD,
+	TAG_ID.HR,
+	TAG_ID.I,
+	TAG_ID.IMG,
+	TAG_ID.LI,
+	TAG_ID.LISTING,
+	TAG_ID.MENU,
+	TAG_ID.META,
+	TAG_ID.NOBR,
+	TAG_ID.OL,
+	TAG_ID.P,
+	TAG_ID.PRE,
+	TAG_ID.RUBY,
+	TAG_ID.S,
+	TAG_ID.SMALL,
+	TAG_ID.SPAN,
+	TAG_ID.STRONG,
+	TAG_ID.STRIKE,
+	TAG_ID.SUB,
+	TAG_ID.SUP,
+	TAG_ID.TABLE,
+	TAG_ID.TT,
+	TAG_ID.U,
+	TAG_ID.UL,
+	TAG_ID.VAR
+]);
+function causesExit(startTagToken) {
+	const tn = startTagToken.tagID;
+	return tn === TAG_ID.FONT && startTagToken.attrs.some(({ name }) => name === ATTRS.COLOR || name === ATTRS.SIZE || name === ATTRS.FACE) || EXITS_FOREIGN_CONTENT.has(tn);
+}
+function adjustTokenMathMLAttrs(token) {
+	for (let i = 0; i < token.attrs.length; i++) if (token.attrs[i].name === DEFINITION_URL_ATTR) {
+		token.attrs[i].name = ADJUSTED_DEFINITION_URL_ATTR;
+		break;
+	}
+}
+function adjustTokenSVGAttrs(token) {
+	for (let i = 0; i < token.attrs.length; i++) {
+		const adjustedAttrName = SVG_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name);
+		if (adjustedAttrName != null) token.attrs[i].name = adjustedAttrName;
+	}
+}
+function adjustTokenXMLAttrs(token) {
+	for (let i = 0; i < token.attrs.length; i++) {
+		const adjustedAttrEntry = XML_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name);
+		if (adjustedAttrEntry) {
+			token.attrs[i].prefix = adjustedAttrEntry.prefix;
+			token.attrs[i].name = adjustedAttrEntry.name;
+			token.attrs[i].namespace = adjustedAttrEntry.namespace;
+		}
+	}
+}
+function adjustTokenSVGTagName(token) {
+	const adjustedTagName = SVG_TAG_NAMES_ADJUSTMENT_MAP.get(token.tagName);
+	if (adjustedTagName != null) {
+		token.tagName = adjustedTagName;
+		token.tagID = getTagID(token.tagName);
+	}
+}
+function isMathMLTextIntegrationPoint(tn, ns) {
+	return ns === NS.MATHML && (tn === TAG_ID.MI || tn === TAG_ID.MO || tn === TAG_ID.MN || tn === TAG_ID.MS || tn === TAG_ID.MTEXT);
+}
+function isHtmlIntegrationPoint(tn, ns, attrs) {
+	if (ns === NS.MATHML && tn === TAG_ID.ANNOTATION_XML) {
+		for (let i = 0; i < attrs.length; i++) if (attrs[i].name === ATTRS.ENCODING) {
+			const value = attrs[i].value.toLowerCase();
+			return value === MIME_TYPES.TEXT_HTML || value === MIME_TYPES.APPLICATION_XML;
+		}
+	}
+	return ns === NS.SVG && (tn === TAG_ID.FOREIGN_OBJECT || tn === TAG_ID.DESC || tn === TAG_ID.TITLE);
+}
+function isIntegrationPoint(tn, ns, attrs, foreignNS) {
+	return (!foreignNS || foreignNS === NS.HTML) && isHtmlIntegrationPoint(tn, ns, attrs) || (!foreignNS || foreignNS === NS.MATHML) && isMathMLTextIntegrationPoint(tn, ns);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/parser/index.js
+const HIDDEN_INPUT_TYPE = "hidden";
+const AA_OUTER_LOOP_ITER = 8;
+const AA_INNER_LOOP_ITER = 3;
+var InsertionMode;
+(function(InsertionMode) {
+	InsertionMode[InsertionMode["INITIAL"] = 0] = "INITIAL";
+	InsertionMode[InsertionMode["BEFORE_HTML"] = 1] = "BEFORE_HTML";
+	InsertionMode[InsertionMode["BEFORE_HEAD"] = 2] = "BEFORE_HEAD";
+	InsertionMode[InsertionMode["IN_HEAD"] = 3] = "IN_HEAD";
+	InsertionMode[InsertionMode["IN_HEAD_NO_SCRIPT"] = 4] = "IN_HEAD_NO_SCRIPT";
+	InsertionMode[InsertionMode["AFTER_HEAD"] = 5] = "AFTER_HEAD";
+	InsertionMode[InsertionMode["IN_BODY"] = 6] = "IN_BODY";
+	InsertionMode[InsertionMode["TEXT"] = 7] = "TEXT";
+	InsertionMode[InsertionMode["IN_TABLE"] = 8] = "IN_TABLE";
+	InsertionMode[InsertionMode["IN_TABLE_TEXT"] = 9] = "IN_TABLE_TEXT";
+	InsertionMode[InsertionMode["IN_CAPTION"] = 10] = "IN_CAPTION";
+	InsertionMode[InsertionMode["IN_COLUMN_GROUP"] = 11] = "IN_COLUMN_GROUP";
+	InsertionMode[InsertionMode["IN_TABLE_BODY"] = 12] = "IN_TABLE_BODY";
+	InsertionMode[InsertionMode["IN_ROW"] = 13] = "IN_ROW";
+	InsertionMode[InsertionMode["IN_CELL"] = 14] = "IN_CELL";
+	InsertionMode[InsertionMode["IN_SELECT"] = 15] = "IN_SELECT";
+	InsertionMode[InsertionMode["IN_SELECT_IN_TABLE"] = 16] = "IN_SELECT_IN_TABLE";
+	InsertionMode[InsertionMode["IN_TEMPLATE"] = 17] = "IN_TEMPLATE";
+	InsertionMode[InsertionMode["AFTER_BODY"] = 18] = "AFTER_BODY";
+	InsertionMode[InsertionMode["IN_FRAMESET"] = 19] = "IN_FRAMESET";
+	InsertionMode[InsertionMode["AFTER_FRAMESET"] = 20] = "AFTER_FRAMESET";
+	InsertionMode[InsertionMode["AFTER_AFTER_BODY"] = 21] = "AFTER_AFTER_BODY";
+	InsertionMode[InsertionMode["AFTER_AFTER_FRAMESET"] = 22] = "AFTER_AFTER_FRAMESET";
+})(InsertionMode || (InsertionMode = {}));
+const BASE_LOC = {
+	startLine: -1,
+	startCol: -1,
+	startOffset: -1,
+	endLine: -1,
+	endCol: -1,
+	endOffset: -1
+};
+const TABLE_STRUCTURE_TAGS = new Set([
+	TAG_ID.TABLE,
+	TAG_ID.TBODY,
+	TAG_ID.TFOOT,
+	TAG_ID.THEAD,
+	TAG_ID.TR
+]);
+const defaultParserOptions = {
+	scriptingEnabled: true,
+	sourceCodeLocationInfo: false,
+	treeAdapter: defaultTreeAdapter,
+	onParseError: null
+};
+var Parser = class {
+	constructor(options, document, fragmentContext = null, scriptHandler = null) {
+		this.fragmentContext = fragmentContext;
+		this.scriptHandler = scriptHandler;
+		this.currentToken = null;
+		this.stopped = false;
+		/** @internal */
+		this.insertionMode = InsertionMode.INITIAL;
+		/** @internal */
+		this.originalInsertionMode = InsertionMode.INITIAL;
+		/** @internal */
+		this.headElement = null;
+		/** @internal */
+		this.formElement = null;
+		/** Indicates that the current node is not an element in the HTML namespace */
+		this.currentNotInHTML = false;
+		/**
+		* The template insertion mode stack is maintained from the left.
+		* Ie. the topmost element will always have index 0.
+		*
+		* @internal
+		*/
+		this.tmplInsertionModeStack = [];
+		/** @internal */
+		this.pendingCharacterTokens = [];
+		/** @internal */
+		this.hasNonWhitespacePendingCharacterToken = false;
+		/** @internal */
+		this.framesetOk = true;
+		/** @internal */
+		this.skipNextNewLine = false;
+		/** @internal */
+		this.fosterParentingEnabled = false;
+		this.options = {
+			...defaultParserOptions,
+			...options
+		};
+		this.treeAdapter = this.options.treeAdapter;
+		this.onParseError = this.options.onParseError;
+		if (this.onParseError) this.options.sourceCodeLocationInfo = true;
+		this.document = document !== null && document !== void 0 ? document : this.treeAdapter.createDocument();
+		this.tokenizer = new Tokenizer(this.options, this);
+		this.activeFormattingElements = new FormattingElementList(this.treeAdapter);
+		this.fragmentContextID = fragmentContext ? getTagID(this.treeAdapter.getTagName(fragmentContext)) : TAG_ID.UNKNOWN;
+		this._setContextModes(fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : this.document, this.fragmentContextID);
+		this.openElements = new OpenElementStack(this.document, this.treeAdapter, this);
+	}
+	static parse(html, options) {
+		const parser = new this(options);
+		parser.tokenizer.write(html, true);
+		return parser.document;
+	}
+	static getFragmentParser(fragmentContext, options) {
+		const opts = {
+			...defaultParserOptions,
+			...options
+		};
+		fragmentContext !== null && fragmentContext !== void 0 || (fragmentContext = opts.treeAdapter.createElement(TAG_NAMES.TEMPLATE, NS.HTML, []));
+		const documentMock = opts.treeAdapter.createElement("documentmock", NS.HTML, []);
+		const parser = new this(opts, documentMock, fragmentContext);
+		if (parser.fragmentContextID === TAG_ID.TEMPLATE) parser.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);
+		parser._initTokenizerForFragmentParsing();
+		parser._insertFakeRootElement();
+		parser._resetInsertionMode();
+		parser._findFormInFragmentContext();
+		return parser;
+	}
+	getFragment() {
+		const rootElement = this.treeAdapter.getFirstChild(this.document);
+		const fragment = this.treeAdapter.createDocumentFragment();
+		this._adoptNodes(rootElement, fragment);
+		return fragment;
+	}
+	/** @internal */
+	_err(token, code, beforeToken) {
+		var _a;
+		if (!this.onParseError) return;
+		const loc = (_a = token.location) !== null && _a !== void 0 ? _a : BASE_LOC;
+		const err = {
+			code,
+			startLine: loc.startLine,
+			startCol: loc.startCol,
+			startOffset: loc.startOffset,
+			endLine: beforeToken ? loc.startLine : loc.endLine,
+			endCol: beforeToken ? loc.startCol : loc.endCol,
+			endOffset: beforeToken ? loc.startOffset : loc.endOffset
+		};
+		this.onParseError(err);
+	}
+	/** @internal */
+	onItemPush(node, tid, isTop) {
+		var _a, _b;
+		(_b = (_a = this.treeAdapter).onItemPush) === null || _b === void 0 || _b.call(_a, node);
+		if (isTop && this.openElements.stackTop > 0) this._setContextModes(node, tid);
+	}
+	/** @internal */
+	onItemPop(node, isTop) {
+		var _a, _b;
+		if (this.options.sourceCodeLocationInfo) this._setEndLocation(node, this.currentToken);
+		(_b = (_a = this.treeAdapter).onItemPop) === null || _b === void 0 || _b.call(_a, node, this.openElements.current);
+		if (isTop) {
+			let current;
+			let currentTagId;
+			if (this.openElements.stackTop === 0 && this.fragmentContext) {
+				current = this.fragmentContext;
+				currentTagId = this.fragmentContextID;
+			} else ({current, currentTagId} = this.openElements);
+			this._setContextModes(current, currentTagId);
+		}
+	}
+	_setContextModes(current, tid) {
+		const isHTML = current === this.document || current && this.treeAdapter.getNamespaceURI(current) === NS.HTML;
+		this.currentNotInHTML = !isHTML;
+		this.tokenizer.inForeignNode = !isHTML && current !== void 0 && tid !== void 0 && !this._isIntegrationPoint(tid, current);
+	}
+	/** @protected */
+	_switchToTextParsing(currentToken, nextTokenizerState) {
+		this._insertElement(currentToken, NS.HTML);
+		this.tokenizer.state = nextTokenizerState;
+		this.originalInsertionMode = this.insertionMode;
+		this.insertionMode = InsertionMode.TEXT;
+	}
+	switchToPlaintextParsing() {
+		this.insertionMode = InsertionMode.TEXT;
+		this.originalInsertionMode = InsertionMode.IN_BODY;
+		this.tokenizer.state = TokenizerMode.PLAINTEXT;
+	}
+	/** @protected */
+	_getAdjustedCurrentElement() {
+		return this.openElements.stackTop === 0 && this.fragmentContext ? this.fragmentContext : this.openElements.current;
+	}
+	/** @protected */
+	_findFormInFragmentContext() {
+		let node = this.fragmentContext;
+		while (node) {
+			if (this.treeAdapter.getTagName(node) === TAG_NAMES.FORM) {
+				this.formElement = node;
+				break;
+			}
+			node = this.treeAdapter.getParentNode(node);
+		}
+	}
+	_initTokenizerForFragmentParsing() {
+		if (!this.fragmentContext || this.treeAdapter.getNamespaceURI(this.fragmentContext) !== NS.HTML) return;
+		switch (this.fragmentContextID) {
+			case TAG_ID.TITLE:
+			case TAG_ID.TEXTAREA:
+				this.tokenizer.state = TokenizerMode.RCDATA;
+				break;
+			case TAG_ID.STYLE:
+			case TAG_ID.XMP:
+			case TAG_ID.IFRAME:
+			case TAG_ID.NOEMBED:
+			case TAG_ID.NOFRAMES:
+			case TAG_ID.NOSCRIPT:
+				this.tokenizer.state = TokenizerMode.RAWTEXT;
+				break;
+			case TAG_ID.SCRIPT:
+				this.tokenizer.state = TokenizerMode.SCRIPT_DATA;
+				break;
+			case TAG_ID.PLAINTEXT:
+				this.tokenizer.state = TokenizerMode.PLAINTEXT;
+				break;
+			default:
+		}
+	}
+	/** @protected */
+	_setDocumentType(token) {
+		const name = token.name || "";
+		const publicId = token.publicId || "";
+		const systemId = token.systemId || "";
+		this.treeAdapter.setDocumentType(this.document, name, publicId, systemId);
+		if (token.location) {
+			const docTypeNode = this.treeAdapter.getChildNodes(this.document).find((node) => this.treeAdapter.isDocumentTypeNode(node));
+			if (docTypeNode) this.treeAdapter.setNodeSourceCodeLocation(docTypeNode, token.location);
+		}
+	}
+	/** @protected */
+	_attachElementToTree(element, location) {
+		if (this.options.sourceCodeLocationInfo) {
+			const loc = location && {
+				...location,
+				startTag: location
+			};
+			this.treeAdapter.setNodeSourceCodeLocation(element, loc);
+		}
+		if (this._shouldFosterParentOnInsertion()) this._fosterParentElement(element);
+		else {
+			const parent = this.openElements.currentTmplContentOrNode;
+			this.treeAdapter.appendChild(parent !== null && parent !== void 0 ? parent : this.document, element);
+		}
+	}
+	/**
+	* For self-closing tags. Add an element to the tree, but skip adding it
+	* to the stack.
+	*/
+	/** @protected */
+	_appendElement(token, namespaceURI) {
+		const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
+		this._attachElementToTree(element, token.location);
+	}
+	/** @protected */
+	_insertElement(token, namespaceURI) {
+		const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
+		this._attachElementToTree(element, token.location);
+		this.openElements.push(element, token.tagID);
+	}
+	/** @protected */
+	_insertFakeElement(tagName, tagID) {
+		const element = this.treeAdapter.createElement(tagName, NS.HTML, []);
+		this._attachElementToTree(element, null);
+		this.openElements.push(element, tagID);
+	}
+	/** @protected */
+	_insertTemplate(token) {
+		const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);
+		const content = this.treeAdapter.createDocumentFragment();
+		this.treeAdapter.setTemplateContent(tmpl, content);
+		this._attachElementToTree(tmpl, token.location);
+		this.openElements.push(tmpl, token.tagID);
+		if (this.options.sourceCodeLocationInfo) this.treeAdapter.setNodeSourceCodeLocation(content, null);
+	}
+	/** @protected */
+	_insertFakeRootElement() {
+		const element = this.treeAdapter.createElement(TAG_NAMES.HTML, NS.HTML, []);
+		if (this.options.sourceCodeLocationInfo) this.treeAdapter.setNodeSourceCodeLocation(element, null);
+		this.treeAdapter.appendChild(this.openElements.current, element);
+		this.openElements.push(element, TAG_ID.HTML);
+	}
+	/** @protected */
+	_appendCommentNode(token, parent) {
+		const commentNode = this.treeAdapter.createCommentNode(token.data);
+		this.treeAdapter.appendChild(parent, commentNode);
+		if (this.options.sourceCodeLocationInfo) this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);
+	}
+	/** @protected */
+	_insertCharacters(token) {
+		let parent;
+		let beforeElement;
+		if (this._shouldFosterParentOnInsertion()) {
+			({parent, beforeElement} = this._findFosterParentingLocation());
+			if (beforeElement) this.treeAdapter.insertTextBefore(parent, token.chars, beforeElement);
+			else this.treeAdapter.insertText(parent, token.chars);
+		} else {
+			parent = this.openElements.currentTmplContentOrNode;
+			this.treeAdapter.insertText(parent, token.chars);
+		}
+		if (!token.location) return;
+		const siblings = this.treeAdapter.getChildNodes(parent);
+		const textNode = siblings[(beforeElement ? siblings.lastIndexOf(beforeElement) : siblings.length) - 1];
+		if (this.treeAdapter.getNodeSourceCodeLocation(textNode)) {
+			const { endLine, endCol, endOffset } = token.location;
+			this.treeAdapter.updateNodeSourceCodeLocation(textNode, {
+				endLine,
+				endCol,
+				endOffset
+			});
+		} else if (this.options.sourceCodeLocationInfo) this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);
+	}
+	/** @protected */
+	_adoptNodes(donor, recipient) {
+		for (let child = this.treeAdapter.getFirstChild(donor); child; child = this.treeAdapter.getFirstChild(donor)) {
+			this.treeAdapter.detachNode(child);
+			this.treeAdapter.appendChild(recipient, child);
+		}
+	}
+	/** @protected */
+	_setEndLocation(element, closingToken) {
+		if (this.treeAdapter.getNodeSourceCodeLocation(element) && closingToken.location) {
+			const ctLoc = closingToken.location;
+			const tn = this.treeAdapter.getTagName(element);
+			const endLoc = closingToken.type === TokenType.END_TAG && tn === closingToken.tagName ? {
+				endTag: { ...ctLoc },
+				endLine: ctLoc.endLine,
+				endCol: ctLoc.endCol,
+				endOffset: ctLoc.endOffset
+			} : {
+				endLine: ctLoc.startLine,
+				endCol: ctLoc.startCol,
+				endOffset: ctLoc.startOffset
+			};
+			this.treeAdapter.updateNodeSourceCodeLocation(element, endLoc);
+		}
+	}
+	shouldProcessStartTagTokenInForeignContent(token) {
+		if (!this.currentNotInHTML) return false;
+		let current;
+		let currentTagId;
+		if (this.openElements.stackTop === 0 && this.fragmentContext) {
+			current = this.fragmentContext;
+			currentTagId = this.fragmentContextID;
+		} else ({current, currentTagId} = this.openElements);
+		if (token.tagID === TAG_ID.SVG && this.treeAdapter.getTagName(current) === TAG_NAMES.ANNOTATION_XML && this.treeAdapter.getNamespaceURI(current) === NS.MATHML) return false;
+		return this.tokenizer.inForeignNode || (token.tagID === TAG_ID.MGLYPH || token.tagID === TAG_ID.MALIGNMARK) && currentTagId !== void 0 && !this._isIntegrationPoint(currentTagId, current, NS.HTML);
+	}
+	/** @protected */
+	_processToken(token) {
+		switch (token.type) {
+			case TokenType.CHARACTER:
+				this.onCharacter(token);
+				break;
+			case TokenType.NULL_CHARACTER:
+				this.onNullCharacter(token);
+				break;
+			case TokenType.COMMENT:
+				this.onComment(token);
+				break;
+			case TokenType.DOCTYPE:
+				this.onDoctype(token);
+				break;
+			case TokenType.START_TAG:
+				this._processStartTag(token);
+				break;
+			case TokenType.END_TAG:
+				this.onEndTag(token);
+				break;
+			case TokenType.EOF:
+				this.onEof(token);
+				break;
+			case TokenType.WHITESPACE_CHARACTER:
+				this.onWhitespaceCharacter(token);
+				break;
+		}
+	}
+	/** @protected */
+	_isIntegrationPoint(tid, element, foreignNS) {
+		return isIntegrationPoint(tid, this.treeAdapter.getNamespaceURI(element), this.treeAdapter.getAttrList(element), foreignNS);
+	}
+	/** @protected */
+	_reconstructActiveFormattingElements() {
+		const listLength = this.activeFormattingElements.entries.length;
+		if (listLength) {
+			const endIndex = this.activeFormattingElements.entries.findIndex((entry) => entry.type === EntryType.Marker || this.openElements.contains(entry.element));
+			const unopenIdx = endIndex === -1 ? listLength - 1 : endIndex - 1;
+			for (let i = unopenIdx; i >= 0; i--) {
+				const entry = this.activeFormattingElements.entries[i];
+				this._insertElement(entry.token, this.treeAdapter.getNamespaceURI(entry.element));
+				entry.element = this.openElements.current;
+			}
+		}
+	}
+	/** @protected */
+	_closeTableCell() {
+		this.openElements.generateImpliedEndTags();
+		this.openElements.popUntilTableCellPopped();
+		this.activeFormattingElements.clearToLastMarker();
+		this.insertionMode = InsertionMode.IN_ROW;
+	}
+	/** @protected */
+	_closePElement() {
+		this.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.P);
+		this.openElements.popUntilTagNamePopped(TAG_ID.P);
+	}
+	/** @protected */
+	_resetInsertionMode() {
+		for (let i = this.openElements.stackTop; i >= 0; i--) switch (i === 0 && this.fragmentContext ? this.fragmentContextID : this.openElements.tagIDs[i]) {
+			case TAG_ID.TR:
+				this.insertionMode = InsertionMode.IN_ROW;
+				return;
+			case TAG_ID.TBODY:
+			case TAG_ID.THEAD:
+			case TAG_ID.TFOOT:
+				this.insertionMode = InsertionMode.IN_TABLE_BODY;
+				return;
+			case TAG_ID.CAPTION:
+				this.insertionMode = InsertionMode.IN_CAPTION;
+				return;
+			case TAG_ID.COLGROUP:
+				this.insertionMode = InsertionMode.IN_COLUMN_GROUP;
+				return;
+			case TAG_ID.TABLE:
+				this.insertionMode = InsertionMode.IN_TABLE;
+				return;
+			case TAG_ID.BODY:
+				this.insertionMode = InsertionMode.IN_BODY;
+				return;
+			case TAG_ID.FRAMESET:
+				this.insertionMode = InsertionMode.IN_FRAMESET;
+				return;
+			case TAG_ID.SELECT:
+				this._resetInsertionModeForSelect(i);
+				return;
+			case TAG_ID.TEMPLATE:
+				this.insertionMode = this.tmplInsertionModeStack[0];
+				return;
+			case TAG_ID.HTML:
+				this.insertionMode = this.headElement ? InsertionMode.AFTER_HEAD : InsertionMode.BEFORE_HEAD;
+				return;
+			case TAG_ID.TD:
+			case TAG_ID.TH:
+				if (i > 0) {
+					this.insertionMode = InsertionMode.IN_CELL;
+					return;
+				}
+				break;
+			case TAG_ID.HEAD:
+				if (i > 0) {
+					this.insertionMode = InsertionMode.IN_HEAD;
+					return;
+				}
+				break;
+		}
+		this.insertionMode = InsertionMode.IN_BODY;
+	}
+	/** @protected */
+	_resetInsertionModeForSelect(selectIdx) {
+		if (selectIdx > 0) for (let i = selectIdx - 1; i > 0; i--) {
+			const tn = this.openElements.tagIDs[i];
+			if (tn === TAG_ID.TEMPLATE) break;
+			else if (tn === TAG_ID.TABLE) {
+				this.insertionMode = InsertionMode.IN_SELECT_IN_TABLE;
+				return;
+			}
+		}
+		this.insertionMode = InsertionMode.IN_SELECT;
+	}
+	/** @protected */
+	_isElementCausesFosterParenting(tn) {
+		return TABLE_STRUCTURE_TAGS.has(tn);
+	}
+	/** @protected */
+	_shouldFosterParentOnInsertion() {
+		return this.fosterParentingEnabled && this.openElements.currentTagId !== void 0 && this._isElementCausesFosterParenting(this.openElements.currentTagId);
+	}
+	/** @protected */
+	_findFosterParentingLocation() {
+		for (let i = this.openElements.stackTop; i >= 0; i--) {
+			const openElement = this.openElements.items[i];
+			switch (this.openElements.tagIDs[i]) {
+				case TAG_ID.TEMPLATE:
+					if (this.treeAdapter.getNamespaceURI(openElement) === NS.HTML) return {
+						parent: this.treeAdapter.getTemplateContent(openElement),
+						beforeElement: null
+					};
+					break;
+				case TAG_ID.TABLE: {
+					const parent = this.treeAdapter.getParentNode(openElement);
+					if (parent) return {
+						parent,
+						beforeElement: openElement
+					};
+					return {
+						parent: this.openElements.items[i - 1],
+						beforeElement: null
+					};
+				}
+				default:
+			}
+		}
+		return {
+			parent: this.openElements.items[0],
+			beforeElement: null
+		};
+	}
+	/** @protected */
+	_fosterParentElement(element) {
+		const location = this._findFosterParentingLocation();
+		if (location.beforeElement) this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);
+		else this.treeAdapter.appendChild(location.parent, element);
+	}
+	/** @protected */
+	_isSpecialElement(element, id) {
+		return SPECIAL_ELEMENTS[this.treeAdapter.getNamespaceURI(element)].has(id);
+	}
+	/** @internal */
+	onCharacter(token) {
+		this.skipNextNewLine = false;
+		if (this.tokenizer.inForeignNode) {
+			characterInForeignContent(this, token);
+			return;
+		}
+		switch (this.insertionMode) {
+			case InsertionMode.INITIAL:
+				tokenInInitialMode(this, token);
+				break;
+			case InsertionMode.BEFORE_HTML:
+				tokenBeforeHtml(this, token);
+				break;
+			case InsertionMode.BEFORE_HEAD:
+				tokenBeforeHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD:
+				tokenInHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD_NO_SCRIPT:
+				tokenInHeadNoScript(this, token);
+				break;
+			case InsertionMode.AFTER_HEAD:
+				tokenAfterHead(this, token);
+				break;
+			case InsertionMode.IN_BODY:
+			case InsertionMode.IN_CAPTION:
+			case InsertionMode.IN_CELL:
+			case InsertionMode.IN_TEMPLATE:
+				characterInBody(this, token);
+				break;
+			case InsertionMode.TEXT:
+			case InsertionMode.IN_SELECT:
+			case InsertionMode.IN_SELECT_IN_TABLE:
+				this._insertCharacters(token);
+				break;
+			case InsertionMode.IN_TABLE:
+			case InsertionMode.IN_TABLE_BODY:
+			case InsertionMode.IN_ROW:
+				characterInTable(this, token);
+				break;
+			case InsertionMode.IN_TABLE_TEXT:
+				characterInTableText(this, token);
+				break;
+			case InsertionMode.IN_COLUMN_GROUP:
+				tokenInColumnGroup(this, token);
+				break;
+			case InsertionMode.AFTER_BODY:
+				tokenAfterBody(this, token);
+				break;
+			case InsertionMode.AFTER_AFTER_BODY:
+				tokenAfterAfterBody(this, token);
+				break;
+			default:
+		}
+	}
+	/** @internal */
+	onNullCharacter(token) {
+		this.skipNextNewLine = false;
+		if (this.tokenizer.inForeignNode) {
+			nullCharacterInForeignContent(this, token);
+			return;
+		}
+		switch (this.insertionMode) {
+			case InsertionMode.INITIAL:
+				tokenInInitialMode(this, token);
+				break;
+			case InsertionMode.BEFORE_HTML:
+				tokenBeforeHtml(this, token);
+				break;
+			case InsertionMode.BEFORE_HEAD:
+				tokenBeforeHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD:
+				tokenInHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD_NO_SCRIPT:
+				tokenInHeadNoScript(this, token);
+				break;
+			case InsertionMode.AFTER_HEAD:
+				tokenAfterHead(this, token);
+				break;
+			case InsertionMode.TEXT:
+				this._insertCharacters(token);
+				break;
+			case InsertionMode.IN_TABLE:
+			case InsertionMode.IN_TABLE_BODY:
+			case InsertionMode.IN_ROW:
+				characterInTable(this, token);
+				break;
+			case InsertionMode.IN_COLUMN_GROUP:
+				tokenInColumnGroup(this, token);
+				break;
+			case InsertionMode.AFTER_BODY:
+				tokenAfterBody(this, token);
+				break;
+			case InsertionMode.AFTER_AFTER_BODY:
+				tokenAfterAfterBody(this, token);
+				break;
+			default:
+		}
+	}
+	/** @internal */
+	onComment(token) {
+		this.skipNextNewLine = false;
+		if (this.currentNotInHTML) {
+			appendComment(this, token);
+			return;
+		}
+		switch (this.insertionMode) {
+			case InsertionMode.INITIAL:
+			case InsertionMode.BEFORE_HTML:
+			case InsertionMode.BEFORE_HEAD:
+			case InsertionMode.IN_HEAD:
+			case InsertionMode.IN_HEAD_NO_SCRIPT:
+			case InsertionMode.AFTER_HEAD:
+			case InsertionMode.IN_BODY:
+			case InsertionMode.IN_TABLE:
+			case InsertionMode.IN_CAPTION:
+			case InsertionMode.IN_COLUMN_GROUP:
+			case InsertionMode.IN_TABLE_BODY:
+			case InsertionMode.IN_ROW:
+			case InsertionMode.IN_CELL:
+			case InsertionMode.IN_SELECT:
+			case InsertionMode.IN_SELECT_IN_TABLE:
+			case InsertionMode.IN_TEMPLATE:
+			case InsertionMode.IN_FRAMESET:
+			case InsertionMode.AFTER_FRAMESET:
+				appendComment(this, token);
+				break;
+			case InsertionMode.IN_TABLE_TEXT:
+				tokenInTableText(this, token);
+				break;
+			case InsertionMode.AFTER_BODY:
+				appendCommentToRootHtmlElement(this, token);
+				break;
+			case InsertionMode.AFTER_AFTER_BODY:
+			case InsertionMode.AFTER_AFTER_FRAMESET:
+				appendCommentToDocument(this, token);
+				break;
+			default:
+		}
+	}
+	/** @internal */
+	onDoctype(token) {
+		this.skipNextNewLine = false;
+		switch (this.insertionMode) {
+			case InsertionMode.INITIAL:
+				doctypeInInitialMode(this, token);
+				break;
+			case InsertionMode.BEFORE_HEAD:
+			case InsertionMode.IN_HEAD:
+			case InsertionMode.IN_HEAD_NO_SCRIPT:
+			case InsertionMode.AFTER_HEAD:
+				this._err(token, ERR.misplacedDoctype);
+				break;
+			case InsertionMode.IN_TABLE_TEXT:
+				tokenInTableText(this, token);
+				break;
+			default:
+		}
+	}
+	/** @internal */
+	onStartTag(token) {
+		this.skipNextNewLine = false;
+		this.currentToken = token;
+		this._processStartTag(token);
+		if (token.selfClosing && !token.ackSelfClosing) this._err(token, ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);
+	}
+	/**
+	* Processes a given start tag.
+	*
+	* `onStartTag` checks if a self-closing tag was recognized. When a token
+	* is moved inbetween multiple insertion modes, this check for self-closing
+	* could lead to false positives. To avoid this, `_processStartTag` is used
+	* for nested calls.
+	*
+	* @param token The token to process.
+	* @protected
+	*/
+	_processStartTag(token) {
+		if (this.shouldProcessStartTagTokenInForeignContent(token)) startTagInForeignContent(this, token);
+		else this._startTagOutsideForeignContent(token);
+	}
+	/** @protected */
+	_startTagOutsideForeignContent(token) {
+		switch (this.insertionMode) {
+			case InsertionMode.INITIAL:
+				tokenInInitialMode(this, token);
+				break;
+			case InsertionMode.BEFORE_HTML:
+				startTagBeforeHtml(this, token);
+				break;
+			case InsertionMode.BEFORE_HEAD:
+				startTagBeforeHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD:
+				startTagInHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD_NO_SCRIPT:
+				startTagInHeadNoScript(this, token);
+				break;
+			case InsertionMode.AFTER_HEAD:
+				startTagAfterHead(this, token);
+				break;
+			case InsertionMode.IN_BODY:
+				startTagInBody(this, token);
+				break;
+			case InsertionMode.IN_TABLE:
+				startTagInTable(this, token);
+				break;
+			case InsertionMode.IN_TABLE_TEXT:
+				tokenInTableText(this, token);
+				break;
+			case InsertionMode.IN_CAPTION:
+				startTagInCaption(this, token);
+				break;
+			case InsertionMode.IN_COLUMN_GROUP:
+				startTagInColumnGroup(this, token);
+				break;
+			case InsertionMode.IN_TABLE_BODY:
+				startTagInTableBody(this, token);
+				break;
+			case InsertionMode.IN_ROW:
+				startTagInRow(this, token);
+				break;
+			case InsertionMode.IN_CELL:
+				startTagInCell(this, token);
+				break;
+			case InsertionMode.IN_SELECT:
+				startTagInSelect(this, token);
+				break;
+			case InsertionMode.IN_SELECT_IN_TABLE:
+				startTagInSelectInTable(this, token);
+				break;
+			case InsertionMode.IN_TEMPLATE:
+				startTagInTemplate(this, token);
+				break;
+			case InsertionMode.AFTER_BODY:
+				startTagAfterBody(this, token);
+				break;
+			case InsertionMode.IN_FRAMESET:
+				startTagInFrameset(this, token);
+				break;
+			case InsertionMode.AFTER_FRAMESET:
+				startTagAfterFrameset(this, token);
+				break;
+			case InsertionMode.AFTER_AFTER_BODY:
+				startTagAfterAfterBody(this, token);
+				break;
+			case InsertionMode.AFTER_AFTER_FRAMESET:
+				startTagAfterAfterFrameset(this, token);
+				break;
+			default:
+		}
+	}
+	/** @internal */
+	onEndTag(token) {
+		this.skipNextNewLine = false;
+		this.currentToken = token;
+		if (this.currentNotInHTML) endTagInForeignContent(this, token);
+		else this._endTagOutsideForeignContent(token);
+	}
+	/** @protected */
+	_endTagOutsideForeignContent(token) {
+		switch (this.insertionMode) {
+			case InsertionMode.INITIAL:
+				tokenInInitialMode(this, token);
+				break;
+			case InsertionMode.BEFORE_HTML:
+				endTagBeforeHtml(this, token);
+				break;
+			case InsertionMode.BEFORE_HEAD:
+				endTagBeforeHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD:
+				endTagInHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD_NO_SCRIPT:
+				endTagInHeadNoScript(this, token);
+				break;
+			case InsertionMode.AFTER_HEAD:
+				endTagAfterHead(this, token);
+				break;
+			case InsertionMode.IN_BODY:
+				endTagInBody(this, token);
+				break;
+			case InsertionMode.TEXT:
+				endTagInText(this, token);
+				break;
+			case InsertionMode.IN_TABLE:
+				endTagInTable(this, token);
+				break;
+			case InsertionMode.IN_TABLE_TEXT:
+				tokenInTableText(this, token);
+				break;
+			case InsertionMode.IN_CAPTION:
+				endTagInCaption(this, token);
+				break;
+			case InsertionMode.IN_COLUMN_GROUP:
+				endTagInColumnGroup(this, token);
+				break;
+			case InsertionMode.IN_TABLE_BODY:
+				endTagInTableBody(this, token);
+				break;
+			case InsertionMode.IN_ROW:
+				endTagInRow(this, token);
+				break;
+			case InsertionMode.IN_CELL:
+				endTagInCell(this, token);
+				break;
+			case InsertionMode.IN_SELECT:
+				endTagInSelect(this, token);
+				break;
+			case InsertionMode.IN_SELECT_IN_TABLE:
+				endTagInSelectInTable(this, token);
+				break;
+			case InsertionMode.IN_TEMPLATE:
+				endTagInTemplate(this, token);
+				break;
+			case InsertionMode.AFTER_BODY:
+				endTagAfterBody(this, token);
+				break;
+			case InsertionMode.IN_FRAMESET:
+				endTagInFrameset(this, token);
+				break;
+			case InsertionMode.AFTER_FRAMESET:
+				endTagAfterFrameset(this, token);
+				break;
+			case InsertionMode.AFTER_AFTER_BODY:
+				tokenAfterAfterBody(this, token);
+				break;
+			default:
+		}
+	}
+	/** @internal */
+	onEof(token) {
+		switch (this.insertionMode) {
+			case InsertionMode.INITIAL:
+				tokenInInitialMode(this, token);
+				break;
+			case InsertionMode.BEFORE_HTML:
+				tokenBeforeHtml(this, token);
+				break;
+			case InsertionMode.BEFORE_HEAD:
+				tokenBeforeHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD:
+				tokenInHead(this, token);
+				break;
+			case InsertionMode.IN_HEAD_NO_SCRIPT:
+				tokenInHeadNoScript(this, token);
+				break;
+			case InsertionMode.AFTER_HEAD:
+				tokenAfterHead(this, token);
+				break;
+			case InsertionMode.IN_BODY:
+			case InsertionMode.IN_TABLE:
+			case InsertionMode.IN_CAPTION:
+			case InsertionMode.IN_COLUMN_GROUP:
+			case InsertionMode.IN_TABLE_BODY:
+			case InsertionMode.IN_ROW:
+			case InsertionMode.IN_CELL:
+			case InsertionMode.IN_SELECT:
+			case InsertionMode.IN_SELECT_IN_TABLE:
+				eofInBody(this, token);
+				break;
+			case InsertionMode.TEXT:
+				eofInText(this, token);
+				break;
+			case InsertionMode.IN_TABLE_TEXT:
+				tokenInTableText(this, token);
+				break;
+			case InsertionMode.IN_TEMPLATE:
+				eofInTemplate(this, token);
+				break;
+			case InsertionMode.AFTER_BODY:
+			case InsertionMode.IN_FRAMESET:
+			case InsertionMode.AFTER_FRAMESET:
+			case InsertionMode.AFTER_AFTER_BODY:
+			case InsertionMode.AFTER_AFTER_FRAMESET:
+				stopParsing(this, token);
+				break;
+			default:
+		}
+	}
+	/** @internal */
+	onWhitespaceCharacter(token) {
+		if (this.skipNextNewLine) {
+			this.skipNextNewLine = false;
+			if (token.chars.charCodeAt(0) === CODE_POINTS.LINE_FEED) {
+				if (token.chars.length === 1) return;
+				token.chars = token.chars.substr(1);
+			}
+		}
+		if (this.tokenizer.inForeignNode) {
+			this._insertCharacters(token);
+			return;
+		}
+		switch (this.insertionMode) {
+			case InsertionMode.IN_HEAD:
+			case InsertionMode.IN_HEAD_NO_SCRIPT:
+			case InsertionMode.AFTER_HEAD:
+			case InsertionMode.TEXT:
+			case InsertionMode.IN_COLUMN_GROUP:
+			case InsertionMode.IN_SELECT:
+			case InsertionMode.IN_SELECT_IN_TABLE:
+			case InsertionMode.IN_FRAMESET:
+			case InsertionMode.AFTER_FRAMESET:
+				this._insertCharacters(token);
+				break;
+			case InsertionMode.IN_BODY:
+			case InsertionMode.IN_CAPTION:
+			case InsertionMode.IN_CELL:
+			case InsertionMode.IN_TEMPLATE:
+			case InsertionMode.AFTER_BODY:
+			case InsertionMode.AFTER_AFTER_BODY:
+			case InsertionMode.AFTER_AFTER_FRAMESET:
+				whitespaceCharacterInBody(this, token);
+				break;
+			case InsertionMode.IN_TABLE:
+			case InsertionMode.IN_TABLE_BODY:
+			case InsertionMode.IN_ROW:
+				characterInTable(this, token);
+				break;
+			case InsertionMode.IN_TABLE_TEXT:
+				whitespaceCharacterInTableText(this, token);
+				break;
+			default:
+		}
+	}
+};
+function aaObtainFormattingElementEntry(p, token) {
+	let formattingElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(token.tagName);
+	if (formattingElementEntry) {
+		if (!p.openElements.contains(formattingElementEntry.element)) {
+			p.activeFormattingElements.removeEntry(formattingElementEntry);
+			formattingElementEntry = null;
+		} else if (!p.openElements.hasInScope(token.tagID)) formattingElementEntry = null;
+	} else genericEndTagInBody(p, token);
+	return formattingElementEntry;
+}
+function aaObtainFurthestBlock(p, formattingElementEntry) {
+	let furthestBlock = null;
+	let idx = p.openElements.stackTop;
+	for (; idx >= 0; idx--) {
+		const element = p.openElements.items[idx];
+		if (element === formattingElementEntry.element) break;
+		if (p._isSpecialElement(element, p.openElements.tagIDs[idx])) furthestBlock = element;
+	}
+	if (!furthestBlock) {
+		p.openElements.shortenToLength(Math.max(idx, 0));
+		p.activeFormattingElements.removeEntry(formattingElementEntry);
+	}
+	return furthestBlock;
+}
+function aaInnerLoop(p, furthestBlock, formattingElement) {
+	let lastElement = furthestBlock;
+	let nextElement = p.openElements.getCommonAncestor(furthestBlock);
+	for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {
+		nextElement = p.openElements.getCommonAncestor(element);
+		const elementEntry = p.activeFormattingElements.getElementEntry(element);
+		const counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER;
+		if (!elementEntry || counterOverflow) {
+			if (counterOverflow) p.activeFormattingElements.removeEntry(elementEntry);
+			p.openElements.remove(element);
+		} else {
+			element = aaRecreateElementFromEntry(p, elementEntry);
+			if (lastElement === furthestBlock) p.activeFormattingElements.bookmark = elementEntry;
+			p.treeAdapter.detachNode(lastElement);
+			p.treeAdapter.appendChild(element, lastElement);
+			lastElement = element;
+		}
+	}
+	return lastElement;
+}
+function aaRecreateElementFromEntry(p, elementEntry) {
+	const ns = p.treeAdapter.getNamespaceURI(elementEntry.element);
+	const newElement = p.treeAdapter.createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs);
+	p.openElements.replace(elementEntry.element, newElement);
+	elementEntry.element = newElement;
+	return newElement;
+}
+function aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {
+	const tid = getTagID(p.treeAdapter.getTagName(commonAncestor));
+	if (p._isElementCausesFosterParenting(tid)) p._fosterParentElement(lastElement);
+	else {
+		const ns = p.treeAdapter.getNamespaceURI(commonAncestor);
+		if (tid === TAG_ID.TEMPLATE && ns === NS.HTML) commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor);
+		p.treeAdapter.appendChild(commonAncestor, lastElement);
+	}
+}
+function aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {
+	const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element);
+	const { token } = formattingElementEntry;
+	const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);
+	p._adoptNodes(furthestBlock, newElement);
+	p.treeAdapter.appendChild(furthestBlock, newElement);
+	p.activeFormattingElements.insertElementAfterBookmark(newElement, token);
+	p.activeFormattingElements.removeEntry(formattingElementEntry);
+	p.openElements.remove(formattingElementEntry.element);
+	p.openElements.insertAfter(furthestBlock, newElement, token.tagID);
+}
+function callAdoptionAgency(p, token) {
+	for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) {
+		const formattingElementEntry = aaObtainFormattingElementEntry(p, token);
+		if (!formattingElementEntry) break;
+		const furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);
+		if (!furthestBlock) break;
+		p.activeFormattingElements.bookmark = formattingElementEntry;
+		const lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element);
+		const commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);
+		p.treeAdapter.detachNode(lastElement);
+		if (commonAncestor) aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement);
+		aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry);
+	}
+}
+function appendComment(p, token) {
+	p._appendCommentNode(token, p.openElements.currentTmplContentOrNode);
+}
+function appendCommentToRootHtmlElement(p, token) {
+	p._appendCommentNode(token, p.openElements.items[0]);
+}
+function appendCommentToDocument(p, token) {
+	p._appendCommentNode(token, p.document);
+}
+function stopParsing(p, token) {
+	p.stopped = true;
+	if (token.location) {
+		const target = p.fragmentContext ? 0 : 2;
+		for (let i = p.openElements.stackTop; i >= target; i--) p._setEndLocation(p.openElements.items[i], token);
+		if (!p.fragmentContext && p.openElements.stackTop >= 0) {
+			const htmlElement = p.openElements.items[0];
+			const htmlLocation = p.treeAdapter.getNodeSourceCodeLocation(htmlElement);
+			if (htmlLocation && !htmlLocation.endTag) {
+				p._setEndLocation(htmlElement, token);
+				if (p.openElements.stackTop >= 1) {
+					const bodyElement = p.openElements.items[1];
+					const bodyLocation = p.treeAdapter.getNodeSourceCodeLocation(bodyElement);
+					if (bodyLocation && !bodyLocation.endTag) p._setEndLocation(bodyElement, token);
+				}
+			}
+		}
+	}
+}
+function doctypeInInitialMode(p, token) {
+	p._setDocumentType(token);
+	const mode = token.forceQuirks ? DOCUMENT_MODE.QUIRKS : getDocumentMode(token);
+	if (!isConforming(token)) p._err(token, ERR.nonConformingDoctype);
+	p.treeAdapter.setDocumentMode(p.document, mode);
+	p.insertionMode = InsertionMode.BEFORE_HTML;
+}
+function tokenInInitialMode(p, token) {
+	p._err(token, ERR.missingDoctype, true);
+	p.treeAdapter.setDocumentMode(p.document, DOCUMENT_MODE.QUIRKS);
+	p.insertionMode = InsertionMode.BEFORE_HTML;
+	p._processToken(token);
+}
+function startTagBeforeHtml(p, token) {
+	if (token.tagID === TAG_ID.HTML) {
+		p._insertElement(token, NS.HTML);
+		p.insertionMode = InsertionMode.BEFORE_HEAD;
+	} else tokenBeforeHtml(p, token);
+}
+function endTagBeforeHtml(p, token) {
+	const tn = token.tagID;
+	if (tn === TAG_ID.HTML || tn === TAG_ID.HEAD || tn === TAG_ID.BODY || tn === TAG_ID.BR) tokenBeforeHtml(p, token);
+}
+function tokenBeforeHtml(p, token) {
+	p._insertFakeRootElement();
+	p.insertionMode = InsertionMode.BEFORE_HEAD;
+	p._processToken(token);
+}
+function startTagBeforeHead(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HTML:
+			startTagInBody(p, token);
+			break;
+		case TAG_ID.HEAD:
+			p._insertElement(token, NS.HTML);
+			p.headElement = p.openElements.current;
+			p.insertionMode = InsertionMode.IN_HEAD;
+			break;
+		default: tokenBeforeHead(p, token);
+	}
+}
+function endTagBeforeHead(p, token) {
+	const tn = token.tagID;
+	if (tn === TAG_ID.HEAD || tn === TAG_ID.BODY || tn === TAG_ID.HTML || tn === TAG_ID.BR) tokenBeforeHead(p, token);
+	else p._err(token, ERR.endTagWithoutMatchingOpenElement);
+}
+function tokenBeforeHead(p, token) {
+	p._insertFakeElement(TAG_NAMES.HEAD, TAG_ID.HEAD);
+	p.headElement = p.openElements.current;
+	p.insertionMode = InsertionMode.IN_HEAD;
+	p._processToken(token);
+}
+function startTagInHead(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HTML:
+			startTagInBody(p, token);
+			break;
+		case TAG_ID.BASE:
+		case TAG_ID.BASEFONT:
+		case TAG_ID.BGSOUND:
+		case TAG_ID.LINK:
+		case TAG_ID.META:
+			p._appendElement(token, NS.HTML);
+			token.ackSelfClosing = true;
+			break;
+		case TAG_ID.TITLE:
+			p._switchToTextParsing(token, TokenizerMode.RCDATA);
+			break;
+		case TAG_ID.NOSCRIPT:
+			if (p.options.scriptingEnabled) p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+			else {
+				p._insertElement(token, NS.HTML);
+				p.insertionMode = InsertionMode.IN_HEAD_NO_SCRIPT;
+			}
+			break;
+		case TAG_ID.NOFRAMES:
+		case TAG_ID.STYLE:
+			p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+			break;
+		case TAG_ID.SCRIPT:
+			p._switchToTextParsing(token, TokenizerMode.SCRIPT_DATA);
+			break;
+		case TAG_ID.TEMPLATE:
+			p._insertTemplate(token);
+			p.activeFormattingElements.insertMarker();
+			p.framesetOk = false;
+			p.insertionMode = InsertionMode.IN_TEMPLATE;
+			p.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);
+			break;
+		case TAG_ID.HEAD:
+			p._err(token, ERR.misplacedStartTagForHeadElement);
+			break;
+		default: tokenInHead(p, token);
+	}
+}
+function endTagInHead(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HEAD:
+			p.openElements.pop();
+			p.insertionMode = InsertionMode.AFTER_HEAD;
+			break;
+		case TAG_ID.BODY:
+		case TAG_ID.BR:
+		case TAG_ID.HTML:
+			tokenInHead(p, token);
+			break;
+		case TAG_ID.TEMPLATE:
+			templateEndTagInHead(p, token);
+			break;
+		default: p._err(token, ERR.endTagWithoutMatchingOpenElement);
+	}
+}
+function templateEndTagInHead(p, token) {
+	if (p.openElements.tmplCount > 0) {
+		p.openElements.generateImpliedEndTagsThoroughly();
+		if (p.openElements.currentTagId !== TAG_ID.TEMPLATE) p._err(token, ERR.closingOfElementWithOpenChildElements);
+		p.openElements.popUntilTagNamePopped(TAG_ID.TEMPLATE);
+		p.activeFormattingElements.clearToLastMarker();
+		p.tmplInsertionModeStack.shift();
+		p._resetInsertionMode();
+	} else p._err(token, ERR.endTagWithoutMatchingOpenElement);
+}
+function tokenInHead(p, token) {
+	p.openElements.pop();
+	p.insertionMode = InsertionMode.AFTER_HEAD;
+	p._processToken(token);
+}
+function startTagInHeadNoScript(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HTML:
+			startTagInBody(p, token);
+			break;
+		case TAG_ID.BASEFONT:
+		case TAG_ID.BGSOUND:
+		case TAG_ID.HEAD:
+		case TAG_ID.LINK:
+		case TAG_ID.META:
+		case TAG_ID.NOFRAMES:
+		case TAG_ID.STYLE:
+			startTagInHead(p, token);
+			break;
+		case TAG_ID.NOSCRIPT:
+			p._err(token, ERR.nestedNoscriptInHead);
+			break;
+		default: tokenInHeadNoScript(p, token);
+	}
+}
+function endTagInHeadNoScript(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.NOSCRIPT:
+			p.openElements.pop();
+			p.insertionMode = InsertionMode.IN_HEAD;
+			break;
+		case TAG_ID.BR:
+			tokenInHeadNoScript(p, token);
+			break;
+		default: p._err(token, ERR.endTagWithoutMatchingOpenElement);
+	}
+}
+function tokenInHeadNoScript(p, token) {
+	p._err(token, token.type === TokenType.EOF ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead);
+	p.openElements.pop();
+	p.insertionMode = InsertionMode.IN_HEAD;
+	p._processToken(token);
+}
+function startTagAfterHead(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HTML:
+			startTagInBody(p, token);
+			break;
+		case TAG_ID.BODY:
+			p._insertElement(token, NS.HTML);
+			p.framesetOk = false;
+			p.insertionMode = InsertionMode.IN_BODY;
+			break;
+		case TAG_ID.FRAMESET:
+			p._insertElement(token, NS.HTML);
+			p.insertionMode = InsertionMode.IN_FRAMESET;
+			break;
+		case TAG_ID.BASE:
+		case TAG_ID.BASEFONT:
+		case TAG_ID.BGSOUND:
+		case TAG_ID.LINK:
+		case TAG_ID.META:
+		case TAG_ID.NOFRAMES:
+		case TAG_ID.SCRIPT:
+		case TAG_ID.STYLE:
+		case TAG_ID.TEMPLATE:
+		case TAG_ID.TITLE:
+			p._err(token, ERR.abandonedHeadElementChild);
+			p.openElements.push(p.headElement, TAG_ID.HEAD);
+			startTagInHead(p, token);
+			p.openElements.remove(p.headElement);
+			break;
+		case TAG_ID.HEAD:
+			p._err(token, ERR.misplacedStartTagForHeadElement);
+			break;
+		default: tokenAfterHead(p, token);
+	}
+}
+function endTagAfterHead(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.BODY:
+		case TAG_ID.HTML:
+		case TAG_ID.BR:
+			tokenAfterHead(p, token);
+			break;
+		case TAG_ID.TEMPLATE:
+			templateEndTagInHead(p, token);
+			break;
+		default: p._err(token, ERR.endTagWithoutMatchingOpenElement);
+	}
+}
+function tokenAfterHead(p, token) {
+	p._insertFakeElement(TAG_NAMES.BODY, TAG_ID.BODY);
+	p.insertionMode = InsertionMode.IN_BODY;
+	modeInBody(p, token);
+}
+function modeInBody(p, token) {
+	switch (token.type) {
+		case TokenType.CHARACTER:
+			characterInBody(p, token);
+			break;
+		case TokenType.WHITESPACE_CHARACTER:
+			whitespaceCharacterInBody(p, token);
+			break;
+		case TokenType.COMMENT:
+			appendComment(p, token);
+			break;
+		case TokenType.START_TAG:
+			startTagInBody(p, token);
+			break;
+		case TokenType.END_TAG:
+			endTagInBody(p, token);
+			break;
+		case TokenType.EOF:
+			eofInBody(p, token);
+			break;
+		default:
+	}
+}
+function whitespaceCharacterInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	p._insertCharacters(token);
+}
+function characterInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	p._insertCharacters(token);
+	p.framesetOk = false;
+}
+function htmlStartTagInBody(p, token) {
+	if (p.openElements.tmplCount === 0) p.treeAdapter.adoptAttributes(p.openElements.items[0], token.attrs);
+}
+function bodyStartTagInBody(p, token) {
+	const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
+	if (bodyElement && p.openElements.tmplCount === 0) {
+		p.framesetOk = false;
+		p.treeAdapter.adoptAttributes(bodyElement, token.attrs);
+	}
+}
+function framesetStartTagInBody(p, token) {
+	const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
+	if (p.framesetOk && bodyElement) {
+		p.treeAdapter.detachNode(bodyElement);
+		p.openElements.popAllUpToHtmlElement();
+		p._insertElement(token, NS.HTML);
+		p.insertionMode = InsertionMode.IN_FRAMESET;
+	}
+}
+function addressStartTagInBody(p, token) {
+	if (p.openElements.hasInButtonScope(TAG_ID.P)) p._closePElement();
+	p._insertElement(token, NS.HTML);
+}
+function numberedHeaderStartTagInBody(p, token) {
+	if (p.openElements.hasInButtonScope(TAG_ID.P)) p._closePElement();
+	if (p.openElements.currentTagId !== void 0 && NUMBERED_HEADERS.has(p.openElements.currentTagId)) p.openElements.pop();
+	p._insertElement(token, NS.HTML);
+}
+function preStartTagInBody(p, token) {
+	if (p.openElements.hasInButtonScope(TAG_ID.P)) p._closePElement();
+	p._insertElement(token, NS.HTML);
+	p.skipNextNewLine = true;
+	p.framesetOk = false;
+}
+function formStartTagInBody(p, token) {
+	const inTemplate = p.openElements.tmplCount > 0;
+	if (!p.formElement || inTemplate) {
+		if (p.openElements.hasInButtonScope(TAG_ID.P)) p._closePElement();
+		p._insertElement(token, NS.HTML);
+		if (!inTemplate) p.formElement = p.openElements.current;
+	}
+}
+function listItemStartTagInBody(p, token) {
+	p.framesetOk = false;
+	const tn = token.tagID;
+	for (let i = p.openElements.stackTop; i >= 0; i--) {
+		const elementId = p.openElements.tagIDs[i];
+		if (tn === TAG_ID.LI && elementId === TAG_ID.LI || (tn === TAG_ID.DD || tn === TAG_ID.DT) && (elementId === TAG_ID.DD || elementId === TAG_ID.DT)) {
+			p.openElements.generateImpliedEndTagsWithExclusion(elementId);
+			p.openElements.popUntilTagNamePopped(elementId);
+			break;
+		}
+		if (elementId !== TAG_ID.ADDRESS && elementId !== TAG_ID.DIV && elementId !== TAG_ID.P && p._isSpecialElement(p.openElements.items[i], elementId)) break;
+	}
+	if (p.openElements.hasInButtonScope(TAG_ID.P)) p._closePElement();
+	p._insertElement(token, NS.HTML);
+}
+function plaintextStartTagInBody(p, token) {
+	if (p.openElements.hasInButtonScope(TAG_ID.P)) p._closePElement();
+	p._insertElement(token, NS.HTML);
+	p.tokenizer.state = TokenizerMode.PLAINTEXT;
+}
+function buttonStartTagInBody(p, token) {
+	if (p.openElements.hasInScope(TAG_ID.BUTTON)) {
+		p.openElements.generateImpliedEndTags();
+		p.openElements.popUntilTagNamePopped(TAG_ID.BUTTON);
+	}
+	p._reconstructActiveFormattingElements();
+	p._insertElement(token, NS.HTML);
+	p.framesetOk = false;
+}
+function aStartTagInBody(p, token) {
+	const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(TAG_NAMES.A);
+	if (activeElementEntry) {
+		callAdoptionAgency(p, token);
+		p.openElements.remove(activeElementEntry.element);
+		p.activeFormattingElements.removeEntry(activeElementEntry);
+	}
+	p._reconstructActiveFormattingElements();
+	p._insertElement(token, NS.HTML);
+	p.activeFormattingElements.pushElement(p.openElements.current, token);
+}
+function bStartTagInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	p._insertElement(token, NS.HTML);
+	p.activeFormattingElements.pushElement(p.openElements.current, token);
+}
+function nobrStartTagInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	if (p.openElements.hasInScope(TAG_ID.NOBR)) {
+		callAdoptionAgency(p, token);
+		p._reconstructActiveFormattingElements();
+	}
+	p._insertElement(token, NS.HTML);
+	p.activeFormattingElements.pushElement(p.openElements.current, token);
+}
+function appletStartTagInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	p._insertElement(token, NS.HTML);
+	p.activeFormattingElements.insertMarker();
+	p.framesetOk = false;
+}
+function tableStartTagInBody(p, token) {
+	if (p.treeAdapter.getDocumentMode(p.document) !== DOCUMENT_MODE.QUIRKS && p.openElements.hasInButtonScope(TAG_ID.P)) p._closePElement();
+	p._insertElement(token, NS.HTML);
+	p.framesetOk = false;
+	p.insertionMode = InsertionMode.IN_TABLE;
+}
+function areaStartTagInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	p._appendElement(token, NS.HTML);
+	p.framesetOk = false;
+	token.ackSelfClosing = true;
+}
+function isHiddenInput(token) {
+	const inputType = getTokenAttr(token, ATTRS.TYPE);
+	return inputType != null && inputType.toLowerCase() === HIDDEN_INPUT_TYPE;
+}
+function inputStartTagInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	p._appendElement(token, NS.HTML);
+	if (!isHiddenInput(token)) p.framesetOk = false;
+	token.ackSelfClosing = true;
+}
+function paramStartTagInBody(p, token) {
+	p._appendElement(token, NS.HTML);
+	token.ackSelfClosing = true;
+}
+function hrStartTagInBody(p, token) {
+	if (p.openElements.hasInButtonScope(TAG_ID.P)) p._closePElement();
+	p._appendElement(token, NS.HTML);
+	p.framesetOk = false;
+	token.ackSelfClosing = true;
+}
+function imageStartTagInBody(p, token) {
+	token.tagName = TAG_NAMES.IMG;
+	token.tagID = TAG_ID.IMG;
+	areaStartTagInBody(p, token);
+}
+function textareaStartTagInBody(p, token) {
+	p._insertElement(token, NS.HTML);
+	p.skipNextNewLine = true;
+	p.tokenizer.state = TokenizerMode.RCDATA;
+	p.originalInsertionMode = p.insertionMode;
+	p.framesetOk = false;
+	p.insertionMode = InsertionMode.TEXT;
+}
+function xmpStartTagInBody(p, token) {
+	if (p.openElements.hasInButtonScope(TAG_ID.P)) p._closePElement();
+	p._reconstructActiveFormattingElements();
+	p.framesetOk = false;
+	p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+}
+function iframeStartTagInBody(p, token) {
+	p.framesetOk = false;
+	p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+}
+function rawTextStartTagInBody(p, token) {
+	p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+}
+function selectStartTagInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	p._insertElement(token, NS.HTML);
+	p.framesetOk = false;
+	p.insertionMode = p.insertionMode === InsertionMode.IN_TABLE || p.insertionMode === InsertionMode.IN_CAPTION || p.insertionMode === InsertionMode.IN_TABLE_BODY || p.insertionMode === InsertionMode.IN_ROW || p.insertionMode === InsertionMode.IN_CELL ? InsertionMode.IN_SELECT_IN_TABLE : InsertionMode.IN_SELECT;
+}
+function optgroupStartTagInBody(p, token) {
+	if (p.openElements.currentTagId === TAG_ID.OPTION) p.openElements.pop();
+	p._reconstructActiveFormattingElements();
+	p._insertElement(token, NS.HTML);
+}
+function rbStartTagInBody(p, token) {
+	if (p.openElements.hasInScope(TAG_ID.RUBY)) p.openElements.generateImpliedEndTags();
+	p._insertElement(token, NS.HTML);
+}
+function rtStartTagInBody(p, token) {
+	if (p.openElements.hasInScope(TAG_ID.RUBY)) p.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.RTC);
+	p._insertElement(token, NS.HTML);
+}
+function mathStartTagInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	adjustTokenMathMLAttrs(token);
+	adjustTokenXMLAttrs(token);
+	if (token.selfClosing) p._appendElement(token, NS.MATHML);
+	else p._insertElement(token, NS.MATHML);
+	token.ackSelfClosing = true;
+}
+function svgStartTagInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	adjustTokenSVGAttrs(token);
+	adjustTokenXMLAttrs(token);
+	if (token.selfClosing) p._appendElement(token, NS.SVG);
+	else p._insertElement(token, NS.SVG);
+	token.ackSelfClosing = true;
+}
+function genericStartTagInBody(p, token) {
+	p._reconstructActiveFormattingElements();
+	p._insertElement(token, NS.HTML);
+}
+function startTagInBody(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.I:
+		case TAG_ID.S:
+		case TAG_ID.B:
+		case TAG_ID.U:
+		case TAG_ID.EM:
+		case TAG_ID.TT:
+		case TAG_ID.BIG:
+		case TAG_ID.CODE:
+		case TAG_ID.FONT:
+		case TAG_ID.SMALL:
+		case TAG_ID.STRIKE:
+		case TAG_ID.STRONG:
+			bStartTagInBody(p, token);
+			break;
+		case TAG_ID.A:
+			aStartTagInBody(p, token);
+			break;
+		case TAG_ID.H1:
+		case TAG_ID.H2:
+		case TAG_ID.H3:
+		case TAG_ID.H4:
+		case TAG_ID.H5:
+		case TAG_ID.H6:
+			numberedHeaderStartTagInBody(p, token);
+			break;
+		case TAG_ID.P:
+		case TAG_ID.DL:
+		case TAG_ID.OL:
+		case TAG_ID.UL:
+		case TAG_ID.DIV:
+		case TAG_ID.DIR:
+		case TAG_ID.NAV:
+		case TAG_ID.MAIN:
+		case TAG_ID.MENU:
+		case TAG_ID.ASIDE:
+		case TAG_ID.CENTER:
+		case TAG_ID.FIGURE:
+		case TAG_ID.FOOTER:
+		case TAG_ID.HEADER:
+		case TAG_ID.HGROUP:
+		case TAG_ID.DIALOG:
+		case TAG_ID.DETAILS:
+		case TAG_ID.ADDRESS:
+		case TAG_ID.ARTICLE:
+		case TAG_ID.SEARCH:
+		case TAG_ID.SECTION:
+		case TAG_ID.SUMMARY:
+		case TAG_ID.FIELDSET:
+		case TAG_ID.BLOCKQUOTE:
+		case TAG_ID.FIGCAPTION:
+			addressStartTagInBody(p, token);
+			break;
+		case TAG_ID.LI:
+		case TAG_ID.DD:
+		case TAG_ID.DT:
+			listItemStartTagInBody(p, token);
+			break;
+		case TAG_ID.BR:
+		case TAG_ID.IMG:
+		case TAG_ID.WBR:
+		case TAG_ID.AREA:
+		case TAG_ID.EMBED:
+		case TAG_ID.KEYGEN:
+			areaStartTagInBody(p, token);
+			break;
+		case TAG_ID.HR:
+			hrStartTagInBody(p, token);
+			break;
+		case TAG_ID.RB:
+		case TAG_ID.RTC:
+			rbStartTagInBody(p, token);
+			break;
+		case TAG_ID.RT:
+		case TAG_ID.RP:
+			rtStartTagInBody(p, token);
+			break;
+		case TAG_ID.PRE:
+		case TAG_ID.LISTING:
+			preStartTagInBody(p, token);
+			break;
+		case TAG_ID.XMP:
+			xmpStartTagInBody(p, token);
+			break;
+		case TAG_ID.SVG:
+			svgStartTagInBody(p, token);
+			break;
+		case TAG_ID.HTML:
+			htmlStartTagInBody(p, token);
+			break;
+		case TAG_ID.BASE:
+		case TAG_ID.LINK:
+		case TAG_ID.META:
+		case TAG_ID.STYLE:
+		case TAG_ID.TITLE:
+		case TAG_ID.SCRIPT:
+		case TAG_ID.BGSOUND:
+		case TAG_ID.BASEFONT:
+		case TAG_ID.TEMPLATE:
+			startTagInHead(p, token);
+			break;
+		case TAG_ID.BODY:
+			bodyStartTagInBody(p, token);
+			break;
+		case TAG_ID.FORM:
+			formStartTagInBody(p, token);
+			break;
+		case TAG_ID.NOBR:
+			nobrStartTagInBody(p, token);
+			break;
+		case TAG_ID.MATH:
+			mathStartTagInBody(p, token);
+			break;
+		case TAG_ID.TABLE:
+			tableStartTagInBody(p, token);
+			break;
+		case TAG_ID.INPUT:
+			inputStartTagInBody(p, token);
+			break;
+		case TAG_ID.PARAM:
+		case TAG_ID.TRACK:
+		case TAG_ID.SOURCE:
+			paramStartTagInBody(p, token);
+			break;
+		case TAG_ID.IMAGE:
+			imageStartTagInBody(p, token);
+			break;
+		case TAG_ID.BUTTON:
+			buttonStartTagInBody(p, token);
+			break;
+		case TAG_ID.APPLET:
+		case TAG_ID.OBJECT:
+		case TAG_ID.MARQUEE:
+			appletStartTagInBody(p, token);
+			break;
+		case TAG_ID.IFRAME:
+			iframeStartTagInBody(p, token);
+			break;
+		case TAG_ID.SELECT:
+			selectStartTagInBody(p, token);
+			break;
+		case TAG_ID.OPTION:
+		case TAG_ID.OPTGROUP:
+			optgroupStartTagInBody(p, token);
+			break;
+		case TAG_ID.NOEMBED:
+		case TAG_ID.NOFRAMES:
+			rawTextStartTagInBody(p, token);
+			break;
+		case TAG_ID.FRAMESET:
+			framesetStartTagInBody(p, token);
+			break;
+		case TAG_ID.TEXTAREA:
+			textareaStartTagInBody(p, token);
+			break;
+		case TAG_ID.NOSCRIPT:
+			if (p.options.scriptingEnabled) rawTextStartTagInBody(p, token);
+			else genericStartTagInBody(p, token);
+			break;
+		case TAG_ID.PLAINTEXT:
+			plaintextStartTagInBody(p, token);
+			break;
+		case TAG_ID.COL:
+		case TAG_ID.TH:
+		case TAG_ID.TD:
+		case TAG_ID.TR:
+		case TAG_ID.HEAD:
+		case TAG_ID.FRAME:
+		case TAG_ID.TBODY:
+		case TAG_ID.TFOOT:
+		case TAG_ID.THEAD:
+		case TAG_ID.CAPTION:
+		case TAG_ID.COLGROUP: break;
+		default: genericStartTagInBody(p, token);
+	}
+}
+function bodyEndTagInBody(p, token) {
+	if (p.openElements.hasInScope(TAG_ID.BODY)) {
+		p.insertionMode = InsertionMode.AFTER_BODY;
+		if (p.options.sourceCodeLocationInfo) {
+			const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
+			if (bodyElement) p._setEndLocation(bodyElement, token);
+		}
+	}
+}
+function htmlEndTagInBody(p, token) {
+	if (p.openElements.hasInScope(TAG_ID.BODY)) {
+		p.insertionMode = InsertionMode.AFTER_BODY;
+		endTagAfterBody(p, token);
+	}
+}
+function addressEndTagInBody(p, token) {
+	const tn = token.tagID;
+	if (p.openElements.hasInScope(tn)) {
+		p.openElements.generateImpliedEndTags();
+		p.openElements.popUntilTagNamePopped(tn);
+	}
+}
+function formEndTagInBody(p) {
+	const inTemplate = p.openElements.tmplCount > 0;
+	const { formElement } = p;
+	if (!inTemplate) p.formElement = null;
+	if ((formElement || inTemplate) && p.openElements.hasInScope(TAG_ID.FORM)) {
+		p.openElements.generateImpliedEndTags();
+		if (inTemplate) p.openElements.popUntilTagNamePopped(TAG_ID.FORM);
+		else if (formElement) p.openElements.remove(formElement);
+	}
+}
+function pEndTagInBody(p) {
+	if (!p.openElements.hasInButtonScope(TAG_ID.P)) p._insertFakeElement(TAG_NAMES.P, TAG_ID.P);
+	p._closePElement();
+}
+function liEndTagInBody(p) {
+	if (p.openElements.hasInListItemScope(TAG_ID.LI)) {
+		p.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.LI);
+		p.openElements.popUntilTagNamePopped(TAG_ID.LI);
+	}
+}
+function ddEndTagInBody(p, token) {
+	const tn = token.tagID;
+	if (p.openElements.hasInScope(tn)) {
+		p.openElements.generateImpliedEndTagsWithExclusion(tn);
+		p.openElements.popUntilTagNamePopped(tn);
+	}
+}
+function numberedHeaderEndTagInBody(p) {
+	if (p.openElements.hasNumberedHeaderInScope()) {
+		p.openElements.generateImpliedEndTags();
+		p.openElements.popUntilNumberedHeaderPopped();
+	}
+}
+function appletEndTagInBody(p, token) {
+	const tn = token.tagID;
+	if (p.openElements.hasInScope(tn)) {
+		p.openElements.generateImpliedEndTags();
+		p.openElements.popUntilTagNamePopped(tn);
+		p.activeFormattingElements.clearToLastMarker();
+	}
+}
+function brEndTagInBody(p) {
+	p._reconstructActiveFormattingElements();
+	p._insertFakeElement(TAG_NAMES.BR, TAG_ID.BR);
+	p.openElements.pop();
+	p.framesetOk = false;
+}
+function genericEndTagInBody(p, token) {
+	const tn = token.tagName;
+	const tid = token.tagID;
+	for (let i = p.openElements.stackTop; i > 0; i--) {
+		const element = p.openElements.items[i];
+		const elementId = p.openElements.tagIDs[i];
+		if (tid === elementId && (tid !== TAG_ID.UNKNOWN || p.treeAdapter.getTagName(element) === tn)) {
+			p.openElements.generateImpliedEndTagsWithExclusion(tid);
+			if (p.openElements.stackTop >= i) p.openElements.shortenToLength(i);
+			break;
+		}
+		if (p._isSpecialElement(element, elementId)) break;
+	}
+}
+function endTagInBody(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.A:
+		case TAG_ID.B:
+		case TAG_ID.I:
+		case TAG_ID.S:
+		case TAG_ID.U:
+		case TAG_ID.EM:
+		case TAG_ID.TT:
+		case TAG_ID.BIG:
+		case TAG_ID.CODE:
+		case TAG_ID.FONT:
+		case TAG_ID.NOBR:
+		case TAG_ID.SMALL:
+		case TAG_ID.STRIKE:
+		case TAG_ID.STRONG:
+			callAdoptionAgency(p, token);
+			break;
+		case TAG_ID.P:
+			pEndTagInBody(p);
+			break;
+		case TAG_ID.DL:
+		case TAG_ID.UL:
+		case TAG_ID.OL:
+		case TAG_ID.DIR:
+		case TAG_ID.DIV:
+		case TAG_ID.NAV:
+		case TAG_ID.PRE:
+		case TAG_ID.MAIN:
+		case TAG_ID.MENU:
+		case TAG_ID.ASIDE:
+		case TAG_ID.BUTTON:
+		case TAG_ID.CENTER:
+		case TAG_ID.FIGURE:
+		case TAG_ID.FOOTER:
+		case TAG_ID.HEADER:
+		case TAG_ID.HGROUP:
+		case TAG_ID.DIALOG:
+		case TAG_ID.ADDRESS:
+		case TAG_ID.ARTICLE:
+		case TAG_ID.DETAILS:
+		case TAG_ID.SEARCH:
+		case TAG_ID.SECTION:
+		case TAG_ID.SUMMARY:
+		case TAG_ID.LISTING:
+		case TAG_ID.FIELDSET:
+		case TAG_ID.BLOCKQUOTE:
+		case TAG_ID.FIGCAPTION:
+			addressEndTagInBody(p, token);
+			break;
+		case TAG_ID.LI:
+			liEndTagInBody(p);
+			break;
+		case TAG_ID.DD:
+		case TAG_ID.DT:
+			ddEndTagInBody(p, token);
+			break;
+		case TAG_ID.H1:
+		case TAG_ID.H2:
+		case TAG_ID.H3:
+		case TAG_ID.H4:
+		case TAG_ID.H5:
+		case TAG_ID.H6:
+			numberedHeaderEndTagInBody(p);
+			break;
+		case TAG_ID.BR:
+			brEndTagInBody(p);
+			break;
+		case TAG_ID.BODY:
+			bodyEndTagInBody(p, token);
+			break;
+		case TAG_ID.HTML:
+			htmlEndTagInBody(p, token);
+			break;
+		case TAG_ID.FORM:
+			formEndTagInBody(p);
+			break;
+		case TAG_ID.APPLET:
+		case TAG_ID.OBJECT:
+		case TAG_ID.MARQUEE:
+			appletEndTagInBody(p, token);
+			break;
+		case TAG_ID.TEMPLATE:
+			templateEndTagInHead(p, token);
+			break;
+		default: genericEndTagInBody(p, token);
+	}
+}
+function eofInBody(p, token) {
+	if (p.tmplInsertionModeStack.length > 0) eofInTemplate(p, token);
+	else stopParsing(p, token);
+}
+function endTagInText(p, token) {
+	var _a;
+	if (token.tagID === TAG_ID.SCRIPT) (_a = p.scriptHandler) === null || _a === void 0 || _a.call(p, p.openElements.current);
+	p.openElements.pop();
+	p.insertionMode = p.originalInsertionMode;
+}
+function eofInText(p, token) {
+	p._err(token, ERR.eofInElementThatCanContainOnlyText);
+	p.openElements.pop();
+	p.insertionMode = p.originalInsertionMode;
+	p.onEof(token);
+}
+function characterInTable(p, token) {
+	if (p.openElements.currentTagId !== void 0 && TABLE_STRUCTURE_TAGS.has(p.openElements.currentTagId)) {
+		p.pendingCharacterTokens.length = 0;
+		p.hasNonWhitespacePendingCharacterToken = false;
+		p.originalInsertionMode = p.insertionMode;
+		p.insertionMode = InsertionMode.IN_TABLE_TEXT;
+		switch (token.type) {
+			case TokenType.CHARACTER:
+				characterInTableText(p, token);
+				break;
+			case TokenType.WHITESPACE_CHARACTER:
+				whitespaceCharacterInTableText(p, token);
+				break;
+		}
+	} else tokenInTable(p, token);
+}
+function captionStartTagInTable(p, token) {
+	p.openElements.clearBackToTableContext();
+	p.activeFormattingElements.insertMarker();
+	p._insertElement(token, NS.HTML);
+	p.insertionMode = InsertionMode.IN_CAPTION;
+}
+function colgroupStartTagInTable(p, token) {
+	p.openElements.clearBackToTableContext();
+	p._insertElement(token, NS.HTML);
+	p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
+}
+function colStartTagInTable(p, token) {
+	p.openElements.clearBackToTableContext();
+	p._insertFakeElement(TAG_NAMES.COLGROUP, TAG_ID.COLGROUP);
+	p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
+	startTagInColumnGroup(p, token);
+}
+function tbodyStartTagInTable(p, token) {
+	p.openElements.clearBackToTableContext();
+	p._insertElement(token, NS.HTML);
+	p.insertionMode = InsertionMode.IN_TABLE_BODY;
+}
+function tdStartTagInTable(p, token) {
+	p.openElements.clearBackToTableContext();
+	p._insertFakeElement(TAG_NAMES.TBODY, TAG_ID.TBODY);
+	p.insertionMode = InsertionMode.IN_TABLE_BODY;
+	startTagInTableBody(p, token);
+}
+function tableStartTagInTable(p, token) {
+	if (p.openElements.hasInTableScope(TAG_ID.TABLE)) {
+		p.openElements.popUntilTagNamePopped(TAG_ID.TABLE);
+		p._resetInsertionMode();
+		p._processStartTag(token);
+	}
+}
+function inputStartTagInTable(p, token) {
+	if (isHiddenInput(token)) p._appendElement(token, NS.HTML);
+	else tokenInTable(p, token);
+	token.ackSelfClosing = true;
+}
+function formStartTagInTable(p, token) {
+	if (!p.formElement && p.openElements.tmplCount === 0) {
+		p._insertElement(token, NS.HTML);
+		p.formElement = p.openElements.current;
+		p.openElements.pop();
+	}
+}
+function startTagInTable(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.TD:
+		case TAG_ID.TH:
+		case TAG_ID.TR:
+			tdStartTagInTable(p, token);
+			break;
+		case TAG_ID.STYLE:
+		case TAG_ID.SCRIPT:
+		case TAG_ID.TEMPLATE:
+			startTagInHead(p, token);
+			break;
+		case TAG_ID.COL:
+			colStartTagInTable(p, token);
+			break;
+		case TAG_ID.FORM:
+			formStartTagInTable(p, token);
+			break;
+		case TAG_ID.TABLE:
+			tableStartTagInTable(p, token);
+			break;
+		case TAG_ID.TBODY:
+		case TAG_ID.TFOOT:
+		case TAG_ID.THEAD:
+			tbodyStartTagInTable(p, token);
+			break;
+		case TAG_ID.INPUT:
+			inputStartTagInTable(p, token);
+			break;
+		case TAG_ID.CAPTION:
+			captionStartTagInTable(p, token);
+			break;
+		case TAG_ID.COLGROUP:
+			colgroupStartTagInTable(p, token);
+			break;
+		default: tokenInTable(p, token);
+	}
+}
+function endTagInTable(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.TABLE:
+			if (p.openElements.hasInTableScope(TAG_ID.TABLE)) {
+				p.openElements.popUntilTagNamePopped(TAG_ID.TABLE);
+				p._resetInsertionMode();
+			}
+			break;
+		case TAG_ID.TEMPLATE:
+			templateEndTagInHead(p, token);
+			break;
+		case TAG_ID.BODY:
+		case TAG_ID.CAPTION:
+		case TAG_ID.COL:
+		case TAG_ID.COLGROUP:
+		case TAG_ID.HTML:
+		case TAG_ID.TBODY:
+		case TAG_ID.TD:
+		case TAG_ID.TFOOT:
+		case TAG_ID.TH:
+		case TAG_ID.THEAD:
+		case TAG_ID.TR: break;
+		default: tokenInTable(p, token);
+	}
+}
+function tokenInTable(p, token) {
+	const savedFosterParentingState = p.fosterParentingEnabled;
+	p.fosterParentingEnabled = true;
+	modeInBody(p, token);
+	p.fosterParentingEnabled = savedFosterParentingState;
+}
+function whitespaceCharacterInTableText(p, token) {
+	p.pendingCharacterTokens.push(token);
+}
+function characterInTableText(p, token) {
+	p.pendingCharacterTokens.push(token);
+	p.hasNonWhitespacePendingCharacterToken = true;
+}
+function tokenInTableText(p, token) {
+	let i = 0;
+	if (p.hasNonWhitespacePendingCharacterToken) for (; i < p.pendingCharacterTokens.length; i++) tokenInTable(p, p.pendingCharacterTokens[i]);
+	else for (; i < p.pendingCharacterTokens.length; i++) p._insertCharacters(p.pendingCharacterTokens[i]);
+	p.insertionMode = p.originalInsertionMode;
+	p._processToken(token);
+}
+const TABLE_VOID_ELEMENTS = new Set([
+	TAG_ID.CAPTION,
+	TAG_ID.COL,
+	TAG_ID.COLGROUP,
+	TAG_ID.TBODY,
+	TAG_ID.TD,
+	TAG_ID.TFOOT,
+	TAG_ID.TH,
+	TAG_ID.THEAD,
+	TAG_ID.TR
+]);
+function startTagInCaption(p, token) {
+	if (TABLE_VOID_ELEMENTS.has(token.tagID)) {
+		if (p.openElements.hasInTableScope(TAG_ID.CAPTION)) {
+			p.openElements.generateImpliedEndTags();
+			p.openElements.popUntilTagNamePopped(TAG_ID.CAPTION);
+			p.activeFormattingElements.clearToLastMarker();
+			p.insertionMode = InsertionMode.IN_TABLE;
+			startTagInTable(p, token);
+		}
+	} else startTagInBody(p, token);
+}
+function endTagInCaption(p, token) {
+	const tn = token.tagID;
+	switch (tn) {
+		case TAG_ID.CAPTION:
+		case TAG_ID.TABLE:
+			if (p.openElements.hasInTableScope(TAG_ID.CAPTION)) {
+				p.openElements.generateImpliedEndTags();
+				p.openElements.popUntilTagNamePopped(TAG_ID.CAPTION);
+				p.activeFormattingElements.clearToLastMarker();
+				p.insertionMode = InsertionMode.IN_TABLE;
+				if (tn === TAG_ID.TABLE) endTagInTable(p, token);
+			}
+			break;
+		case TAG_ID.BODY:
+		case TAG_ID.COL:
+		case TAG_ID.COLGROUP:
+		case TAG_ID.HTML:
+		case TAG_ID.TBODY:
+		case TAG_ID.TD:
+		case TAG_ID.TFOOT:
+		case TAG_ID.TH:
+		case TAG_ID.THEAD:
+		case TAG_ID.TR: break;
+		default: endTagInBody(p, token);
+	}
+}
+function startTagInColumnGroup(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HTML:
+			startTagInBody(p, token);
+			break;
+		case TAG_ID.COL:
+			p._appendElement(token, NS.HTML);
+			token.ackSelfClosing = true;
+			break;
+		case TAG_ID.TEMPLATE:
+			startTagInHead(p, token);
+			break;
+		default: tokenInColumnGroup(p, token);
+	}
+}
+function endTagInColumnGroup(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.COLGROUP:
+			if (p.openElements.currentTagId === TAG_ID.COLGROUP) {
+				p.openElements.pop();
+				p.insertionMode = InsertionMode.IN_TABLE;
+			}
+			break;
+		case TAG_ID.TEMPLATE:
+			templateEndTagInHead(p, token);
+			break;
+		case TAG_ID.COL: break;
+		default: tokenInColumnGroup(p, token);
+	}
+}
+function tokenInColumnGroup(p, token) {
+	if (p.openElements.currentTagId === TAG_ID.COLGROUP) {
+		p.openElements.pop();
+		p.insertionMode = InsertionMode.IN_TABLE;
+		p._processToken(token);
+	}
+}
+function startTagInTableBody(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.TR:
+			p.openElements.clearBackToTableBodyContext();
+			p._insertElement(token, NS.HTML);
+			p.insertionMode = InsertionMode.IN_ROW;
+			break;
+		case TAG_ID.TH:
+		case TAG_ID.TD:
+			p.openElements.clearBackToTableBodyContext();
+			p._insertFakeElement(TAG_NAMES.TR, TAG_ID.TR);
+			p.insertionMode = InsertionMode.IN_ROW;
+			startTagInRow(p, token);
+			break;
+		case TAG_ID.CAPTION:
+		case TAG_ID.COL:
+		case TAG_ID.COLGROUP:
+		case TAG_ID.TBODY:
+		case TAG_ID.TFOOT:
+		case TAG_ID.THEAD:
+			if (p.openElements.hasTableBodyContextInTableScope()) {
+				p.openElements.clearBackToTableBodyContext();
+				p.openElements.pop();
+				p.insertionMode = InsertionMode.IN_TABLE;
+				startTagInTable(p, token);
+			}
+			break;
+		default: startTagInTable(p, token);
+	}
+}
+function endTagInTableBody(p, token) {
+	const tn = token.tagID;
+	switch (token.tagID) {
+		case TAG_ID.TBODY:
+		case TAG_ID.TFOOT:
+		case TAG_ID.THEAD:
+			if (p.openElements.hasInTableScope(tn)) {
+				p.openElements.clearBackToTableBodyContext();
+				p.openElements.pop();
+				p.insertionMode = InsertionMode.IN_TABLE;
+			}
+			break;
+		case TAG_ID.TABLE:
+			if (p.openElements.hasTableBodyContextInTableScope()) {
+				p.openElements.clearBackToTableBodyContext();
+				p.openElements.pop();
+				p.insertionMode = InsertionMode.IN_TABLE;
+				endTagInTable(p, token);
+			}
+			break;
+		case TAG_ID.BODY:
+		case TAG_ID.CAPTION:
+		case TAG_ID.COL:
+		case TAG_ID.COLGROUP:
+		case TAG_ID.HTML:
+		case TAG_ID.TD:
+		case TAG_ID.TH:
+		case TAG_ID.TR: break;
+		default: endTagInTable(p, token);
+	}
+}
+function startTagInRow(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.TH:
+		case TAG_ID.TD:
+			p.openElements.clearBackToTableRowContext();
+			p._insertElement(token, NS.HTML);
+			p.insertionMode = InsertionMode.IN_CELL;
+			p.activeFormattingElements.insertMarker();
+			break;
+		case TAG_ID.CAPTION:
+		case TAG_ID.COL:
+		case TAG_ID.COLGROUP:
+		case TAG_ID.TBODY:
+		case TAG_ID.TFOOT:
+		case TAG_ID.THEAD:
+		case TAG_ID.TR:
+			if (p.openElements.hasInTableScope(TAG_ID.TR)) {
+				p.openElements.clearBackToTableRowContext();
+				p.openElements.pop();
+				p.insertionMode = InsertionMode.IN_TABLE_BODY;
+				startTagInTableBody(p, token);
+			}
+			break;
+		default: startTagInTable(p, token);
+	}
+}
+function endTagInRow(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.TR:
+			if (p.openElements.hasInTableScope(TAG_ID.TR)) {
+				p.openElements.clearBackToTableRowContext();
+				p.openElements.pop();
+				p.insertionMode = InsertionMode.IN_TABLE_BODY;
+			}
+			break;
+		case TAG_ID.TABLE:
+			if (p.openElements.hasInTableScope(TAG_ID.TR)) {
+				p.openElements.clearBackToTableRowContext();
+				p.openElements.pop();
+				p.insertionMode = InsertionMode.IN_TABLE_BODY;
+				endTagInTableBody(p, token);
+			}
+			break;
+		case TAG_ID.TBODY:
+		case TAG_ID.TFOOT:
+		case TAG_ID.THEAD:
+			if (p.openElements.hasInTableScope(token.tagID) || p.openElements.hasInTableScope(TAG_ID.TR)) {
+				p.openElements.clearBackToTableRowContext();
+				p.openElements.pop();
+				p.insertionMode = InsertionMode.IN_TABLE_BODY;
+				endTagInTableBody(p, token);
+			}
+			break;
+		case TAG_ID.BODY:
+		case TAG_ID.CAPTION:
+		case TAG_ID.COL:
+		case TAG_ID.COLGROUP:
+		case TAG_ID.HTML:
+		case TAG_ID.TD:
+		case TAG_ID.TH: break;
+		default: endTagInTable(p, token);
+	}
+}
+function startTagInCell(p, token) {
+	if (TABLE_VOID_ELEMENTS.has(token.tagID)) {
+		if (p.openElements.hasInTableScope(TAG_ID.TD) || p.openElements.hasInTableScope(TAG_ID.TH)) {
+			p._closeTableCell();
+			startTagInRow(p, token);
+		}
+	} else startTagInBody(p, token);
+}
+function endTagInCell(p, token) {
+	const tn = token.tagID;
+	switch (tn) {
+		case TAG_ID.TD:
+		case TAG_ID.TH:
+			if (p.openElements.hasInTableScope(tn)) {
+				p.openElements.generateImpliedEndTags();
+				p.openElements.popUntilTagNamePopped(tn);
+				p.activeFormattingElements.clearToLastMarker();
+				p.insertionMode = InsertionMode.IN_ROW;
+			}
+			break;
+		case TAG_ID.TABLE:
+		case TAG_ID.TBODY:
+		case TAG_ID.TFOOT:
+		case TAG_ID.THEAD:
+		case TAG_ID.TR:
+			if (p.openElements.hasInTableScope(tn)) {
+				p._closeTableCell();
+				endTagInRow(p, token);
+			}
+			break;
+		case TAG_ID.BODY:
+		case TAG_ID.CAPTION:
+		case TAG_ID.COL:
+		case TAG_ID.COLGROUP:
+		case TAG_ID.HTML: break;
+		default: endTagInBody(p, token);
+	}
+}
+function startTagInSelect(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HTML:
+			startTagInBody(p, token);
+			break;
+		case TAG_ID.OPTION:
+			if (p.openElements.currentTagId === TAG_ID.OPTION) p.openElements.pop();
+			p._insertElement(token, NS.HTML);
+			break;
+		case TAG_ID.OPTGROUP:
+			if (p.openElements.currentTagId === TAG_ID.OPTION) p.openElements.pop();
+			if (p.openElements.currentTagId === TAG_ID.OPTGROUP) p.openElements.pop();
+			p._insertElement(token, NS.HTML);
+			break;
+		case TAG_ID.HR:
+			if (p.openElements.currentTagId === TAG_ID.OPTION) p.openElements.pop();
+			if (p.openElements.currentTagId === TAG_ID.OPTGROUP) p.openElements.pop();
+			p._appendElement(token, NS.HTML);
+			token.ackSelfClosing = true;
+			break;
+		case TAG_ID.INPUT:
+		case TAG_ID.KEYGEN:
+		case TAG_ID.TEXTAREA:
+		case TAG_ID.SELECT:
+			if (p.openElements.hasInSelectScope(TAG_ID.SELECT)) {
+				p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
+				p._resetInsertionMode();
+				if (token.tagID !== TAG_ID.SELECT) p._processStartTag(token);
+			}
+			break;
+		case TAG_ID.SCRIPT:
+		case TAG_ID.TEMPLATE:
+			startTagInHead(p, token);
+			break;
+		default:
+	}
+}
+function endTagInSelect(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.OPTGROUP:
+			if (p.openElements.stackTop > 0 && p.openElements.currentTagId === TAG_ID.OPTION && p.openElements.tagIDs[p.openElements.stackTop - 1] === TAG_ID.OPTGROUP) p.openElements.pop();
+			if (p.openElements.currentTagId === TAG_ID.OPTGROUP) p.openElements.pop();
+			break;
+		case TAG_ID.OPTION:
+			if (p.openElements.currentTagId === TAG_ID.OPTION) p.openElements.pop();
+			break;
+		case TAG_ID.SELECT:
+			if (p.openElements.hasInSelectScope(TAG_ID.SELECT)) {
+				p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
+				p._resetInsertionMode();
+			}
+			break;
+		case TAG_ID.TEMPLATE:
+			templateEndTagInHead(p, token);
+			break;
+		default:
+	}
+}
+function startTagInSelectInTable(p, token) {
+	const tn = token.tagID;
+	if (tn === TAG_ID.CAPTION || tn === TAG_ID.TABLE || tn === TAG_ID.TBODY || tn === TAG_ID.TFOOT || tn === TAG_ID.THEAD || tn === TAG_ID.TR || tn === TAG_ID.TD || tn === TAG_ID.TH) {
+		p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
+		p._resetInsertionMode();
+		p._processStartTag(token);
+	} else startTagInSelect(p, token);
+}
+function endTagInSelectInTable(p, token) {
+	const tn = token.tagID;
+	if (tn === TAG_ID.CAPTION || tn === TAG_ID.TABLE || tn === TAG_ID.TBODY || tn === TAG_ID.TFOOT || tn === TAG_ID.THEAD || tn === TAG_ID.TR || tn === TAG_ID.TD || tn === TAG_ID.TH) {
+		if (p.openElements.hasInTableScope(tn)) {
+			p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
+			p._resetInsertionMode();
+			p.onEndTag(token);
+		}
+	} else endTagInSelect(p, token);
+}
+function startTagInTemplate(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.BASE:
+		case TAG_ID.BASEFONT:
+		case TAG_ID.BGSOUND:
+		case TAG_ID.LINK:
+		case TAG_ID.META:
+		case TAG_ID.NOFRAMES:
+		case TAG_ID.SCRIPT:
+		case TAG_ID.STYLE:
+		case TAG_ID.TEMPLATE:
+		case TAG_ID.TITLE:
+			startTagInHead(p, token);
+			break;
+		case TAG_ID.CAPTION:
+		case TAG_ID.COLGROUP:
+		case TAG_ID.TBODY:
+		case TAG_ID.TFOOT:
+		case TAG_ID.THEAD:
+			p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE;
+			p.insertionMode = InsertionMode.IN_TABLE;
+			startTagInTable(p, token);
+			break;
+		case TAG_ID.COL:
+			p.tmplInsertionModeStack[0] = InsertionMode.IN_COLUMN_GROUP;
+			p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
+			startTagInColumnGroup(p, token);
+			break;
+		case TAG_ID.TR:
+			p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE_BODY;
+			p.insertionMode = InsertionMode.IN_TABLE_BODY;
+			startTagInTableBody(p, token);
+			break;
+		case TAG_ID.TD:
+		case TAG_ID.TH:
+			p.tmplInsertionModeStack[0] = InsertionMode.IN_ROW;
+			p.insertionMode = InsertionMode.IN_ROW;
+			startTagInRow(p, token);
+			break;
+		default:
+			p.tmplInsertionModeStack[0] = InsertionMode.IN_BODY;
+			p.insertionMode = InsertionMode.IN_BODY;
+			startTagInBody(p, token);
+	}
+}
+function endTagInTemplate(p, token) {
+	if (token.tagID === TAG_ID.TEMPLATE) templateEndTagInHead(p, token);
+}
+function eofInTemplate(p, token) {
+	if (p.openElements.tmplCount > 0) {
+		p.openElements.popUntilTagNamePopped(TAG_ID.TEMPLATE);
+		p.activeFormattingElements.clearToLastMarker();
+		p.tmplInsertionModeStack.shift();
+		p._resetInsertionMode();
+		p.onEof(token);
+	} else stopParsing(p, token);
+}
+function startTagAfterBody(p, token) {
+	if (token.tagID === TAG_ID.HTML) startTagInBody(p, token);
+	else tokenAfterBody(p, token);
+}
+function endTagAfterBody(p, token) {
+	var _a;
+	if (token.tagID === TAG_ID.HTML) {
+		if (!p.fragmentContext) p.insertionMode = InsertionMode.AFTER_AFTER_BODY;
+		if (p.options.sourceCodeLocationInfo && p.openElements.tagIDs[0] === TAG_ID.HTML) {
+			p._setEndLocation(p.openElements.items[0], token);
+			const bodyElement = p.openElements.items[1];
+			if (bodyElement && !((_a = p.treeAdapter.getNodeSourceCodeLocation(bodyElement)) === null || _a === void 0 ? void 0 : _a.endTag)) p._setEndLocation(bodyElement, token);
+		}
+	} else tokenAfterBody(p, token);
+}
+function tokenAfterBody(p, token) {
+	p.insertionMode = InsertionMode.IN_BODY;
+	modeInBody(p, token);
+}
+function startTagInFrameset(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HTML:
+			startTagInBody(p, token);
+			break;
+		case TAG_ID.FRAMESET:
+			p._insertElement(token, NS.HTML);
+			break;
+		case TAG_ID.FRAME:
+			p._appendElement(token, NS.HTML);
+			token.ackSelfClosing = true;
+			break;
+		case TAG_ID.NOFRAMES:
+			startTagInHead(p, token);
+			break;
+		default:
+	}
+}
+function endTagInFrameset(p, token) {
+	if (token.tagID === TAG_ID.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) {
+		p.openElements.pop();
+		if (!p.fragmentContext && p.openElements.currentTagId !== TAG_ID.FRAMESET) p.insertionMode = InsertionMode.AFTER_FRAMESET;
+	}
+}
+function startTagAfterFrameset(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HTML:
+			startTagInBody(p, token);
+			break;
+		case TAG_ID.NOFRAMES:
+			startTagInHead(p, token);
+			break;
+		default:
+	}
+}
+function endTagAfterFrameset(p, token) {
+	if (token.tagID === TAG_ID.HTML) p.insertionMode = InsertionMode.AFTER_AFTER_FRAMESET;
+}
+function startTagAfterAfterBody(p, token) {
+	if (token.tagID === TAG_ID.HTML) startTagInBody(p, token);
+	else tokenAfterAfterBody(p, token);
+}
+function tokenAfterAfterBody(p, token) {
+	p.insertionMode = InsertionMode.IN_BODY;
+	modeInBody(p, token);
+}
+function startTagAfterAfterFrameset(p, token) {
+	switch (token.tagID) {
+		case TAG_ID.HTML:
+			startTagInBody(p, token);
+			break;
+		case TAG_ID.NOFRAMES:
+			startTagInHead(p, token);
+			break;
+		default:
+	}
+}
+function nullCharacterInForeignContent(p, token) {
+	token.chars = "�";
+	p._insertCharacters(token);
+}
+function characterInForeignContent(p, token) {
+	p._insertCharacters(token);
+	p.framesetOk = false;
+}
+function popUntilHtmlOrIntegrationPoint(p) {
+	while (p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML && p.openElements.currentTagId !== void 0 && !p._isIntegrationPoint(p.openElements.currentTagId, p.openElements.current)) p.openElements.pop();
+}
+function startTagInForeignContent(p, token) {
+	if (causesExit(token)) {
+		popUntilHtmlOrIntegrationPoint(p);
+		p._startTagOutsideForeignContent(token);
+	} else {
+		const current = p._getAdjustedCurrentElement();
+		const currentNs = p.treeAdapter.getNamespaceURI(current);
+		if (currentNs === NS.MATHML) adjustTokenMathMLAttrs(token);
+		else if (currentNs === NS.SVG) {
+			adjustTokenSVGTagName(token);
+			adjustTokenSVGAttrs(token);
+		}
+		adjustTokenXMLAttrs(token);
+		if (token.selfClosing) p._appendElement(token, currentNs);
+		else p._insertElement(token, currentNs);
+		token.ackSelfClosing = true;
+	}
+}
+function endTagInForeignContent(p, token) {
+	if (token.tagID === TAG_ID.P || token.tagID === TAG_ID.BR) {
+		popUntilHtmlOrIntegrationPoint(p);
+		p._endTagOutsideForeignContent(token);
+		return;
+	}
+	for (let i = p.openElements.stackTop; i > 0; i--) {
+		const element = p.openElements.items[i];
+		if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) {
+			p._endTagOutsideForeignContent(token);
+			break;
+		}
+		const tagName = p.treeAdapter.getTagName(element);
+		if (tagName.toLowerCase() === token.tagName) {
+			token.tagName = tagName;
+			p.openElements.shortenToLength(i);
+			break;
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/parse5@8.0.1/node_modules/parse5/dist/index.js
+/**
+* Parses an HTML string.
+*
+* @param html Input HTML string.
+* @param options Parsing options.
+* @returns Document
+*
+* @example
+*
+* ```js
+* const parse5 = require('parse5');
+*
+* const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');
+*
+* console.log(document.childNodes[1].tagName); //> 'html'
+*```
+*/
+function parse(html, options) {
+	return Parser.parse(html, options);
+}
+//#endregion
+export { ERR as ErrorCodes, parse };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/lib.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/lib.js
new file mode 100644
index 0000000..c58bed0
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/lib.js
@@ -0,0 +1,371 @@
+import { z as __commonJSMin } from "./logger.js";
+//#region ../../node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var openParentheses = "(".charCodeAt(0);
+	var closeParentheses = ")".charCodeAt(0);
+	var singleQuote = "'".charCodeAt(0);
+	var doubleQuote = "\"".charCodeAt(0);
+	var backslash = "\\".charCodeAt(0);
+	var slash = "/".charCodeAt(0);
+	var comma = ",".charCodeAt(0);
+	var colon = ":".charCodeAt(0);
+	var star = "*".charCodeAt(0);
+	var uLower = "u".charCodeAt(0);
+	var uUpper = "U".charCodeAt(0);
+	var plus = "+".charCodeAt(0);
+	var isUnicodeRange = /^[a-f0-9?-]+$/i;
+	module.exports = function(input) {
+		var tokens = [];
+		var value = input;
+		var next, quote, prev, token, escape, escapePos, whitespacePos, parenthesesOpenPos;
+		var pos = 0;
+		var code = value.charCodeAt(pos);
+		var max = value.length;
+		var stack = [{ nodes: tokens }];
+		var balanced = 0;
+		var parent;
+		var name = "";
+		var before = "";
+		var after = "";
+		while (pos < max) if (code <= 32) {
+			next = pos;
+			do {
+				next += 1;
+				code = value.charCodeAt(next);
+			} while (code <= 32);
+			token = value.slice(pos, next);
+			prev = tokens[tokens.length - 1];
+			if (code === closeParentheses && balanced) after = token;
+			else if (prev && prev.type === "div") {
+				prev.after = token;
+				prev.sourceEndIndex += token.length;
+			} else if (code === comma || code === colon || code === slash && value.charCodeAt(next + 1) !== star && (!parent || parent && parent.type === "function" && parent.value !== "calc")) before = token;
+			else tokens.push({
+				type: "space",
+				sourceIndex: pos,
+				sourceEndIndex: next,
+				value: token
+			});
+			pos = next;
+		} else if (code === singleQuote || code === doubleQuote) {
+			next = pos;
+			quote = code === singleQuote ? "'" : "\"";
+			token = {
+				type: "string",
+				sourceIndex: pos,
+				quote
+			};
+			do {
+				escape = false;
+				next = value.indexOf(quote, next + 1);
+				if (~next) {
+					escapePos = next;
+					while (value.charCodeAt(escapePos - 1) === backslash) {
+						escapePos -= 1;
+						escape = !escape;
+					}
+				} else {
+					value += quote;
+					next = value.length - 1;
+					token.unclosed = true;
+				}
+			} while (escape);
+			token.value = value.slice(pos + 1, next);
+			token.sourceEndIndex = token.unclosed ? next : next + 1;
+			tokens.push(token);
+			pos = next + 1;
+			code = value.charCodeAt(pos);
+		} else if (code === slash && value.charCodeAt(pos + 1) === star) {
+			next = value.indexOf("*/", pos);
+			token = {
+				type: "comment",
+				sourceIndex: pos,
+				sourceEndIndex: next + 2
+			};
+			if (next === -1) {
+				token.unclosed = true;
+				next = value.length;
+				token.sourceEndIndex = next;
+			}
+			token.value = value.slice(pos + 2, next);
+			tokens.push(token);
+			pos = next + 2;
+			code = value.charCodeAt(pos);
+		} else if ((code === slash || code === star) && parent && parent.type === "function" && parent.value === "calc") {
+			token = value[pos];
+			tokens.push({
+				type: "word",
+				sourceIndex: pos - before.length,
+				sourceEndIndex: pos + token.length,
+				value: token
+			});
+			pos += 1;
+			code = value.charCodeAt(pos);
+		} else if (code === slash || code === comma || code === colon) {
+			token = value[pos];
+			tokens.push({
+				type: "div",
+				sourceIndex: pos - before.length,
+				sourceEndIndex: pos + token.length,
+				value: token,
+				before,
+				after: ""
+			});
+			before = "";
+			pos += 1;
+			code = value.charCodeAt(pos);
+		} else if (openParentheses === code) {
+			next = pos;
+			do {
+				next += 1;
+				code = value.charCodeAt(next);
+			} while (code <= 32);
+			parenthesesOpenPos = pos;
+			token = {
+				type: "function",
+				sourceIndex: pos - name.length,
+				value: name,
+				before: value.slice(parenthesesOpenPos + 1, next)
+			};
+			pos = next;
+			if (name === "url" && code !== singleQuote && code !== doubleQuote) {
+				next -= 1;
+				do {
+					escape = false;
+					next = value.indexOf(")", next + 1);
+					if (~next) {
+						escapePos = next;
+						while (value.charCodeAt(escapePos - 1) === backslash) {
+							escapePos -= 1;
+							escape = !escape;
+						}
+					} else {
+						value += ")";
+						next = value.length - 1;
+						token.unclosed = true;
+					}
+				} while (escape);
+				whitespacePos = next;
+				do {
+					whitespacePos -= 1;
+					code = value.charCodeAt(whitespacePos);
+				} while (code <= 32);
+				if (parenthesesOpenPos < whitespacePos) {
+					if (pos !== whitespacePos + 1) token.nodes = [{
+						type: "word",
+						sourceIndex: pos,
+						sourceEndIndex: whitespacePos + 1,
+						value: value.slice(pos, whitespacePos + 1)
+					}];
+					else token.nodes = [];
+					if (token.unclosed && whitespacePos + 1 !== next) {
+						token.after = "";
+						token.nodes.push({
+							type: "space",
+							sourceIndex: whitespacePos + 1,
+							sourceEndIndex: next,
+							value: value.slice(whitespacePos + 1, next)
+						});
+					} else {
+						token.after = value.slice(whitespacePos + 1, next);
+						token.sourceEndIndex = next;
+					}
+				} else {
+					token.after = "";
+					token.nodes = [];
+				}
+				pos = next + 1;
+				token.sourceEndIndex = token.unclosed ? next : pos;
+				code = value.charCodeAt(pos);
+				tokens.push(token);
+			} else {
+				balanced += 1;
+				token.after = "";
+				token.sourceEndIndex = pos + 1;
+				tokens.push(token);
+				stack.push(token);
+				tokens = token.nodes = [];
+				parent = token;
+			}
+			name = "";
+		} else if (closeParentheses === code && balanced) {
+			pos += 1;
+			code = value.charCodeAt(pos);
+			parent.after = after;
+			parent.sourceEndIndex += after.length;
+			after = "";
+			balanced -= 1;
+			stack[stack.length - 1].sourceEndIndex = pos;
+			stack.pop();
+			parent = stack[balanced];
+			tokens = parent.nodes;
+		} else {
+			next = pos;
+			do {
+				if (code === backslash) next += 1;
+				next += 1;
+				code = value.charCodeAt(next);
+			} while (next < max && !(code <= 32 || code === singleQuote || code === doubleQuote || code === comma || code === colon || code === slash || code === openParentheses || code === star && parent && parent.type === "function" && parent.value === "calc" || code === slash && parent.type === "function" && parent.value === "calc" || code === closeParentheses && balanced));
+			token = value.slice(pos, next);
+			if (openParentheses === code) name = token;
+			else if ((uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) && plus === token.charCodeAt(1) && isUnicodeRange.test(token.slice(2))) tokens.push({
+				type: "unicode-range",
+				sourceIndex: pos,
+				sourceEndIndex: next,
+				value: token
+			});
+			else tokens.push({
+				type: "word",
+				sourceIndex: pos,
+				sourceEndIndex: next,
+				value: token
+			});
+			pos = next;
+		}
+		for (pos = stack.length - 1; pos; pos -= 1) {
+			stack[pos].unclosed = true;
+			stack[pos].sourceEndIndex = value.length;
+		}
+		return stack[0].nodes;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/walk.js
+var require_walk = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function walk(nodes, cb, bubble) {
+		var i, max, node, result;
+		for (i = 0, max = nodes.length; i < max; i += 1) {
+			node = nodes[i];
+			if (!bubble) result = cb(node, i, nodes);
+			if (result !== false && node.type === "function" && Array.isArray(node.nodes)) walk(node.nodes, cb, bubble);
+			if (bubble) cb(node, i, nodes);
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/stringify.js
+var require_stringify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function stringifyNode(node, custom) {
+		var type = node.type;
+		var value = node.value;
+		var buf;
+		var customResult;
+		if (custom && (customResult = custom(node)) !== void 0) return customResult;
+		else if (type === "word" || type === "space") return value;
+		else if (type === "string") {
+			buf = node.quote || "";
+			return buf + value + (node.unclosed ? "" : buf);
+		} else if (type === "comment") return "/*" + value + (node.unclosed ? "" : "*/");
+		else if (type === "div") return (node.before || "") + value + (node.after || "");
+		else if (Array.isArray(node.nodes)) {
+			buf = stringify(node.nodes, custom);
+			if (type !== "function") return buf;
+			return value + "(" + (node.before || "") + buf + (node.after || "") + (node.unclosed ? "" : ")");
+		}
+		return value;
+	}
+	function stringify(nodes, custom) {
+		var result, i;
+		if (Array.isArray(nodes)) {
+			result = "";
+			for (i = nodes.length - 1; ~i; i -= 1) result = stringifyNode(nodes[i], custom) + result;
+			return result;
+		}
+		return stringifyNode(nodes, custom);
+	}
+	module.exports = stringify;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/unit.js
+var require_unit = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var minus = "-".charCodeAt(0);
+	var plus = "+".charCodeAt(0);
+	var dot = ".".charCodeAt(0);
+	var exp = "e".charCodeAt(0);
+	var EXP = "E".charCodeAt(0);
+	function likeNumber(value) {
+		var code = value.charCodeAt(0);
+		var nextCode;
+		if (code === plus || code === minus) {
+			nextCode = value.charCodeAt(1);
+			if (nextCode >= 48 && nextCode <= 57) return true;
+			var nextNextCode = value.charCodeAt(2);
+			if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) return true;
+			return false;
+		}
+		if (code === dot) {
+			nextCode = value.charCodeAt(1);
+			if (nextCode >= 48 && nextCode <= 57) return true;
+			return false;
+		}
+		if (code >= 48 && code <= 57) return true;
+		return false;
+	}
+	module.exports = function(value) {
+		var pos = 0;
+		var length = value.length;
+		var code;
+		var nextCode;
+		var nextNextCode;
+		if (length === 0 || !likeNumber(value)) return false;
+		code = value.charCodeAt(pos);
+		if (code === plus || code === minus) pos++;
+		while (pos < length) {
+			code = value.charCodeAt(pos);
+			if (code < 48 || code > 57) break;
+			pos += 1;
+		}
+		code = value.charCodeAt(pos);
+		nextCode = value.charCodeAt(pos + 1);
+		if (code === dot && nextCode >= 48 && nextCode <= 57) {
+			pos += 2;
+			while (pos < length) {
+				code = value.charCodeAt(pos);
+				if (code < 48 || code > 57) break;
+				pos += 1;
+			}
+		}
+		code = value.charCodeAt(pos);
+		nextCode = value.charCodeAt(pos + 1);
+		nextNextCode = value.charCodeAt(pos + 2);
+		if ((code === exp || code === EXP) && (nextCode >= 48 && nextCode <= 57 || (nextCode === plus || nextCode === minus) && nextNextCode >= 48 && nextNextCode <= 57)) {
+			pos += nextCode === plus || nextCode === minus ? 3 : 2;
+			while (pos < length) {
+				code = value.charCodeAt(pos);
+				if (code < 48 || code > 57) break;
+				pos += 1;
+			}
+		}
+		return {
+			number: value.slice(0, pos),
+			unit: value.slice(pos)
+		};
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var parse = require_parse();
+	var walk = require_walk();
+	var stringify = require_stringify();
+	function ValueParser(value) {
+		if (this instanceof ValueParser) {
+			this.nodes = parse(value);
+			return this;
+		}
+		return new ValueParser(value);
+	}
+	ValueParser.prototype.toString = function() {
+		return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+	};
+	ValueParser.prototype.walk = function(cb, bubble) {
+		walk(this.nodes, cb, bubble);
+		return this;
+	};
+	ValueParser.unit = require_unit();
+	ValueParser.walk = walk;
+	ValueParser.stringify = stringify;
+	module.exports = ValueParser;
+}));
+//#endregion
+export { require_lib as t };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/logger.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/logger.js
new file mode 100644
index 0000000..bcaf830
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/logger.js
@@ -0,0 +1,357 @@
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import path, { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import readline from "node:readline";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+//#endregion
+//#region src/node/constants.ts
+const { version } = JSON.parse(readFileSync(new URL("../../package.json", new URL("../../../src/node/constants.ts", import.meta.url))).toString());
+const ROLLUP_HOOKS = [
+	"options",
+	"buildStart",
+	"buildEnd",
+	"renderStart",
+	"renderError",
+	"renderChunk",
+	"writeBundle",
+	"generateBundle",
+	"banner",
+	"footer",
+	"augmentChunkHash",
+	"outputOptions",
+	"intro",
+	"outro",
+	"closeBundle",
+	"closeWatcher",
+	"load",
+	"moduleParsed",
+	"watchChange",
+	"resolveDynamicImport",
+	"resolveId",
+	"transform",
+	"onLog"
+];
+const VERSION = version;
+const DEFAULT_MAIN_FIELDS = [
+	"browser",
+	"module",
+	"jsnext:main",
+	"jsnext"
+];
+const DEFAULT_CLIENT_MAIN_FIELDS = Object.freeze(DEFAULT_MAIN_FIELDS);
+const DEFAULT_SERVER_MAIN_FIELDS = Object.freeze(DEFAULT_MAIN_FIELDS.filter((f) => f !== "browser"));
+/**
+* A special condition that would be replaced with production or development
+* depending on NODE_ENV env variable
+*/
+const DEV_PROD_CONDITION = `development|production`;
+const DEFAULT_CONDITIONS = [
+	"module",
+	"browser",
+	"node",
+	DEV_PROD_CONDITION
+];
+const DEFAULT_CLIENT_CONDITIONS = Object.freeze(DEFAULT_CONDITIONS.filter((c) => c !== "node"));
+const DEFAULT_SERVER_CONDITIONS = Object.freeze(DEFAULT_CONDITIONS.filter((c) => c !== "browser"));
+const DEFAULT_EXTERNAL_CONDITIONS = Object.freeze(["node", "module-sync"]);
+const DEFAULT_EXTENSIONS = [
+	".mjs",
+	".js",
+	".mts",
+	".ts",
+	".jsx",
+	".tsx",
+	".json"
+];
+/**
+* The browser versions that are included in the Baseline Widely Available on 2025-05-01.
+*
+* This value would be bumped on each major release of Vite.
+*
+* The value is generated by `pnpm generate-target` script.
+*/
+const ESBUILD_BASELINE_WIDELY_AVAILABLE_TARGET = [
+	"chrome111",
+	"edge111",
+	"firefox114",
+	"safari16.4",
+	"ios16.4"
+];
+const DEFAULT_CONFIG_FILES = [
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.ts",
+	"vite.config.cjs",
+	"vite.config.mts",
+	"vite.config.cts"
+];
+const JS_TYPES_RE = /\.(?:j|t)sx?$|\.mjs$/;
+const CSS_LANGS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const OPTIMIZABLE_ENTRY_RE = /\.[cm]?[jt]s$/;
+const SPECIAL_QUERY_RE = /[?&](?:worker|sharedworker|raw|url)\b/;
+/**
+* Prefix for resolved fs paths, since windows paths may not be valid as URLs.
+*/
+const FS_PREFIX = `/@fs/`;
+const CLIENT_PUBLIC_PATH = `/@vite/client`;
+const ENV_PUBLIC_PATH = `/@vite/env`;
+const VITE_PACKAGE_DIR = resolve(fileURLToPath(new URL("../../../src/node/constants.ts", import.meta.url)), "../../..");
+const CLIENT_ENTRY = resolve(VITE_PACKAGE_DIR, "dist/client/client.mjs");
+const ENV_ENTRY = resolve(VITE_PACKAGE_DIR, "dist/client/env.mjs");
+const CLIENT_DIR = path.dirname(CLIENT_ENTRY);
+const KNOWN_ASSET_TYPES = [
+	"apng",
+	"bmp",
+	"png",
+	"jpe?g",
+	"jfif",
+	"pjpeg",
+	"pjp",
+	"gif",
+	"svg",
+	"ico",
+	"webp",
+	"avif",
+	"cur",
+	"jxl",
+	"mp4",
+	"webm",
+	"ogg",
+	"mp3",
+	"wav",
+	"flac",
+	"aac",
+	"opus",
+	"mov",
+	"m4a",
+	"vtt",
+	"woff2?",
+	"eot",
+	"ttf",
+	"otf",
+	"webmanifest",
+	"pdf",
+	"txt"
+];
+const DEFAULT_ASSETS_RE = new RegExp(`\\.(` + KNOWN_ASSET_TYPES.join("|") + `)(\\?.*)?$`, "i");
+const DEP_VERSION_RE = /[?&](v=[\w.-]+)\b/;
+const loopbackHosts = new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"0000:0000:0000:0000:0000:0000:0000:0001"
+]);
+const wildcardHosts = new Set([
+	"0.0.0.0",
+	"::",
+	"0000:0000:0000:0000:0000:0000:0000:0000"
+]);
+const DEFAULT_DEV_PORT = 5173;
+const DEFAULT_PREVIEW_PORT = 4173;
+const DEFAULT_ASSETS_INLINE_LIMIT = 4096;
+const defaultAllowedOrigins = /^https?:\/\/(?:(?:[^:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/;
+const METADATA_FILENAME = "_metadata.json";
+const ERR_OPTIMIZE_DEPS_PROCESSING_ERROR = "ERR_OPTIMIZE_DEPS_PROCESSING_ERROR";
+const ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR = "ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR";
+//#endregion
+//#region src/node/logger.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const LogLevels = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3
+};
+let lastType;
+let lastMsg;
+let sameCount = 0;
+function clearScreen() {
+	const repeatCount = process.stdout.rows - 2;
+	const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+	console.log(blank);
+	readline.cursorTo(process.stdout, 0, 0);
+	readline.clearScreenDown(process.stdout);
+}
+let timeFormatter;
+function getTimeFormatter() {
+	timeFormatter ??= new Intl.DateTimeFormat(void 0, {
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric"
+	});
+	return timeFormatter;
+}
+function createLogger(level = "info", options = {}) {
+	if (options.customLogger) return options.customLogger;
+	const loggedErrors = /* @__PURE__ */ new WeakSet();
+	const { prefix = "[vite]", allowClearScreen = true, console = globalThis.console } = options;
+	const thresh = LogLevels[level];
+	const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
+	const clear = canClearScreen ? clearScreen : () => {};
+	function format(type, msg, options = {}) {
+		if (options.timestamp) {
+			let tag = "";
+			if (type === "info") tag = import_picocolors.default.cyan(import_picocolors.default.bold(prefix));
+			else if (type === "warn") tag = import_picocolors.default.yellow(import_picocolors.default.bold(prefix));
+			else tag = import_picocolors.default.red(import_picocolors.default.bold(prefix));
+			const environment = options.environment ? options.environment + " " : "";
+			return `${import_picocolors.default.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${environment}${msg}`;
+		} else return msg;
+	}
+	function output(type, msg, options = {}) {
+		if (thresh >= LogLevels[type]) {
+			const method = type === "info" ? "log" : type;
+			if (options.error) loggedErrors.add(options.error);
+			if (canClearScreen) if (type === lastType && msg === lastMsg) {
+				sameCount++;
+				clear();
+				console[method](format(type, msg, options), import_picocolors.default.yellow(`(x${sameCount + 1})`));
+			} else {
+				sameCount = 0;
+				lastMsg = msg;
+				lastType = type;
+				if (options.clear) clear();
+				console[method](format(type, msg, options));
+			}
+			else console[method](format(type, msg, options));
+		}
+	}
+	const warnedMessages = /* @__PURE__ */ new Set();
+	const logger = {
+		hasWarned: false,
+		info(msg, opts) {
+			output("info", msg, opts);
+		},
+		warn(msg, opts) {
+			logger.hasWarned = true;
+			output("warn", msg, opts);
+		},
+		warnOnce(msg, opts) {
+			if (warnedMessages.has(msg)) return;
+			logger.hasWarned = true;
+			output("warn", msg, opts);
+			warnedMessages.add(msg);
+		},
+		error(msg, opts) {
+			logger.hasWarned = true;
+			output("error", msg, opts);
+		},
+		clearScreen(type) {
+			if (thresh >= LogLevels[type]) clear();
+		},
+		hasErrorLogged(error) {
+			return loggedErrors.has(error);
+		}
+	};
+	return logger;
+}
+function printServerUrls(urls, optionsHost, info) {
+	const colorUrl = (url) => import_picocolors.default.cyan(url.replace(/:(\d+)\//, (_, port) => `:${import_picocolors.default.bold(port)}/`));
+	for (const url of urls.local) info(`  ${import_picocolors.default.green("➜")}  ${import_picocolors.default.bold("Local")}:   ${colorUrl(url)}`);
+	for (const url of urls.network) info(`  ${import_picocolors.default.green("➜")}  ${import_picocolors.default.bold("Network")}: ${colorUrl(url)}`);
+	if (urls.network.length === 0 && optionsHost === void 0) info(import_picocolors.default.dim(`  ${import_picocolors.default.green("➜")}  ${import_picocolors.default.bold("Network")}: use `) + import_picocolors.default.bold("--host") + import_picocolors.default.dim(" to expose"));
+}
+//#endregion
+export { OPTIMIZABLE_ENTRY_RE as A, __esmMin as B, ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR as C, JS_TYPES_RE as D, FS_PREFIX as E, defaultAllowedOrigins as F, __require as H, loopbackHosts as I, wildcardHosts as L, SPECIAL_QUERY_RE as M, VERSION as N, KNOWN_ASSET_TYPES as O, VITE_PACKAGE_DIR as P, require_picocolors as R, ENV_PUBLIC_PATH as S, ESBUILD_BASELINE_WIDELY_AVAILABLE_TARGET as T, __toCommonJS as U, __exportAll as V, __toESM as W, DEFAULT_SERVER_CONDITIONS as _, CLIENT_ENTRY as a, DEV_PROD_CONDITION as b, DEFAULT_ASSETS_INLINE_LIMIT as c, DEFAULT_CLIENT_MAIN_FIELDS as d, DEFAULT_CONFIG_FILES as f, DEFAULT_PREVIEW_PORT as g, DEFAULT_EXTERNAL_CONDITIONS as h, CLIENT_DIR as i, ROLLUP_HOOKS as j, METADATA_FILENAME as k, DEFAULT_ASSETS_RE as l, DEFAULT_EXTENSIONS as m, createLogger as n, CLIENT_PUBLIC_PATH as o, DEFAULT_DEV_PORT as p, printServerUrls as r, CSS_LANGS_RE as s, LogLevels as t, DEFAULT_CLIENT_CONDITIONS as u, DEFAULT_SERVER_MAIN_FIELDS as v, ERR_OPTIMIZE_DEPS_PROCESSING_ERROR as w, ENV_ENTRY as x, DEP_VERSION_RE as y, __commonJSMin as z };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/moduleRunnerTransport.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/moduleRunnerTransport.d.ts
new file mode 100644
index 0000000..27e8a18
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/moduleRunnerTransport.d.ts
@@ -0,0 +1,96 @@
+import { HotPayload } from "#types/hmrPayload";
+
+//#region src/shared/invokeMethods.d.ts
+interface FetchFunctionOptions {
+  cached?: boolean;
+  startOffset?: number;
+}
+type FetchResult = CachedFetchResult | ExternalFetchResult | ViteFetchResult;
+interface CachedFetchResult {
+  /**
+  * If the module is cached in the runner, this confirms
+  * it was not invalidated on the server side.
+  */
+  cache: true;
+}
+interface ExternalFetchResult {
+  /**
+  * The path to the externalized module starting with file://.
+  * By default this will be imported via a dynamic "import"
+  * instead of being transformed by Vite and loaded with the Vite runner.
+  */
+  externalize: string;
+  /**
+  * Type of the module. Used to determine if the import statement is correct.
+  * For example, if Vite needs to throw an error if a variable is not actually exported.
+  */
+  type: "module" | "commonjs" | "builtin" | "network";
+}
+interface ViteFetchResult {
+  /**
+  * Code that will be evaluated by the Vite runner.
+  * By default this will be wrapped in an async function.
+  */
+  code: string;
+  /**
+  * File path of the module on disk.
+  * This will be resolved as import.meta.url/filename.
+  * Will be `null` for virtual modules.
+  */
+  file: string | null;
+  /**
+  * Module ID in the server module graph.
+  */
+  id: string;
+  /**
+  * Module URL used in the import.
+  */
+  url: string;
+  /**
+  * Invalidate module on the client side.
+  */
+  invalidate: boolean;
+}
+type InvokeMethods = {
+  fetchModule: (id: string, importer?: string, options?: FetchFunctionOptions) => Promise<FetchResult>;
+  getBuiltins: () => Promise<Array<{
+    type: "string";
+    value: string;
+  } | {
+    type: "RegExp";
+    source: string;
+    flags: string;
+  }>>;
+};
+//#endregion
+//#region src/shared/moduleRunnerTransport.d.ts
+type ModuleRunnerTransportHandlers = {
+  onMessage: (data: HotPayload) => void;
+  onDisconnection: () => void;
+};
+/**
+* "send and connect" or "invoke" must be implemented
+*/
+interface ModuleRunnerTransport {
+  connect?(handlers: ModuleRunnerTransportHandlers): Promise<void> | void;
+  disconnect?(): Promise<void> | void;
+  send?(data: HotPayload): Promise<void> | void;
+  invoke?(data: HotPayload): Promise<{
+    result: any;
+  } | {
+    error: any;
+  }>;
+  timeout?: number;
+}
+interface NormalizedModuleRunnerTransport {
+  connect?(onMessage?: (data: HotPayload) => void): Promise<void> | void;
+  disconnect?(): Promise<void> | void;
+  send(data: HotPayload): Promise<void>;
+  invoke<T extends keyof InvokeMethods>(name: T, data: Parameters<InvokeMethods[T]>): Promise<ReturnType<Awaited<InvokeMethods[T]>>>;
+}
+declare const createWebSocketModuleRunnerTransport: (options: {
+  createConnection: () => WebSocket;
+  pingInterval?: number;
+}) => Required<Pick<ModuleRunnerTransport, "connect" | "disconnect" | "send">>;
+//#endregion
+export { ExternalFetchResult as a, ViteFetchResult as c, createWebSocketModuleRunnerTransport as i, ModuleRunnerTransportHandlers as n, FetchFunctionOptions as o, NormalizedModuleRunnerTransport as r, FetchResult as s, ModuleRunnerTransport as t };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/node.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/node.js
new file mode 100644
index 0000000..07bab15
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/node.js
@@ -0,0 +1,34994 @@
+import { A as OPTIMIZABLE_ENTRY_RE, B as __esmMin, C as ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR, D as JS_TYPES_RE, E as FS_PREFIX, F as defaultAllowedOrigins, H as __require, I as loopbackHosts, L as wildcardHosts, M as SPECIAL_QUERY_RE, N as VERSION, O as KNOWN_ASSET_TYPES, P as VITE_PACKAGE_DIR, R as require_picocolors, S as ENV_PUBLIC_PATH, T as ESBUILD_BASELINE_WIDELY_AVAILABLE_TARGET, U as __toCommonJS, V as __exportAll, W as __toESM, _ as DEFAULT_SERVER_CONDITIONS, a as CLIENT_ENTRY, b as DEV_PROD_CONDITION, c as DEFAULT_ASSETS_INLINE_LIMIT, d as DEFAULT_CLIENT_MAIN_FIELDS, f as DEFAULT_CONFIG_FILES, g as DEFAULT_PREVIEW_PORT, h as DEFAULT_EXTERNAL_CONDITIONS, i as CLIENT_DIR, j as ROLLUP_HOOKS, k as METADATA_FILENAME, l as DEFAULT_ASSETS_RE, m as DEFAULT_EXTENSIONS, n as createLogger, o as CLIENT_PUBLIC_PATH, p as DEFAULT_DEV_PORT, r as printServerUrls, s as CSS_LANGS_RE, t as LogLevels, u as DEFAULT_CLIENT_CONDITIONS, v as DEFAULT_SERVER_MAIN_FIELDS, w as ERR_OPTIMIZE_DEPS_PROCESSING_ERROR, x as ENV_ENTRY, y as DEP_VERSION_RE, z as __commonJSMin } from "./logger.js";
+import { builtinModules, createRequire } from "node:module";
+import { parseAst, parseAstAsync } from "rolldown/parseAst";
+import { esmExternalRequirePlugin, esmExternalRequirePlugin as esmExternalRequirePlugin$1 } from "rolldown/plugins";
+import { TsconfigCache, Visitor, minify, minifySync, parse, parseSync, transformSync } from "rolldown/utils";
+import * as fs$1 from "node:fs";
+import fs, { existsSync, readFileSync } from "node:fs";
+import path, { basename, dirname, extname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "node:path";
+import fsp, { constants } from "node:fs/promises";
+import { URL as URL$1, fileURLToPath, pathToFileURL } from "node:url";
+import { format, formatWithOptions, inspect, parseEnv, promisify, stripVTControlCharacters } from "node:util";
+import { performance as performance$1 } from "node:perf_hooks";
+import crypto from "node:crypto";
+import picomatch from "picomatch";
+import { VERSION as rolldownVersion, rolldown } from "rolldown";
+import os from "node:os";
+import net from "node:net";
+import childProcess, { exec, execFile, execSync } from "node:child_process";
+import { promises } from "node:dns";
+import { isatty } from "node:tty";
+import path$1, { isAbsolute as isAbsolute$1, join as join$1, posix as posix$1, resolve as resolve$1, win32 } from "path";
+import { exactRegex, makeIdFiltersToMatchWithQuery, prefixRegex, withFilter } from "rolldown/filter";
+import { dev, oxcRuntimePlugin, resolveTsconfig, scan, viteAliasPlugin, viteBuildImportAnalysisPlugin, viteDynamicImportVarsPlugin, viteImportGlobPlugin, viteJsonPlugin, viteLoadFallbackPlugin, viteManifestPlugin, viteModulePreloadPolyfillPlugin, viteReporterPlugin, viteResolvePlugin, viteTransformPlugin, viteWasmFallbackPlugin, viteWebWorkerPostPlugin } from "rolldown/experimental";
+import readline from "node:readline";
+import { MessageChannel, Worker } from "node:worker_threads";
+import isModuleSyncConditionEnabled from "#module-sync-enabled";
+import { escapePath, glob, globSync, isDynamicPattern } from "tinyglobby";
+import assert from "node:assert";
+import process$1 from "node:process";
+import v8 from "node:v8";
+import { EventEmitter } from "node:events";
+import { STATUS_CODES, createServer, get } from "node:http";
+import { createServer as createServer$1, get as get$1 } from "node:https";
+import { readdirSync, statSync } from "fs";
+import { ESModulesEvaluator, ModuleRunner, createNodeImportMeta } from "vite/module-runner";
+import { Buffer as Buffer$1 } from "node:buffer";
+import zlib from "zlib";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import * as qs from "node:querystring";
+//#region src/shared/constants.ts
+/**
+* Prefix for resolved Ids that are not valid browser import specifiers
+*/
+const VALID_ID_PREFIX = `/@id/`;
+/**
+* Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+* module ID with `\0`, a convention from the rollup ecosystem.
+* This prevents other plugins from trying to process the id (like node resolution),
+* and core features like sourcemaps can use this info to differentiate between
+* virtual modules and regular files.
+* `\0` is not a permitted char in import URLs so we have to replace them during
+* import analysis. The id will be decoded back before entering the plugins pipeline.
+* These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+* modules in the browser end up encoded as `/@id/__x00__{id}`
+*/
+const NULL_BYTE_PLACEHOLDER = `__x00__`;
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+const MODULE_RUNNER_SOURCEMAPPING_SOURCE = "//# sourceMappingSource=vite-generated";
+const ERR_OUTDATED_OPTIMIZED_DEP = "ERR_OUTDATED_OPTIMIZED_DEP";
+//#endregion
+//#region src/shared/utils.ts
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
+/**
+* Prepend `/@id/` and replace null byte so the id is URL-safe.
+* This is prepended to resolved ids that are not valid browser
+* import specifiers by the importAnalysis plugin.
+*/
+function wrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+/**
+* Undo {@link wrapId}'s `/@id/` and null byte replacements.
+*/
+function unwrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+const windowsSlashRE = /\\/g;
+function slash(p) {
+	return p.replace(windowsSlashRE, "/");
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function splitFileAndPostfix(path) {
+	const file = cleanUrl(path);
+	return {
+		file,
+		postfix: path.slice(file.length)
+	};
+}
+function withTrailingSlash(path) {
+	if (path[path.length - 1] !== "/") return `${path}/`;
+	return path;
+}
+function promiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((_resolve, _reject) => {
+			resolve = _resolve;
+			reject = _reject;
+		}),
+		resolve,
+		reject
+	};
+}
+//#endregion
+//#region src/module-runner/importMetaResolver.ts
+const customizationHookNamespace = "vite-module-runner:import-meta-resolve/v1/";
+const customizationHooksModule = `
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier.startsWith(${JSON.stringify(customizationHookNamespace)})) {
+    const data = specifier.slice(${JSON.stringify(customizationHookNamespace)}.length)
+    const [parsedSpecifier, parsedImporter] = JSON.parse(data)
+    specifier = parsedSpecifier
+    context.parentURL = parsedImporter
+  }
+  return nextResolve(specifier, context)
+}
+
+`;
+function customizationHookResolve(specifier, context, nextResolve) {
+	if (specifier.startsWith(customizationHookNamespace)) {
+		const data = specifier.slice(42);
+		const [parsedSpecifier, parsedImporter] = JSON.parse(data);
+		specifier = parsedSpecifier;
+		context.parentURL = parsedImporter;
+	}
+	return nextResolve(specifier, context);
+}
+let isHookRegistered = false;
+function createImportMetaResolver() {
+	if (isHookRegistered) return importMetaResolveWithCustomHook;
+	let module;
+	try {
+		module = typeof process !== "undefined" ? process.getBuiltinModule("node:module").Module : void 0;
+	} catch {
+		return;
+	}
+	if (!module) return;
+	if (module.registerHooks) {
+		module.registerHooks({ resolve: customizationHookResolve });
+		isHookRegistered = true;
+		return importMetaResolveWithCustomHook;
+	}
+	if (!module.register) return;
+	try {
+		const hookModuleContent = `data:text/javascript,${encodeURI(customizationHooksModule)}`;
+		module.register(hookModuleContent);
+	} catch (e) {
+		if ("code" in e && e.code === "ERR_NETWORK_IMPORT_DISALLOWED") return;
+		throw e;
+	}
+	isHookRegistered = true;
+	return importMetaResolveWithCustomHook;
+}
+function importMetaResolveWithCustomHook(specifier, importer) {
+	return import.meta.resolve(`${customizationHookNamespace}${JSON.stringify([specifier, importer])}`);
+}
+const importMetaResolveWithCustomHookString = `
+
+  (() => {
+    const resolve = 'resolve'
+    return (specifier, importer) =>
+      import.meta[resolve](
+        \`${customizationHookNamespace}\${JSON.stringify([specifier, importer])}\`,
+      )
+  })()
+
+`;
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma$1 = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars$1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar$1 = new Uint8Array(64);
+var charToInt$1 = new Uint8Array(128);
+for (let i = 0; i < chars$1.length; i++) {
+	const c = chars$1.charCodeAt(i);
+	intToChar$1[i] = c;
+	charToInt$1[c] = i;
+}
+function decodeInteger$1(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt$1[reader.next()];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) value = -2147483648 | -value;
+	return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+	let delta = num - relative;
+	delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+	do {
+		let clamped = delta & 31;
+		delta >>>= 5;
+		if (delta > 0) clamped |= 32;
+		builder.write(intToChar$1[clamped]);
+	} while (delta > 0);
+	return num;
+}
+function hasMoreVlq$1(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma$1;
+}
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { decode(buf) {
+	return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
+} } : { decode(buf) {
+	let out = "";
+	for (let i = 0; i < buf.length; i++) out += String.fromCharCode(buf[i]);
+	return out;
+} };
+var StringWriter = class {
+	constructor() {
+		this.pos = 0;
+		this.out = "";
+		this.buffer = new Uint8Array(bufLength);
+	}
+	write(v) {
+		const { buffer } = this;
+		buffer[this.pos++] = v;
+		if (this.pos === bufLength) {
+			this.out += td.decode(buffer);
+			this.pos = 0;
+		}
+	}
+	flush() {
+		const { buffer, out, pos } = this;
+		return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+	}
+};
+var StringReader$1 = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode$1(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader$1(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger$1(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq$1(reader, semi)) {
+				sourcesIndex = decodeInteger$1(reader, sourcesIndex);
+				sourceLine = decodeInteger$1(reader, sourceLine);
+				sourceColumn = decodeInteger$1(reader, sourceColumn);
+				if (hasMoreVlq$1(reader, semi)) {
+					namesIndex = decodeInteger$1(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else seg = [
+					genColumn,
+					sourcesIndex,
+					sourceLine,
+					sourceColumn
+				];
+			} else seg = [genColumn];
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort$1(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort$1(line) {
+	line.sort(sortComparator$2);
+}
+function sortComparator$2(a, b) {
+	return a[0] - b[0];
+}
+function encode$1(decoded) {
+	const writer = new StringWriter();
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	for (let i = 0; i < decoded.length; i++) {
+		const line = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		if (line.length === 0) continue;
+		let genColumn = 0;
+		for (let j = 0; j < line.length; j++) {
+			const segment = line[j];
+			if (j > 0) writer.write(comma$1);
+			genColumn = encodeInteger(writer, segment[0], genColumn);
+			if (segment.length === 1) continue;
+			sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+			sourceLine = encodeInteger(writer, segment[2], sourceLine);
+			sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+			if (segment.length === 4) continue;
+			namesIndex = encodeInteger(writer, segment[4], namesIndex);
+		}
+	}
+	return writer.flush();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+* Matches the parts of a URL:
+* 1. Scheme, including ":", guaranteed.
+* 2. User/password, including "@", optional.
+* 3. Host, guaranteed.
+* 4. Port, including ":", optional.
+* 5. Path, including "/", optional.
+* 6. Query, including "?", optional.
+* 7. Hash, including "#", optional.
+*/
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+*
+* 1. Host, optional.
+* 2. Path, which may include "/", guaranteed.
+* 3. Query, including "?", optional.
+* 4. Hash, including "#", optional.
+*/
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+	return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+	return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+	return input.startsWith("/");
+}
+function isFileUrl(input) {
+	return input.startsWith("file:");
+}
+function isRelative(input) {
+	return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+	const match = urlRegex.exec(input);
+	return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+	const match = fileRegex.exec(input);
+	const path = match[2];
+	return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+	return {
+		scheme,
+		user,
+		host,
+		port,
+		path,
+		query,
+		hash,
+		type: 7
+	};
+}
+function parseUrl(input) {
+	if (isSchemeRelativeUrl(input)) {
+		const url = parseAbsoluteUrl("http:" + input);
+		url.scheme = "";
+		url.type = 6;
+		return url;
+	}
+	if (isAbsolutePath(input)) {
+		const url = parseAbsoluteUrl("http://foo.com" + input);
+		url.scheme = "";
+		url.host = "";
+		url.type = 5;
+		return url;
+	}
+	if (isFileUrl(input)) return parseFileUrl(input);
+	if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+	const url = parseAbsoluteUrl("http://foo.com/" + input);
+	url.scheme = "";
+	url.host = "";
+	url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+	return url;
+}
+function stripPathFilename(path) {
+	if (path.endsWith("/..")) return path;
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+	normalizePath$2(base, base.type);
+	if (url.path === "/") url.path = base.path;
+	else url.path = stripPathFilename(base.path) + url.path;
+}
+/**
+* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+* "foo/.". We need to normalize to a standard representation.
+*/
+function normalizePath$2(url, type) {
+	const rel = type <= 4;
+	const pieces = url.path.split("/");
+	let pointer = 1;
+	let positive = 0;
+	let addTrailingSlash = false;
+	for (let i = 1; i < pieces.length; i++) {
+		const piece = pieces[i];
+		if (!piece) {
+			addTrailingSlash = true;
+			continue;
+		}
+		addTrailingSlash = false;
+		if (piece === ".") continue;
+		if (piece === "..") {
+			if (positive) {
+				addTrailingSlash = true;
+				positive--;
+				pointer--;
+			} else if (rel) pieces[pointer++] = piece;
+			continue;
+		}
+		pieces[pointer++] = piece;
+		positive++;
+	}
+	let path = "";
+	for (let i = 1; i < pointer; i++) path += "/" + pieces[i];
+	if (!path || addTrailingSlash && !path.endsWith("/..")) path += "/";
+	url.path = path;
+}
+/**
+* Attempts to resolve `input` URL/path relative to `base`.
+*/
+function resolve$4(input, base) {
+	if (!input && !base) return "";
+	const url = parseUrl(input);
+	let inputType = url.type;
+	if (base && inputType !== 7) {
+		const baseUrl = parseUrl(base);
+		const baseType = baseUrl.type;
+		switch (inputType) {
+			case 1: url.hash = baseUrl.hash;
+			case 2: url.query = baseUrl.query;
+			case 3:
+			case 4: mergePaths(url, baseUrl);
+			case 5:
+				url.user = baseUrl.user;
+				url.host = baseUrl.host;
+				url.port = baseUrl.port;
+			case 6: url.scheme = baseUrl.scheme;
+		}
+		if (baseType > inputType) inputType = baseType;
+	}
+	normalizePath$2(url, inputType);
+	const queryHash = url.query + url.hash;
+	switch (inputType) {
+		case 2:
+		case 3: return queryHash;
+		case 4: {
+			const path = url.path.slice(1);
+			if (!path) return queryHash || ".";
+			if (isRelative(base || input) && !isRelative(path)) return "./" + path + queryHash;
+			return path + queryHash;
+		}
+		case 5: return url.path + queryHash;
+		default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+	if (!path) return "";
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+	const from = stripFilename(mapUrl);
+	const prefix = sourceRoot ? sourceRoot + "/" : "";
+	return (source) => resolve$4(prefix + (source || ""), from);
+}
+var COLUMN$2 = 0;
+var SOURCES_INDEX$2 = 1;
+var SOURCE_LINE$2 = 2;
+var SOURCE_COLUMN$2 = 3;
+var NAMES_INDEX$2 = 4;
+function maybeSort(mappings, owned) {
+	const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+	if (unsortedIndex === mappings.length) return mappings;
+	if (!owned) mappings = mappings.slice();
+	for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) mappings[i] = sortSegments(mappings[i], owned);
+	return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+	for (let i = start; i < mappings.length; i++) if (!isSorted(mappings[i])) return i;
+	return mappings.length;
+}
+function isSorted(line) {
+	for (let j = 1; j < line.length; j++) if (line[j][COLUMN$2] < line[j - 1][COLUMN$2]) return false;
+	return true;
+}
+function sortSegments(line, owned) {
+	if (!owned) line = line.slice();
+	return line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+	return a[COLUMN$2] - b[COLUMN$2];
+}
+var found$1 = false;
+function binarySearch$1(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN$2] - needle;
+		if (cmp === 0) {
+			found$1 = true;
+			return mid;
+		}
+		if (cmp < 0) low = mid + 1;
+		else high = mid - 1;
+	}
+	found$1 = false;
+	return low - 1;
+}
+function upperBound$1(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN$2] !== needle) break;
+	return index;
+}
+function lowerBound$1(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN$2] !== needle) break;
+	return index;
+}
+function memoizedState$1() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function memoizedBinarySearch$1(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found$1 = lastIndex !== -1 && haystack[lastIndex][COLUMN$2] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
+		else high = lastIndex;
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch$1(haystack, needle, low, high);
+}
+function parse$3(map) {
+	return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO$1 = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO$1 = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var TraceMap = class {
+	constructor(map, mapUrl) {
+		const isString = typeof map === "string";
+		if (!isString && map._decodedMemo) return map;
+		const parsed = parse$3(map);
+		const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		this.version = version;
+		this.file = file;
+		this.names = names || [];
+		this.sourceRoot = sourceRoot;
+		this.sources = sources;
+		this.sourcesContent = sourcesContent;
+		this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+		const resolve = resolver(mapUrl, sourceRoot);
+		this.resolvedSources = sources.map(resolve);
+		const { mappings } = parsed;
+		if (typeof mappings === "string") {
+			this._encoded = mappings;
+			this._decoded = void 0;
+		} else if (Array.isArray(mappings)) {
+			this._encoded = void 0;
+			this._decoded = maybeSort(mappings, isString);
+		} else if (parsed.sections) throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+		else throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+		this._decodedMemo = memoizedState$1();
+		this._bySources = void 0;
+		this._bySourceMemos = void 0;
+	}
+};
+function cast$2(map) {
+	return map;
+}
+function decodedMappings$1(map) {
+	var _a;
+	return (_a = cast$2(map))._decoded || (_a._decoded = decode$1(cast$2(map)._encoded));
+}
+function traceSegment(map, line, column) {
+	const decoded = decodedMappings$1(map);
+	if (line >= decoded.length) return null;
+	const segments = decoded[line];
+	const index = traceSegmentInternal$1(segments, cast$2(map)._decodedMemo, line, column, 1);
+	return index === -1 ? null : segments[index];
+}
+function originalPositionFor$2(map, needle) {
+	let { line, column, bias } = needle;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO$1);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO$1);
+	const decoded = decodedMappings$1(map);
+	if (line >= decoded.length) return OMapping$1(null, null, null, null);
+	const segments = decoded[line];
+	const index = traceSegmentInternal$1(segments, cast$2(map)._decodedMemo, line, column, bias || 1);
+	if (index === -1) return OMapping$1(null, null, null, null);
+	const segment = segments[index];
+	if (segment.length === 1) return OMapping$1(null, null, null, null);
+	const { names, resolvedSources } = map;
+	return OMapping$1(resolvedSources[segment[SOURCES_INDEX$2]], segment[SOURCE_LINE$2] + 1, segment[SOURCE_COLUMN$2], segment.length === 5 ? names[segment[NAMES_INDEX$2]] : null);
+}
+function OMapping$1(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function traceSegmentInternal$1(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch$1(segments, column, memo, line);
+	if (found$1) index = (bias === -1 ? upperBound$1 : lowerBound$1)(segments, column, index);
+	else if (bias === -1) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
+var SetArray = class {
+	constructor() {
+		this._indexes = { __proto__: null };
+		this.array = [];
+	}
+};
+function cast$1(set) {
+	return set;
+}
+function get$2(setarr, key) {
+	return cast$1(setarr)._indexes[key];
+}
+function put(setarr, key) {
+	const index = get$2(setarr, key);
+	if (index !== void 0) return index;
+	const { array, _indexes: indexes } = cast$1(setarr);
+	return indexes[key] = array.push(key) - 1;
+}
+function remove(setarr, key) {
+	const index = get$2(setarr, key);
+	if (index === void 0) return;
+	const { array, _indexes: indexes } = cast$1(setarr);
+	for (let i = index + 1; i < array.length; i++) {
+		const k = array[i];
+		array[i - 1] = k;
+		indexes[k]--;
+	}
+	indexes[key] = void 0;
+	array.pop();
+}
+var COLUMN$1 = 0;
+var SOURCES_INDEX$1 = 1;
+var SOURCE_LINE$1 = 2;
+var SOURCE_COLUMN$1 = 3;
+var NAMES_INDEX$1 = 4;
+var NO_NAME = -1;
+var GenMapping = class {
+	constructor({ file, sourceRoot } = {}) {
+		this._names = new SetArray();
+		this._sources = new SetArray();
+		this._sourcesContent = [];
+		this._mappings = [];
+		this.file = file;
+		this.sourceRoot = sourceRoot;
+		this._ignoreList = new SetArray();
+	}
+};
+function cast2(map) {
+	return map;
+}
+var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
+	return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
+};
+function setSourceContent(map, source, content) {
+	const { _sources: sources, _sourcesContent: sourcesContent } = cast2(map);
+	const index = put(sources, source);
+	sourcesContent[index] = content;
+}
+function setIgnore(map, source, ignore = true) {
+	const { _sources: sources, _sourcesContent: sourcesContent, _ignoreList: ignoreList } = cast2(map);
+	const index = put(sources, source);
+	if (index === sourcesContent.length) sourcesContent[index] = null;
+	if (ignore) put(ignoreList, index);
+	else remove(ignoreList, index);
+}
+function toDecodedMap(map) {
+	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList } = cast2(map);
+	removeEmptyFinalLines(mappings);
+	return {
+		version: 3,
+		file: map.file || void 0,
+		names: names.array,
+		sourceRoot: map.sourceRoot || void 0,
+		sources: sources.array,
+		sourcesContent,
+		mappings,
+		ignoreList: ignoreList.array
+	};
+}
+function toEncodedMap(map) {
+	const decoded = toDecodedMap(map);
+	return Object.assign({}, decoded, { mappings: encode$1(decoded.mappings) });
+}
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names } = cast2(map);
+	const line = getIndex(mappings, genLine);
+	const index = getColumnIndex(line, genColumn);
+	if (!source) {
+		if (skipable && skipSourceless(line, index)) return;
+		return insert(line, index, [genColumn]);
+	}
+	const sourcesIndex = put(sources, source);
+	const namesIndex = name ? put(names, name) : NO_NAME;
+	if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null;
+	if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) return;
+	return insert(line, index, name ? [
+		genColumn,
+		sourcesIndex,
+		sourceLine,
+		sourceColumn,
+		namesIndex
+	] : [
+		genColumn,
+		sourcesIndex,
+		sourceLine,
+		sourceColumn
+	]);
+}
+function getIndex(arr, index) {
+	for (let i = arr.length; i <= index; i++) arr[i] = [];
+	return arr[index];
+}
+function getColumnIndex(line, genColumn) {
+	let index = line.length;
+	for (let i = index - 1; i >= 0; index = i--) if (genColumn >= line[i][COLUMN$1]) break;
+	return index;
+}
+function insert(array, index, value) {
+	for (let i = array.length; i > index; i--) array[i] = array[i - 1];
+	array[index] = value;
+}
+function removeEmptyFinalLines(mappings) {
+	const { length } = mappings;
+	let len = length;
+	for (let i = len - 1; i >= 0; len = i, i--) if (mappings[i].length > 0) break;
+	if (len < length) mappings.length = len;
+}
+function skipSourceless(line, index) {
+	if (index === 0) return true;
+	return line[index - 1].length === 1;
+}
+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+	if (index === 0) return false;
+	const prev = line[index - 1];
+	if (prev.length === 1) return false;
+	return sourcesIndex === prev[SOURCES_INDEX$1] && sourceLine === prev[SOURCE_LINE$1] && sourceColumn === prev[SOURCE_COLUMN$1] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX$1] : NO_NAME);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+remapping@2.3.5/node_modules/@jridgewell/remapping/dist/remapping.mjs
+var SOURCELESS_MAPPING = /* @__PURE__ */ SegmentObject("", -1, -1, "", null, false);
+var EMPTY_SOURCES = [];
+function SegmentObject(source, line, column, name, content, ignore) {
+	return {
+		source,
+		line,
+		column,
+		name,
+		content,
+		ignore
+	};
+}
+function Source(map, sources, source, content, ignore) {
+	return {
+		map,
+		sources,
+		source,
+		content,
+		ignore
+	};
+}
+function MapSource(map, sources) {
+	return Source(map, sources, "", null, false);
+}
+function OriginalSource(source, content, ignore) {
+	return Source(null, EMPTY_SOURCES, source, content, ignore);
+}
+function traceMappings(tree) {
+	const gen = new GenMapping({ file: tree.map.file });
+	const { sources: rootSources, map } = tree;
+	const rootNames = map.names;
+	const rootMappings = decodedMappings$1(map);
+	for (let i = 0; i < rootMappings.length; i++) {
+		const segments = rootMappings[i];
+		for (let j = 0; j < segments.length; j++) {
+			const segment = segments[j];
+			const genCol = segment[0];
+			let traced = SOURCELESS_MAPPING;
+			if (segment.length !== 1) {
+				const source2 = rootSources[segment[1]];
+				traced = originalPositionFor$1(source2, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : "");
+				if (traced == null) continue;
+			}
+			const { column, line, name, content, source, ignore } = traced;
+			maybeAddSegment(gen, i, genCol, source, line, column, name);
+			if (source && content != null) setSourceContent(gen, source, content);
+			if (ignore) setIgnore(gen, source, true);
+		}
+	}
+	return gen;
+}
+function originalPositionFor$1(source, line, column, name) {
+	if (!source.map) return SegmentObject(source.source, line, column, name, source.content, source.ignore);
+	const segment = traceSegment(source.map, line, column);
+	if (segment == null) return null;
+	if (segment.length === 1) return SOURCELESS_MAPPING;
+	return originalPositionFor$1(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name);
+}
+function asArray(value) {
+	if (Array.isArray(value)) return value;
+	return [value];
+}
+function buildSourceMapTree(input, loader) {
+	const maps = asArray(input).map((m) => new TraceMap(m, ""));
+	const map = maps.pop();
+	for (let i = 0; i < maps.length; i++) if (maps[i].sources.length > 1) throw new Error(`Transformation map ${i} must have exactly one source file.
+Did you specify these with the most recent transformation maps first?`);
+	let tree = build$1(map, loader, "", 0);
+	for (let i = maps.length - 1; i >= 0; i--) tree = MapSource(maps[i], [tree]);
+	return tree;
+}
+function build$1(map, loader, importer, importerDepth) {
+	const { resolvedSources, sourcesContent, ignoreList } = map;
+	const depth = importerDepth + 1;
+	return MapSource(map, resolvedSources.map((sourceFile, i) => {
+		const ctx = {
+			importer,
+			depth,
+			source: sourceFile || "",
+			content: void 0,
+			ignore: void 0
+		};
+		const sourceMap = loader(ctx.source, ctx);
+		const { source, content, ignore } = ctx;
+		if (sourceMap) return build$1(new TraceMap(sourceMap, source), loader, source, depth);
+		return OriginalSource(source, content !== void 0 ? content : sourcesContent ? sourcesContent[i] : null, ignore !== void 0 ? ignore : ignoreList ? ignoreList.includes(i) : false);
+	}));
+}
+var SourceMap$1 = class {
+	constructor(map, options) {
+		const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);
+		this.version = out.version;
+		this.file = out.file;
+		this.mappings = out.mappings;
+		this.names = out.names;
+		this.ignoreList = out.ignoreList;
+		this.sourceRoot = out.sourceRoot;
+		this.sources = out.sources;
+		if (!options.excludeContent) this.sourcesContent = out.sourcesContent;
+	}
+	toString() {
+		return JSON.stringify(this);
+	}
+};
+function remapping(input, loader, options) {
+	const opts = typeof options === "object" ? options : {
+		excludeContent: !!options,
+		decodedMappings: false
+	};
+	return new SourceMap$1(traceMappings(buildSourceMapTree(input, loader)), opts);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/obug@1.0.2_ms@2.1.3/node_modules/obug/dist/core.js
+function coerce(value) {
+	if (value instanceof Error) return value.stack || value.message;
+	return value;
+}
+function selectColor(colors, namespace) {
+	let hash = 0;
+	for (let i = 0; i < namespace.length; i++) {
+		hash = (hash << 5) - hash + namespace.charCodeAt(i);
+		hash |= 0;
+	}
+	return colors[Math.abs(hash) % colors.length];
+}
+function matchesTemplate(search, template) {
+	let searchIndex = 0;
+	let templateIndex = 0;
+	let starIndex = -1;
+	let matchIndex = 0;
+	while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) if (template[templateIndex] === "*") {
+		starIndex = templateIndex;
+		matchIndex = searchIndex;
+		templateIndex++;
+	} else {
+		searchIndex++;
+		templateIndex++;
+	}
+	else if (starIndex !== -1) {
+		templateIndex = starIndex + 1;
+		matchIndex++;
+		searchIndex = matchIndex;
+	} else return false;
+	while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++;
+	return templateIndex === template.length;
+}
+function humanize(value) {
+	if (value >= 1e3) return `${(value / 1e3).toFixed(1)}s`;
+	return `${value}ms`;
+}
+function setup(useColors, colors, log, load, save, formatArgs, init) {
+	const createDebug = (namespace) => {
+		let prevTime;
+		let enableOverride;
+		let namespacesCache;
+		let enabledCache;
+		const debug = (...args) => {
+			if (!debug.enabled) return;
+			const curr = Date.now();
+			debug.diff = curr - (prevTime || curr);
+			debug.prev = prevTime;
+			debug.curr = curr;
+			prevTime = curr;
+			args[0] = coerce(args[0]);
+			if (typeof args[0] !== "string") args.unshift("%O");
+			let index = 0;
+			args[0] = args[0].replace(/%([a-z%])/gi, (match, format) => {
+				if (match === "%%") return "%";
+				index++;
+				const formatter = createDebug.formatters[format];
+				if (typeof formatter === "function") {
+					match = formatter.call(debug, args[index]);
+					args.splice(index, 1);
+					index--;
+				}
+				return match;
+			});
+			createDebug.formatArgs.call(debug, args);
+			(debug.log || createDebug.log).apply(debug, args);
+		};
+		function extend(namespace$1, delimiter = ":") {
+			const newDebug = createDebug(this.namespace + delimiter + namespace$1);
+			newDebug.log = this.log;
+			return newDebug;
+		}
+		debug.namespace = namespace;
+		debug.useColors = useColors;
+		debug.color = selectColor(colors, namespace);
+		debug.extend = extend;
+		debug.log = log;
+		Object.defineProperty(debug, "enabled", {
+			enumerable: true,
+			configurable: false,
+			get: () => {
+				if (enableOverride != null) return enableOverride;
+				if (namespacesCache !== createDebug.namespaces) {
+					namespacesCache = createDebug.namespaces;
+					enabledCache = createDebug.enabled(namespace);
+				}
+				return enabledCache;
+			},
+			set: (v) => {
+				enableOverride = v;
+			}
+		});
+		init && init(debug);
+		return debug;
+	};
+	function enable(namespaces) {
+		save(namespaces);
+		createDebug.namespaces = namespaces;
+		createDebug.names = [];
+		createDebug.skips = [];
+		const split = namespaces.trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+		for (const ns of split) if (ns[0] === "-") createDebug.skips.push(ns.slice(1));
+		else createDebug.names.push(ns);
+	}
+	function disable() {
+		const namespaces = [...createDebug.names, ...createDebug.skips.map((namespace) => `-${namespace}`)].join(",");
+		createDebug.enable("");
+		return namespaces;
+	}
+	function enabled(name) {
+		for (const skip of createDebug.skips) if (matchesTemplate(name, skip)) return false;
+		for (const ns of createDebug.names) if (matchesTemplate(name, ns)) return true;
+		return false;
+	}
+	createDebug.namespaces = "";
+	createDebug.formatters = {};
+	createDebug.enable = enable;
+	createDebug.disable = disable;
+	createDebug.enabled = enabled;
+	createDebug.names = [];
+	createDebug.skips = [];
+	createDebug.selectColor = (ns) => selectColor(colors, ns);
+	createDebug.formatArgs = formatArgs;
+	createDebug.log = log;
+	createDebug.enable(load());
+	return createDebug;
+}
+var init_core = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/obug@1.0.2_ms@2.1.3/node_modules/obug/dist/node.js
+var node_exports = /* @__PURE__ */ __exportAll({
+	createDebug: () => createDebug,
+	default: () => node_default,
+	formatArgs: () => formatArgs,
+	log: () => log,
+	"module.exports": () => createDebug
+});
+function log(...args) {
+	process.stderr.write(`${formatWithOptions(inspectOpts, ...args)}\n`);
+}
+function load() {
+	return process.env.DEBUG || "";
+}
+function save(namespaces) {
+	if (namespaces) process.env.DEBUG = namespaces;
+	else delete process.env.DEBUG;
+}
+function useColors() {
+	return "colors" in inspectOpts ? Boolean(inspectOpts.colors) : isatty(process.stderr.fd);
+}
+function formatArgs(args) {
+	const { namespace: name, useColors: useColors$1 } = this;
+	if (useColors$1) {
+		const c = this.color;
+		const colorCode = `\u001B[3${c < 8 ? c : `8;5;${c}`}`;
+		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+		args[0] = prefix + args[0].split("\n").join(`\n${prefix}`);
+		args.push(`${colorCode}m+${humanize$1(this.diff)}\u001B[0m`);
+	} else args[0] = `${getDate()}${name} ${args[0]}`;
+}
+function getDate() {
+	if (inspectOpts.hideDate) return "";
+	return `${(/* @__PURE__ */ new Date()).toISOString()} `;
+}
+function init$1(debug) {
+	debug.inspectOpts = Object.assign({}, inspectOpts);
+}
+var require$1, colors$38, inspectOpts, humanize$1, createDebug, node_default;
+var init_node = __esmMin((() => {
+	init_core();
+	require$1 = createRequire(import.meta.url);
+	colors$38 = process.stderr.getColorDepth && process.stderr.getColorDepth() > 2 ? [
+		20,
+		21,
+		26,
+		27,
+		32,
+		33,
+		38,
+		39,
+		40,
+		41,
+		42,
+		43,
+		44,
+		45,
+		56,
+		57,
+		62,
+		63,
+		68,
+		69,
+		74,
+		75,
+		76,
+		77,
+		78,
+		79,
+		80,
+		81,
+		92,
+		93,
+		98,
+		99,
+		112,
+		113,
+		128,
+		129,
+		134,
+		135,
+		148,
+		149,
+		160,
+		161,
+		162,
+		163,
+		164,
+		165,
+		166,
+		167,
+		168,
+		169,
+		170,
+		171,
+		172,
+		173,
+		178,
+		179,
+		184,
+		185,
+		196,
+		197,
+		198,
+		199,
+		200,
+		201,
+		202,
+		203,
+		204,
+		205,
+		206,
+		207,
+		208,
+		209,
+		214,
+		215,
+		220,
+		221
+	] : [
+		6,
+		2,
+		3,
+		4,
+		5,
+		1
+	];
+	inspectOpts = Object.keys(process.env).filter((key) => {
+		return /^debug_/i.test(key);
+	}).reduce((obj, key) => {
+		const prop = key.slice(6).toLowerCase().replace(/_([a-z])/g, (_, k) => k.toUpperCase());
+		let value = process.env[key];
+		if (value === "null") value = null;
+		else if (/^yes|on|true|enabled$/i.test(value)) value = true;
+		else if (/^no|off|false|disabled$/i.test(value)) value = false;
+		else value = Number(value);
+		obj[prop] = value;
+		return obj;
+	}, {});
+	try {
+		humanize$1 = require$1("ms");
+	} catch (_unused) {
+		humanize$1 = humanize;
+	}
+	createDebug = setup(useColors(), colors$38, log, load, save, formatArgs, init$1);
+	createDebug.inspectOpts = inspectOpts;
+	createDebug.formatters.o = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+	};
+	createDebug.formatters.O = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return inspect(v, this.inspectOpts);
+	};
+	node_default = createDebug;
+	createDebug.default = createDebug;
+	createDebug.debug = createDebug;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@rollup+pluginutils@5.3.0_rollup@4.59.0/node_modules/@rollup/pluginutils/dist/es/index.js
+function isArray(arg) {
+	return Array.isArray(arg);
+}
+function ensureArray(thing) {
+	if (isArray(thing)) return thing;
+	if (thing == null) return [];
+	return [thing];
+}
+const normalizePathRegExp = new RegExp(`\\${win32.sep}`, "g");
+const normalizePath$1 = function normalizePath(filename) {
+	return filename.replace(normalizePathRegExp, posix$1.sep);
+};
+function getMatcherString$1(id, resolutionBase) {
+	if (resolutionBase === false || isAbsolute$1(id) || id.startsWith("**")) return normalizePath$1(id);
+	const basePath = normalizePath$1(resolve$1(resolutionBase || "")).replace(/[-^$*+?.()|[\]{}]/g, "\\$&");
+	return posix$1.join(basePath, normalizePath$1(id));
+}
+const createFilter$2 = function createFilter(include, exclude, options) {
+	const resolutionBase = options && options.resolve;
+	const getMatcher = (id) => id instanceof RegExp ? id : { test: (what) => {
+		return picomatch(getMatcherString$1(id, resolutionBase), { dot: true })(what);
+	} };
+	const includeMatchers = ensureArray(include).map(getMatcher);
+	const excludeMatchers = ensureArray(exclude).map(getMatcher);
+	if (!includeMatchers.length && !excludeMatchers.length) return (id) => typeof id === "string" && !id.includes("\0");
+	return function result(id) {
+		if (typeof id !== "string") return false;
+		if (id.includes("\0")) return false;
+		const pathId = normalizePath$1(id);
+		for (let i = 0; i < excludeMatchers.length; ++i) {
+			const matcher = excludeMatchers[i];
+			if (matcher instanceof RegExp) matcher.lastIndex = 0;
+			if (matcher.test(pathId)) return false;
+		}
+		for (let i = 0; i < includeMatchers.length; ++i) {
+			const matcher = includeMatchers[i];
+			if (matcher instanceof RegExp) matcher.lastIndex = 0;
+			if (matcher.test(pathId)) return true;
+		}
+		return !includeMatchers.length;
+	};
+};
+const forbiddenIdentifiers = new Set(`break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl`.split(" "));
+forbiddenIdentifiers.add("");
+const makeLegalIdentifier = function makeLegalIdentifier(str) {
+	let identifier = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, "_");
+	if (/\d/.test(identifier[0]) || forbiddenIdentifiers.has(identifier)) identifier = `_${identifier}`;
+	return identifier || "_";
+};
+function stringify(obj) {
+	return (JSON.stringify(obj) || "undefined").replace(/[\u2028\u2029]/g, (char) => `\\u${`000${char.charCodeAt(0).toString(16)}`.slice(-4)}`);
+}
+function serializeArray(arr, indent, baseIndent) {
+	let output = "[";
+	const separator = indent ? `\n${baseIndent}${indent}` : "";
+	for (let i = 0; i < arr.length; i++) {
+		const key = arr[i];
+		output += `${i > 0 ? "," : ""}${separator}${serialize(key, indent, baseIndent + indent)}`;
+	}
+	return `${output}${indent ? `\n${baseIndent}` : ""}]`;
+}
+function serializeObject(obj, indent, baseIndent) {
+	let output = "{";
+	const separator = indent ? `\n${baseIndent}${indent}` : "";
+	const entries = Object.entries(obj);
+	for (let i = 0; i < entries.length; i++) {
+		const [key, value] = entries[i];
+		const stringKey = makeLegalIdentifier(key) === key ? key : stringify(key);
+		output += `${i > 0 ? "," : ""}${separator}${stringKey}:${indent ? " " : ""}${serialize(value, indent, baseIndent + indent)}`;
+	}
+	return `${output}${indent ? `\n${baseIndent}` : ""}}`;
+}
+function serialize(obj, indent, baseIndent) {
+	if (typeof obj === "object" && obj !== null) {
+		if (Array.isArray(obj)) return serializeArray(obj, indent, baseIndent);
+		if (obj instanceof Date) return `new Date(${obj.getTime()})`;
+		if (obj instanceof RegExp) return obj.toString();
+		return serializeObject(obj, indent, baseIndent);
+	}
+	if (typeof obj === "number") {
+		if (obj === Infinity) return "Infinity";
+		if (obj === -Infinity) return "-Infinity";
+		if (obj === 0) return 1 / obj === Infinity ? "0" : "-0";
+		if (obj !== obj) return "NaN";
+	}
+	if (typeof obj === "symbol") {
+		const key = Symbol.keyFor(obj);
+		if (key !== void 0) return `Symbol.for(${stringify(key)})`;
+	}
+	if (typeof obj === "bigint") return `${obj}n`;
+	return stringify(obj);
+}
+const hasStringIsWellFormed = "isWellFormed" in String.prototype;
+function isWellFormedString(input) {
+	if (hasStringIsWellFormed) return input.isWellFormed();
+	return !/\p{Surrogate}/u.test(input);
+}
+const dataToEsm = function dataToEsm(data, options = {}) {
+	var _a, _b;
+	const t = options.compact ? "" : "indent" in options ? options.indent : "	";
+	const _ = options.compact ? "" : " ";
+	const n = options.compact ? "" : "\n";
+	const declarationType = options.preferConst ? "const" : "var";
+	if (options.namedExports === false || typeof data !== "object" || Array.isArray(data) || data instanceof Date || data instanceof RegExp || data === null) {
+		const code = serialize(data, options.compact ? null : t, "");
+		return `export default${_ || (/^[{[\-\/]/.test(code) ? "" : " ")}${code};`;
+	}
+	let maxUnderbarPrefixLength = 0;
+	for (const key of Object.keys(data)) {
+		const underbarPrefixLength = (_b = (_a = /^(_+)/.exec(key)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+		if (underbarPrefixLength > maxUnderbarPrefixLength) maxUnderbarPrefixLength = underbarPrefixLength;
+	}
+	const arbitraryNamePrefix = `${"_".repeat(maxUnderbarPrefixLength + 1)}arbitrary`;
+	let namedExportCode = "";
+	const defaultExportRows = [];
+	const arbitraryNameExportRows = [];
+	for (const [key, value] of Object.entries(data)) if (key === makeLegalIdentifier(key)) {
+		if (options.objectShorthand) defaultExportRows.push(key);
+		else defaultExportRows.push(`${key}:${_}${key}`);
+		namedExportCode += `export ${declarationType} ${key}${_}=${_}${serialize(value, options.compact ? null : t, "")};${n}`;
+	} else {
+		defaultExportRows.push(`${stringify(key)}:${_}${serialize(value, options.compact ? null : t, "")}`);
+		if (options.includeArbitraryNames && isWellFormedString(key)) {
+			const variableName = `${arbitraryNamePrefix}${arbitraryNameExportRows.length}`;
+			namedExportCode += `${declarationType} ${variableName}${_}=${_}${serialize(value, options.compact ? null : t, "")};${n}`;
+			arbitraryNameExportRows.push(`${variableName} as ${JSON.stringify(key)}`);
+		}
+	}
+	const arbitraryExportCode = arbitraryNameExportRows.length > 0 ? `export${_}{${n}${t}${arbitraryNameExportRows.join(`,${n}${t}`)}${n}};${n}` : "";
+	const defaultExportCode = `export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
+	return `${namedExportCode}${arbitraryExportCode}${defaultExportCode}`;
+};
+//#endregion
+//#region src/shared/builtin.ts
+function createIsBuiltin(builtins) {
+	const plainBuiltinsSet = new Set(builtins.filter((builtin) => typeof builtin === "string"));
+	const regexBuiltins = builtins.filter((builtin) => typeof builtin !== "string");
+	return (id) => plainBuiltinsSet.has(id) || regexBuiltins.some((regexp) => regexp.test(id));
+}
+//#endregion
+//#region src/node/packages.ts
+let pnp;
+if (process.versions.pnp) try {
+	pnp = createRequire(
+		/** #__KEEP__ */
+		import.meta.url
+	)("pnpapi");
+} catch {}
+function invalidatePackageData(packageCache, pkgPath) {
+	const pkgDir = normalizePath(path.dirname(pkgPath));
+	packageCache.forEach((pkg, cacheKey) => {
+		if (pkg.dir === pkgDir) packageCache.delete(cacheKey);
+	});
+}
+function resolvePackageData(pkgName, basedir, preserveSymlinks = false, packageCache) {
+	if (pnp) {
+		const cacheKey = getRpdCacheKey(pkgName, basedir, preserveSymlinks);
+		if (packageCache?.has(cacheKey)) return packageCache.get(cacheKey);
+		try {
+			const pkg = pnp.resolveToUnqualified(pkgName, basedir, { considerBuiltins: false });
+			if (!pkg) return null;
+			const pkgData = loadPackageData(path.join(pkg, "package.json"));
+			packageCache?.set(cacheKey, pkgData);
+			return pkgData;
+		} catch {
+			return null;
+		}
+	}
+	const originalBasedir = basedir;
+	while (basedir) {
+		if (packageCache) {
+			const cached = getRpdCache(packageCache, pkgName, basedir, originalBasedir, preserveSymlinks);
+			if (cached) return cached;
+		}
+		const pkg = path.join(basedir, "node_modules", pkgName, "package.json");
+		try {
+			if (fs.existsSync(pkg)) {
+				const pkgData = loadPackageData(preserveSymlinks ? pkg : safeRealpathSync(pkg));
+				if (packageCache) setRpdCache(packageCache, pkgData, pkgName, basedir, originalBasedir, preserveSymlinks);
+				return pkgData;
+			}
+		} catch {}
+		const nextBasedir = path.dirname(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return null;
+}
+function findNearestPackageData(basedir, packageCache) {
+	const originalBasedir = basedir;
+	while (basedir) {
+		if (packageCache) {
+			const cached = getFnpdCache(packageCache, basedir, originalBasedir);
+			if (cached) return cached;
+		}
+		const pkgPath = path.join(basedir, "package.json");
+		if (tryStatSync(pkgPath)?.isFile()) try {
+			const pkgData = loadPackageData(pkgPath);
+			if (packageCache) setFnpdCache(packageCache, pkgData, basedir, originalBasedir);
+			return pkgData;
+		} catch {}
+		const nextBasedir = path.dirname(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return null;
+}
+function findNearestMainPackageData(basedir, packageCache) {
+	const nearestPackage = findNearestPackageData(basedir, packageCache);
+	return nearestPackage && (nearestPackage.data.name ? nearestPackage : findNearestMainPackageData(path.dirname(nearestPackage.dir), packageCache));
+}
+function loadPackageData(pkgPath) {
+	const data = JSON.parse(stripBomTag(fs.readFileSync(pkgPath, "utf-8")));
+	const pkgDir = normalizePath(path.dirname(pkgPath));
+	const { sideEffects } = data;
+	let hasSideEffects;
+	if (typeof sideEffects === "boolean") hasSideEffects = () => sideEffects;
+	else if (Array.isArray(sideEffects)) if (sideEffects.length <= 0) hasSideEffects = () => false;
+	else hasSideEffects = createFilter$1(sideEffects.map((sideEffect) => {
+		if (sideEffect.includes("/")) return sideEffect;
+		return `**/${sideEffect}`;
+	}), null, { resolve: pkgDir });
+	else hasSideEffects = () => null;
+	const resolvedCache = {};
+	return {
+		dir: pkgDir,
+		data,
+		hasSideEffects,
+		setResolvedCache(key, entry, options) {
+			resolvedCache[getResolveCacheKey(key, options)] = entry;
+		},
+		getResolvedCache(key, options) {
+			return resolvedCache[getResolveCacheKey(key, options)];
+		}
+	};
+}
+function getResolveCacheKey(key, options) {
+	return [
+		key,
+		options.isRequire ? "1" : "0",
+		options.conditions.join("_"),
+		options.extensions.join("_"),
+		options.mainFields.join("_")
+	].join("|");
+}
+function findNearestNodeModules(basedir) {
+	while (basedir) {
+		const pkgPath = path.join(basedir, "node_modules");
+		if (tryStatSync(pkgPath)?.isDirectory()) return pkgPath;
+		const nextBasedir = path.dirname(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return null;
+}
+function watchPackageDataPlugin(packageCache) {
+	const watchQueue = /* @__PURE__ */ new Set();
+	const watchedDirs = /* @__PURE__ */ new Set();
+	const watchFileStub = (id) => {
+		watchQueue.add(id);
+	};
+	let watchFile = watchFileStub;
+	const setPackageData = packageCache.set.bind(packageCache);
+	packageCache.set = (id, pkg) => {
+		if (!isInNodeModules(pkg.dir) && !watchedDirs.has(pkg.dir)) {
+			watchedDirs.add(pkg.dir);
+			watchFile(path.join(pkg.dir, "package.json"));
+		}
+		return setPackageData(id, pkg);
+	};
+	return {
+		name: "vite:watch-package-data",
+		buildStart() {
+			watchFile = this.addWatchFile.bind(this);
+			watchQueue.forEach(watchFile);
+			watchQueue.clear();
+		},
+		buildEnd() {
+			watchFile = watchFileStub;
+		},
+		watchChange(id) {
+			if (id.endsWith("/package.json")) invalidatePackageData(packageCache, path.normalize(id));
+		}
+	};
+}
+/**
+* Get cached `resolvePackageData` value based on `basedir`. When one is found,
+* and we've already traversed some directories between `basedir` and `originalBasedir`,
+* we cache the value for those in-between directories as well.
+*
+* This makes it so the fs is only read once for a shared `basedir`.
+*/
+function getRpdCache(packageCache, pkgName, basedir, originalBasedir, preserveSymlinks) {
+	const cacheKey = getRpdCacheKey(pkgName, basedir, preserveSymlinks);
+	const pkgData = packageCache.get(cacheKey);
+	if (pkgData) {
+		traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+			packageCache.set(getRpdCacheKey(pkgName, dir, preserveSymlinks), pkgData);
+		});
+		return pkgData;
+	}
+}
+function setRpdCache(packageCache, pkgData, pkgName, basedir, originalBasedir, preserveSymlinks) {
+	packageCache.set(getRpdCacheKey(pkgName, basedir, preserveSymlinks), pkgData);
+	traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+		packageCache.set(getRpdCacheKey(pkgName, dir, preserveSymlinks), pkgData);
+	});
+}
+function getRpdCacheKey(pkgName, basedir, preserveSymlinks) {
+	return `rpd_${pkgName}_${basedir}_${preserveSymlinks}`;
+}
+/**
+* Get cached `findNearestPackageData` value based on `basedir`. When one is found,
+* and we've already traversed some directories between `basedir` and `originalBasedir`,
+* we cache the value for those in-between directories as well.
+*
+* This makes it so the fs is only read once for a shared `basedir`.
+*/
+function getFnpdCache(packageCache, basedir, originalBasedir) {
+	const cacheKey = getFnpdCacheKey(basedir);
+	const pkgData = packageCache.get(cacheKey);
+	if (pkgData) {
+		traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+			packageCache.set(getFnpdCacheKey(dir), pkgData);
+		});
+		return pkgData;
+	}
+}
+function setFnpdCache(packageCache, pkgData, basedir, originalBasedir) {
+	packageCache.set(getFnpdCacheKey(basedir), pkgData);
+	traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+		packageCache.set(getFnpdCacheKey(dir), pkgData);
+	});
+}
+function getFnpdCacheKey(basedir) {
+	return `fnpd_${basedir}`;
+}
+/**
+* Traverse between `longerDir` (inclusive) and `shorterDir` (exclusive) and call `cb` for each dir.
+* @param longerDir Longer dir path, e.g. `/User/foo/bar/baz`
+* @param shorterDir Shorter dir path, e.g. `/User/foo`
+*/
+function traverseBetweenDirs(longerDir, shorterDir, cb) {
+	while (longerDir !== shorterDir) {
+		cb(longerDir);
+		longerDir = path.dirname(longerDir);
+	}
+}
+//#endregion
+//#region src/node/utils.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+init_node();
+const createFilter$1 = createFilter$2;
+const invalidUrlPathCharRE = /[\u0000-\u001F"#$%&*+,:;<=>?[\]^`{|}\u007F]/g;
+const replaceNestedIdRE = /\s*>\s*/g;
+const flattenId = (id) => {
+	return limitFlattenIdLength(id.replaceAll(/_+/g, "$&__").replaceAll("/", "_").replaceAll(".", "__").replace(replaceNestedIdRE, "_n_").replace(invalidUrlPathCharRE, (c) => "_0" + c.charCodeAt(0).toString(16) + "_"));
+};
+const FLATTEN_ID_HASH_LENGTH = 8;
+const FLATTEN_ID_MAX_FILE_LENGTH = 170;
+const limitFlattenIdLength = (id, limit = FLATTEN_ID_MAX_FILE_LENGTH) => {
+	if (id.length <= limit) return id;
+	return id.slice(0, limit - (FLATTEN_ID_HASH_LENGTH + 1)) + "_" + getHash(id);
+};
+const normalizeId = (id) => id.replace(replaceNestedIdRE, " > ");
+const NODE_BUILTIN_NAMESPACE = "node:";
+const BUN_BUILTIN_NAMESPACE = "bun:";
+const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
+const isBuiltinCache = /* @__PURE__ */ new WeakMap();
+function isBuiltin(builtins, id) {
+	let isBuiltin = isBuiltinCache.get(builtins);
+	if (!isBuiltin) {
+		isBuiltin = createIsBuiltin(builtins);
+		isBuiltinCache.set(builtins, isBuiltin);
+	}
+	return isBuiltin(id);
+}
+const nodeLikeBuiltins = [
+	...nodeBuiltins,
+	new RegExp(`^${NODE_BUILTIN_NAMESPACE}`),
+	new RegExp(`^${BUN_BUILTIN_NAMESPACE}`)
+];
+function isNodeLikeBuiltin(id) {
+	return isBuiltin(nodeLikeBuiltins, id);
+}
+function isNodeBuiltin(id) {
+	if (id.startsWith(NODE_BUILTIN_NAMESPACE)) return true;
+	return nodeBuiltins.includes(id);
+}
+function isInNodeModules(id) {
+	return id.includes("node_modules");
+}
+function moduleListContains(moduleList, id) {
+	return moduleList?.some((m) => m === id || id.startsWith(withTrailingSlash(m)));
+}
+function isOptimizable(id, optimizeDeps) {
+	const { extensions } = optimizeDeps;
+	return OPTIMIZABLE_ENTRY_RE.test(id) || (extensions?.some((ext) => id.endsWith(ext)) ?? false);
+}
+const bareImportRE = /^(?![a-zA-Z]:)[\w@](?!.*:\/\/)/;
+const deepImportRE = /^([^@][^/]*)\/|^(@[^/]+\/[^/]+)\//;
+const _dirname = path.dirname(fileURLToPath(
+	/** #__KEEP__ */
+	import.meta.url
+));
+const rollupVersion = "4.23.0";
+const filter = process.env.VITE_DEBUG_FILTER;
+const DEBUG = process.env.DEBUG;
+function createDebugger(namespace, options = {}) {
+	const log = node_default(namespace);
+	const { onlyWhenFocused, depth } = options;
+	if (depth && log.inspectOpts && log.inspectOpts.depth == null) log.inspectOpts.depth = options.depth;
+	let enabled = log.enabled;
+	if (enabled && onlyWhenFocused) enabled = !!DEBUG?.includes(typeof onlyWhenFocused === "string" ? onlyWhenFocused : namespace);
+	if (enabled) return (...args) => {
+		if (!filter || args.some((a) => a?.includes?.(filter))) log(...args);
+	};
+}
+function testCaseInsensitiveFS() {
+	if (!CLIENT_ENTRY.endsWith("client.mjs")) throw new Error(`cannot test case insensitive FS, CLIENT_ENTRY const doesn't contain client.mjs`);
+	if (!fs.existsSync(CLIENT_ENTRY)) throw new Error("cannot test case insensitive FS, CLIENT_ENTRY does not point to an existing file: " + CLIENT_ENTRY);
+	return fs.existsSync(CLIENT_ENTRY.replace("client.mjs", "cLiEnT.mjs"));
+}
+const isCaseInsensitiveFS = testCaseInsensitiveFS();
+const VOLUME_RE = /^[A-Z]:/i;
+function normalizePath(id) {
+	return path.posix.normalize(isWindows ? slash(id) : id);
+}
+function fsPathFromId(id) {
+	const fsPath = normalizePath(id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id);
+	return fsPath[0] === "/" || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
+}
+function fsPathFromUrl(url) {
+	return fsPathFromId(cleanUrl(url));
+}
+/**
+* Check if dir is a parent of file
+*
+* Warning: parameters are not validated, only works with normalized absolute paths
+*
+* @param dir - normalized absolute path
+* @param file - normalized absolute path
+* @returns true if dir is a parent of file
+*/
+function isParentDirectory(dir, file) {
+	dir = withTrailingSlash(dir);
+	return file.startsWith(dir) || isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase());
+}
+/**
+* Check if 2 file name are identical
+*
+* Warning: parameters are not validated, only works with normalized absolute paths
+*
+* @param file1 - normalized absolute path
+* @param file2 - normalized absolute path
+* @returns true if both files url are identical
+*/
+function isSameFilePath(file1, file2) {
+	return file1 === file2 || isCaseInsensitiveFS && file1.toLowerCase() === file2.toLowerCase();
+}
+const externalRE = /^([a-z]+:)?\/\//;
+const isExternalUrl = (url) => externalRE.test(url);
+const dataUrlRE = /^\s*data:/i;
+const isDataUrl = (url) => dataUrlRE.test(url);
+const virtualModuleRE = /^virtual-module:.*/;
+const virtualModulePrefix = "virtual-module:";
+const knownJsSrcRE = /\.(?:[jt]sx?|m[jt]s|vue|marko|svelte|astro|imba|mdx)(?:$|\?)/;
+const isJSRequest = (url) => {
+	url = cleanUrl(url);
+	if (knownJsSrcRE.test(url)) return true;
+	if (!path.extname(url) && url[url.length - 1] !== "/") return true;
+	return false;
+};
+const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
+const importQueryRE = /(\?|&)import=?(?:&|$)/;
+const directRequestRE$1 = /(\?|&)direct=?(?:&|$)/;
+const InternalPrefixRE = new RegExp(`^(?:${[
+	FS_PREFIX,
+	VALID_ID_PREFIX,
+	CLIENT_PUBLIC_PATH,
+	ENV_PUBLIC_PATH
+].join("|")})`);
+const trailingSeparatorRE = /[?&]$/;
+const isImportRequest = (url) => importQueryRE.test(url);
+const isInternalRequest = (url) => InternalPrefixRE.test(url);
+function removeImportQuery(url) {
+	return url.replace(importQueryRE, "$1").replace(trailingSeparatorRE, "");
+}
+function removeDirectQuery(url) {
+	return url.replace(directRequestRE$1, "$1").replace(trailingSeparatorRE, "");
+}
+const urlRE$1 = /(\?|&)url(?:&|$)/;
+const rawRE$1 = /(\?|&)raw(?:&|$)/;
+function removeUrlQuery(url) {
+	return url.replace(urlRE$1, "$1").replace(trailingSeparatorRE, "");
+}
+function injectQuery(url, queryToInject) {
+	const { file, postfix } = splitFileAndPostfix(url);
+	return `${isWindows ? slash(file) : file}?${queryToInject}${postfix[0] === "?" ? `&${postfix.slice(1)}` : postfix}`;
+}
+const timestampRE = /\bt=\d{13}&?\b/;
+function removeTimestampQuery(url) {
+	return url.replace(timestampRE, "").replace(trailingSeparatorRE, "");
+}
+async function asyncReplace(input, re, replacer) {
+	let match;
+	let remaining = input;
+	let rewritten = "";
+	while (match = re.exec(remaining)) {
+		rewritten += remaining.slice(0, match.index);
+		rewritten += await replacer(match);
+		remaining = remaining.slice(match.index + match[0].length);
+	}
+	rewritten += remaining;
+	return rewritten;
+}
+function timeFrom(start, subtract = 0) {
+	const time = performance$1.now() - start - subtract;
+	const timeString = (time.toFixed(2) + `ms`).padEnd(5, " ");
+	if (time < 10) return import_picocolors.default.green(timeString);
+	else if (time < 50) return import_picocolors.default.yellow(timeString);
+	else return import_picocolors.default.red(timeString);
+}
+/**
+* pretty url for logging.
+*/
+function prettifyUrl(url, root) {
+	url = removeTimestampQuery(url);
+	const isAbsoluteFile = url.startsWith(root);
+	if (isAbsoluteFile || url.startsWith(FS_PREFIX)) {
+		const file = path.posix.relative(root, isAbsoluteFile ? url : fsPathFromId(url));
+		return import_picocolors.default.dim(file);
+	} else return import_picocolors.default.dim(url);
+}
+function isObject$1(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isDefined(value) {
+	return value != null;
+}
+function tryStatSync(file) {
+	try {
+		return fs.statSync(file, { throwIfNoEntry: false });
+	} catch {}
+}
+function lookupFile(dir, fileNames) {
+	while (dir) {
+		for (const fileName of fileNames) {
+			const fullPath = path.join(dir, fileName);
+			if (tryStatSync(fullPath)?.isFile()) return fullPath;
+		}
+		const parentDir = path.dirname(dir);
+		if (parentDir === dir) return;
+		dir = parentDir;
+	}
+}
+function isFilePathESM(filePath, packageCache) {
+	if (/\.m[jt]s$/.test(filePath)) return true;
+	else if (/\.c[jt]s$/.test(filePath)) return false;
+	else try {
+		return findNearestPackageData(path.dirname(filePath), packageCache)?.data.type === "module";
+	} catch {
+		return false;
+	}
+}
+const splitRE = /\r?\n/g;
+const range = 2;
+function pad(source, n = 2) {
+	return source.split(splitRE).map((l) => ` `.repeat(n) + l).join(`\n`);
+}
+function posToNumber(source, pos) {
+	if (typeof pos === "number") return pos;
+	const lines = source.split(splitRE);
+	const { line, column } = pos;
+	let start = 0;
+	for (let i = 0; i < line - 1 && i < lines.length; i++) start += lines[i].length + 1;
+	return start + column;
+}
+function numberToPos(source, offset) {
+	if (typeof offset !== "number") return offset;
+	if (offset > source.length) throw new Error(`offset is longer than source length! offset ${offset} > length ${source.length}`);
+	const lines = source.slice(0, offset).split(splitRE);
+	return {
+		line: lines.length,
+		column: lines[lines.length - 1].length
+	};
+}
+const MAX_DISPLAY_LEN = 120;
+const ELLIPSIS = "...";
+function generateCodeFrame(source, start = 0, end) {
+	start = Math.max(posToNumber(source, start), 0);
+	end = Math.min(end !== void 0 ? posToNumber(source, end) : start, source.length);
+	const lastPosLine = end !== void 0 ? numberToPos(source, end).line : numberToPos(source, start).line + range;
+	const lineNumberWidth = Math.max(3, String(lastPosLine).length + 1);
+	const lines = source.split(splitRE);
+	let count = 0;
+	const res = [];
+	for (let i = 0; i < lines.length; i++) {
+		count += lines[i].length;
+		if (count >= start) {
+			for (let j = i - range; j <= i + range || end > count; j++) {
+				if (j < 0 || j >= lines.length) continue;
+				const line = j + 1;
+				const lineLength = lines[j].length;
+				const pad = Math.max(start - (count - lineLength), 0);
+				const underlineLength = Math.max(1, end > count ? lineLength - pad : end - start);
+				let displayLine = lines[j];
+				let underlinePad = pad;
+				if (lineLength > MAX_DISPLAY_LEN) {
+					let startIdx = 0;
+					if (j === i) {
+						if (underlineLength > MAX_DISPLAY_LEN) startIdx = pad;
+						else {
+							const center = pad + Math.floor(underlineLength / 2);
+							startIdx = Math.max(0, center - Math.floor(MAX_DISPLAY_LEN / 2));
+						}
+						underlinePad = Math.max(0, pad - startIdx) + (startIdx > 0 ? 3 : 0);
+					}
+					const prefix = startIdx > 0 ? ELLIPSIS : "";
+					const suffix = lineLength - startIdx > MAX_DISPLAY_LEN ? ELLIPSIS : "";
+					const sliceLen = MAX_DISPLAY_LEN - prefix.length - suffix.length;
+					displayLine = prefix + displayLine.slice(startIdx, startIdx + sliceLen) + suffix;
+				}
+				res.push(`${line}${" ".repeat(lineNumberWidth - String(line).length)}|  ${displayLine}`);
+				if (j === i) {
+					const underline = "^".repeat(Math.min(underlineLength, MAX_DISPLAY_LEN));
+					res.push(`${" ".repeat(lineNumberWidth)}|  ` + " ".repeat(underlinePad) + underline);
+				} else if (j > i) {
+					if (end > count) {
+						const length = Math.max(Math.min(end - count, lineLength), 1);
+						const underline = "^".repeat(Math.min(length, MAX_DISPLAY_LEN));
+						res.push(`${" ".repeat(lineNumberWidth)}|  ` + underline);
+					}
+					count += lineLength + 1;
+				}
+			}
+			break;
+		}
+		count++;
+	}
+	return res.join("\n");
+}
+function isFileReadable(filename) {
+	if (!tryStatSync(filename)) return false;
+	try {
+		fs.accessSync(filename, fs.constants.R_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const splitFirstDirRE = /(.+?)[\\/](.+)/;
+/**
+* Delete every file and subdirectory. **The given directory must exist.**
+* Pass an optional `skip` array to preserve files under the root directory.
+*/
+function emptyDir(dir, skip) {
+	const skipInDir = [];
+	let nested = null;
+	if (skip?.length) for (const file of skip) if (path.dirname(file) !== ".") {
+		const matched = splitFirstDirRE.exec(file);
+		if (matched) {
+			nested ??= /* @__PURE__ */ new Map();
+			const [, nestedDir, skipPath] = matched;
+			let nestedSkip = nested.get(nestedDir);
+			if (!nestedSkip) {
+				nestedSkip = [];
+				nested.set(nestedDir, nestedSkip);
+			}
+			if (!nestedSkip.includes(skipPath)) nestedSkip.push(skipPath);
+		}
+	} else skipInDir.push(file);
+	for (const file of fs.readdirSync(dir)) {
+		if (skipInDir.includes(file)) continue;
+		if (nested?.has(file)) emptyDir(path.resolve(dir, file), nested.get(file));
+		else fs.rmSync(path.resolve(dir, file), {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function copyDir(srcDir, destDir) {
+	fs.mkdirSync(destDir, { recursive: true });
+	for (const file of fs.readdirSync(srcDir)) {
+		const srcFile = path.resolve(srcDir, file);
+		if (srcFile === destDir) continue;
+		const destFile = path.resolve(destDir, file);
+		if (fs.statSync(srcFile).isDirectory()) copyDir(srcFile, destFile);
+		else fs.copyFileSync(srcFile, destFile);
+	}
+}
+const ERR_SYMLINK_IN_RECURSIVE_READDIR = "ERR_SYMLINK_IN_RECURSIVE_READDIR";
+async function recursiveReaddir(dir) {
+	if (!fs.existsSync(dir)) return [];
+	let dirents;
+	try {
+		dirents = await fsp.readdir(dir, { withFileTypes: true });
+	} catch (e) {
+		if (e.code === "EACCES") return [];
+		throw e;
+	}
+	if (dirents.some((dirent) => dirent.isSymbolicLink())) {
+		const err = /* @__PURE__ */ new Error("Symbolic links are not supported in recursiveReaddir");
+		err.code = ERR_SYMLINK_IN_RECURSIVE_READDIR;
+		throw err;
+	}
+	return (await Promise.all(dirents.map((dirent) => {
+		const res = path.resolve(dir, dirent.name);
+		return dirent.isDirectory() ? recursiveReaddir(res) : normalizePath(res);
+	}))).flat(1);
+}
+let safeRealpathSync = isWindows ? windowsSafeRealPathSync : fs.realpathSync.native;
+const windowsNetworkMap = /* @__PURE__ */ new Map();
+function windowsMappedRealpathSync(path) {
+	const realPath = fs.realpathSync.native(path);
+	if (realPath.startsWith("\\\\")) {
+		for (const [network, volume] of windowsNetworkMap) if (realPath.startsWith(network)) return realPath.replace(network, volume);
+	}
+	return realPath;
+}
+const parseNetUseRE = /^\w* +(\w:) +([^ ]+)\s/;
+let firstSafeRealPathSyncRun = false;
+function windowsSafeRealPathSync(path) {
+	if (!firstSafeRealPathSyncRun) {
+		optimizeSafeRealPathSync();
+		firstSafeRealPathSyncRun = true;
+	}
+	return fs.realpathSync(path);
+}
+function optimizeSafeRealPathSync() {
+	try {
+		fs.realpathSync.native(path.resolve("./"));
+	} catch (error) {
+		if (error.message.includes("EISDIR: illegal operation on a directory")) {
+			safeRealpathSync = fs.realpathSync;
+			return;
+		}
+	}
+	exec("net use", (error, stdout) => {
+		if (error) return;
+		const lines = stdout.split("\n");
+		for (const line of lines) {
+			const m = parseNetUseRE.exec(line);
+			if (m) windowsNetworkMap.set(m[2], m[1]);
+		}
+		if (windowsNetworkMap.size === 0) safeRealpathSync = fs.realpathSync.native;
+		else safeRealpathSync = windowsMappedRealpathSync;
+	});
+}
+function ensureWatchedFile(watcher, file, root) {
+	if (file && !file.startsWith(withTrailingSlash(root)) && !file.includes("\0") && fs.existsSync(file)) watcher.add(path.resolve(file));
+}
+function joinSrcset(ret) {
+	return ret.map(({ url, descriptor }) => url + (descriptor ? ` ${descriptor}` : "")).join(", ");
+}
+/**
+This regex represents a loose rule of an “image candidate string” and "image set options".
+
+@see https://html.spec.whatwg.org/multipage/images.html#srcset-attribute
+@see https://drafts.csswg.org/css-images-4/#image-set-notation
+
+The Regex has named capturing groups `url` and `descriptor`.
+The `url` group can be:
+* any CSS function
+* CSS string (single or double-quoted)
+* URL string (unquoted)
+The `descriptor` is anything after the space and before the comma.
+*/
+const imageCandidateRegex = /(?:^|\s|(?<=,))(?<url>[\w-]+\([^)]*\)|"[^"]*"|'[^']*'|[^,]\S*[^,])\s*(?:\s(?<descriptor>\w[^,]+))?(?:,|$)/g;
+const escapedSpaceCharacters = /(?: |\\t|\\n|\\f|\\r)+/g;
+function parseSrcset(string) {
+	const matches = string.trim().replace(escapedSpaceCharacters, " ").replace(/\r?\n/, "").replace(/,\s+/, ", ").replaceAll(/\s+/g, " ").matchAll(imageCandidateRegex);
+	return Array.from(matches, ({ groups }) => ({
+		url: groups?.url?.trim() ?? "",
+		descriptor: groups?.descriptor?.trim() ?? ""
+	})).filter(({ url }) => !!url);
+}
+function processSrcSet(srcs, replacer) {
+	return Promise.all(parseSrcset(srcs).map(async ({ url, descriptor }) => ({
+		url: await replacer({
+			url,
+			descriptor
+		}),
+		descriptor
+	}))).then(joinSrcset);
+}
+function processSrcSetSync(srcs, replacer) {
+	return joinSrcset(parseSrcset(srcs).map(({ url, descriptor }) => ({
+		url: replacer({
+			url,
+			descriptor
+		}),
+		descriptor
+	})));
+}
+const windowsDriveRE = /^[A-Z]:/;
+const replaceWindowsDriveRE = /^([A-Z]):\//;
+const linuxAbsolutePathRE = /^\/[^/]/;
+function escapeToLinuxLikePath(path) {
+	if (windowsDriveRE.test(path)) return path.replace(replaceWindowsDriveRE, "/windows/$1/");
+	if (linuxAbsolutePathRE.test(path)) return `/linux${path}`;
+	return path;
+}
+const revertWindowsDriveRE = /^\/windows\/([A-Z])\//;
+function unescapeToLinuxLikePath(path) {
+	if (path.startsWith("/linux/")) return path.slice(6);
+	if (path.startsWith("/windows/")) return path.replace(revertWindowsDriveRE, "$1:/");
+	return path;
+}
+const nullSourceMap = {
+	names: [],
+	sources: [],
+	mappings: "",
+	version: 3
+};
+/**
+* Combines multiple sourcemaps into a single sourcemap.
+* Note that the length of sourcemapList must be 2.
+*/
+function combineSourcemaps(filename, sourcemapList) {
+	if (sourcemapList.length === 0 || sourcemapList.every((m) => m.sources.length === 0)) return { ...nullSourceMap };
+	sourcemapList = sourcemapList.map((sourcemap) => {
+		const newSourcemaps = { ...sourcemap };
+		newSourcemaps.sources = sourcemap.sources.map((source) => source ? escapeToLinuxLikePath(source) : null);
+		if (sourcemap.sourceRoot) newSourcemaps.sourceRoot = escapeToLinuxLikePath(sourcemap.sourceRoot);
+		return newSourcemaps;
+	});
+	const escapedFilename = escapeToLinuxLikePath(filename);
+	let map;
+	let mapIndex = 1;
+	if (sourcemapList.slice(0, -1).find((m) => m.sources.length !== 1) === void 0) map = remapping(sourcemapList, () => null);
+	else map = remapping(sourcemapList[0], function loader(sourcefile) {
+		if (sourcefile === escapedFilename && sourcemapList[mapIndex]) return sourcemapList[mapIndex++];
+		else return null;
+	});
+	if (!map.file) delete map.file;
+	map.sources = map.sources.map((source) => source ? unescapeToLinuxLikePath(source) : source);
+	map.file = filename;
+	return map;
+}
+function unique(arr) {
+	return Array.from(new Set(arr));
+}
+/**
+* Returns resolved localhost address when `dns.lookup` result differs from DNS
+*
+* `dns.lookup` result is same when defaultResultOrder is `verbatim`.
+* Even if defaultResultOrder is `ipv4first`, `dns.lookup` result maybe same.
+* For example, when IPv6 is not supported on that machine/network.
+*/
+function getLocalhostAddressIfDiffersFromDNS() {
+	if (promises.getDefaultResultOrder && promises.getDefaultResultOrder() === "verbatim") return;
+	return Promise.all([promises.lookup("localhost"), promises.lookup("localhost", { verbatim: true })]).then(([nodeResult, dnsResult]) => {
+		return nodeResult.family === dnsResult.family && nodeResult.address === dnsResult.address ? void 0 : nodeResult.address;
+	});
+}
+function diffDnsOrderChange(oldUrls, newUrls) {
+	return !(oldUrls === newUrls || oldUrls && newUrls && arrayEqual(oldUrls.local, newUrls.local) && arrayEqual(oldUrls.network, newUrls.network));
+}
+async function resolveHostname(optionsHost) {
+	let host;
+	if (optionsHost === void 0 || optionsHost === false) host = "localhost";
+	else if (optionsHost === true) host = void 0;
+	else host = optionsHost;
+	let name = host === void 0 || wildcardHosts.has(host) ? "localhost" : host;
+	if (host === "localhost") {
+		const localhostAddr = await getLocalhostAddressIfDiffersFromDNS();
+		if (localhostAddr) name = localhostAddr;
+	}
+	return {
+		host,
+		name
+	};
+}
+function extractHostnamesFromCerts(certs) {
+	const certList = certs ? arraify(certs) : [];
+	if (certList.length === 0) return [];
+	return unique(certList.map((cert) => {
+		try {
+			return new crypto.X509Certificate(cert);
+		} catch {
+			return null;
+		}
+	}).flatMap((cert) => cert?.subjectAltName ? extractHostnamesFromSubjectAltName(cert.subjectAltName) : []));
+}
+function resolveServerUrls(server, options, hostname, httpsOptions, config) {
+	const address = server.address();
+	const isAddressInfo = (x) => x?.address;
+	if (!isAddressInfo(address)) return {
+		local: [],
+		network: []
+	};
+	const local = [];
+	const network = [];
+	const protocol = options.https ? "https" : "http";
+	const port = address.port;
+	const base = config.rawBase === "./" || config.rawBase === "" ? "/" : config.rawBase;
+	if (hostname.host !== void 0 && !wildcardHosts.has(hostname.host)) {
+		let hostnameName = hostname.name;
+		if (hostnameName.includes(":")) hostnameName = `[${hostnameName}]`;
+		const address = `${protocol}://${hostnameName}:${port}${base}`;
+		if (loopbackHosts.has(hostname.host)) local.push(address);
+		else network.push(address);
+	} else Object.values(os.networkInterfaces()).flatMap((nInterface) => nInterface ?? []).filter((detail) => detail.address && detail.family === "IPv4").forEach((detail) => {
+		let host = detail.address.replace("127.0.0.1", hostname.name);
+		if (host.includes(":")) host = `[${host}]`;
+		const url = `${protocol}://${host}:${port}${base}`;
+		if (detail.address.includes("127.0.0.1")) local.push(url);
+		else network.push(url);
+	});
+	const hostnamesFromCert = extractHostnamesFromCerts(httpsOptions?.cert);
+	if (hostnamesFromCert.length > 0) {
+		const existings = new Set([...local, ...network]);
+		local.push(...hostnamesFromCert.map((hostname) => `${protocol}://${hostname}:${port}${base}`).filter((url) => !existings.has(url)));
+	}
+	return {
+		local,
+		network
+	};
+}
+function extractHostnamesFromSubjectAltName(subjectAltName) {
+	const hostnames = [];
+	let remaining = subjectAltName;
+	while (remaining) {
+		const nameEndIndex = remaining.indexOf(":");
+		const name = remaining.slice(0, nameEndIndex);
+		remaining = remaining.slice(nameEndIndex + 1);
+		if (!remaining) break;
+		const isQuoted = remaining[0] === "\"";
+		let value;
+		if (isQuoted) {
+			const endQuoteIndex = remaining.indexOf("\"", 1);
+			value = JSON.parse(remaining.slice(0, endQuoteIndex + 1));
+			remaining = remaining.slice(endQuoteIndex + 1);
+		} else {
+			const maybeEndIndex = remaining.indexOf(",");
+			const endIndex = maybeEndIndex === -1 ? remaining.length : maybeEndIndex;
+			value = remaining.slice(0, endIndex);
+			remaining = remaining.slice(endIndex);
+		}
+		remaining = remaining.slice(1).trimStart();
+		if (name === "DNS" && value !== "[::1]" && !(value.startsWith("*.") && net.isIPv4(value.slice(2)))) hostnames.push(value.replace("*", "vite"));
+	}
+	return hostnames;
+}
+function arraify(target) {
+	return Array.isArray(target) ? target : [target];
+}
+const multilineCommentsRE = /\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g;
+const singlelineCommentsRE = /\/\/.*/g;
+const requestQuerySplitRE = /\?(?!.*[/|}])/;
+const requestQueryMaybeEscapedSplitRE = /\\?\?(?!.*[/|}])/;
+const blankReplacer = (match) => " ".repeat(match.length);
+function getHash(text, length = 8) {
+	const h = crypto.hash("sha256", text, "hex").substring(0, length);
+	if (length <= 64) return h;
+	return h.padEnd(length, "_");
+}
+function emptyCssComments(raw) {
+	return raw.replace(multilineCommentsRE, blankReplacer);
+}
+function backwardCompatibleWorkerPlugins(plugins) {
+	if (Array.isArray(plugins)) return plugins;
+	if (typeof plugins === "function") return plugins();
+	return [];
+}
+function deepClone(value) {
+	if (Array.isArray(value)) return value.map((v) => deepClone(v));
+	if (isObject$1(value)) {
+		const cloned = {};
+		for (const key in value) cloned[key] = deepClone(value[key]);
+		return cloned;
+	}
+	if (typeof value === "function") return value;
+	if (value instanceof RegExp) return new RegExp(value);
+	if (typeof value === "object" && value != null) throw new Error("Cannot deep clone non-plain object");
+	return value;
+}
+function mergeWithDefaultsRecursively(defaults, values) {
+	const merged = defaults;
+	for (const key in values) {
+		const value = values[key];
+		if (value === void 0) continue;
+		const existing = merged[key];
+		if (existing === void 0) {
+			merged[key] = value;
+			continue;
+		}
+		if (isObject$1(existing) && isObject$1(value)) {
+			merged[key] = mergeWithDefaultsRecursively(existing, value);
+			continue;
+		}
+		merged[key] = value;
+	}
+	return merged;
+}
+const environmentPathRE = /^environments\.[^.]+$/;
+function mergeWithDefaults(defaults, values) {
+	return mergeWithDefaultsRecursively(deepClone(defaults), values);
+}
+const runtimeDeprecatedPath = new Set(["optimizeDeps", "ssr.optimizeDeps"]);
+const rollupOptionsDeprecationCall = () => {
+	const method = process.env.VITE_DEPRECATION_TRACE ? "trace" : "warn";
+	console[method]("`optimizeDeps.rollupOptions` / `ssr.optimizeDeps.rollupOptions` is deprecated. Use `optimizeDeps.rolldownOptions` instead. Note that this option may be set by a plugin. " + (method === "trace" ? "Showing trace because VITE_DEPRECATION_TRACE is set." : "Set VITE_DEPRECATION_TRACE=1 to see where it is called."));
+};
+function setupRollupOptionCompat(buildConfig, path) {
+	buildConfig.rolldownOptions ??= buildConfig.rollupOptions;
+	if (runtimeDeprecatedPath.has(path) && buildConfig.rollupOptions && buildConfig.rolldownOptions !== buildConfig.rollupOptions) rollupOptionsDeprecationCall();
+	Object.defineProperty(buildConfig, "rollupOptions", {
+		get() {
+			return buildConfig.rolldownOptions;
+		},
+		set(newValue) {
+			if (runtimeDeprecatedPath.has(path)) rollupOptionsDeprecationCall();
+			buildConfig.rolldownOptions = newValue;
+		},
+		configurable: true,
+		enumerable: true
+	});
+}
+const rollupOptionsRootPaths = new Set([
+	"build",
+	"worker",
+	"optimizeDeps",
+	"ssr.optimizeDeps"
+]);
+/**
+* Sets up `rollupOptions` compat proxies for an environment.
+*/
+function setupRollupOptionCompatForEnvironment(environment) {
+	if (!isObject$1(environment)) return environment;
+	const merged = { ...environment };
+	if (isObject$1(merged.build)) setupRollupOptionCompat(merged.build, "build");
+	return merged;
+}
+function hasBothRollupOptionsAndRolldownOptions(options) {
+	for (const opt of [
+		options.build,
+		options.worker,
+		options.optimizeDeps,
+		options.ssr?.optimizeDeps
+	]) if (opt != null && opt.rollupOptions != null && opt.rolldownOptions != null && opt.rollupOptions !== opt.rolldownOptions) return true;
+	return false;
+}
+function mergeConfigRecursively(defaults, overrides, rootPath) {
+	const merged = { ...defaults };
+	if (rollupOptionsRootPaths.has(rootPath)) setupRollupOptionCompat(merged, rootPath);
+	for (const key in overrides) {
+		const value = overrides[key];
+		if (value == null) continue;
+		let existing = merged[key];
+		if (key === "rollupOptions" && rollupOptionsRootPaths.has(rootPath)) {
+			if (overrides.rolldownOptions) continue;
+			existing = merged.rolldownOptions;
+		}
+		if (existing == null) {
+			if (rootPath === "" && key === "environments" && isObject$1(value)) {
+				const environments = { ...value };
+				for (const envName in environments) environments[envName] = setupRollupOptionCompatForEnvironment(environments[envName]);
+				merged[key] = environments;
+			} else if (rootPath === "environments") merged[key] = setupRollupOptionCompatForEnvironment(value);
+			else merged[key] = value;
+			continue;
+		}
+		if (key === "alias" && (rootPath === "resolve" || rootPath === "")) {
+			merged[key] = mergeAlias(existing, value);
+			continue;
+		} else if (key === "assetsInclude" && rootPath === "") {
+			merged[key] = [].concat(existing, value);
+			continue;
+		} else if (((key === "noExternal" || key === "external") && (rootPath === "ssr" || rootPath === "resolve") || key === "allowedHosts" && rootPath === "server") && (existing === true || value === true)) {
+			merged[key] = true;
+			continue;
+		} else if (key === "plugins" && rootPath === "worker") {
+			merged[key] = () => [...backwardCompatibleWorkerPlugins(existing), ...backwardCompatibleWorkerPlugins(value)];
+			continue;
+		} else if (key === "server" && rootPath === "server.hmr") {
+			merged[key] = value;
+			continue;
+		}
+		if (Array.isArray(existing) || Array.isArray(value)) {
+			merged[key] = [...arraify(existing), ...arraify(value)];
+			continue;
+		}
+		if (isObject$1(existing) && isObject$1(value)) {
+			merged[key] = mergeConfigRecursively(existing, value, rootPath && !environmentPathRE.test(rootPath) ? `${rootPath}.${key}` : key);
+			continue;
+		}
+		merged[key] = value;
+	}
+	return merged;
+}
+function mergeConfig(defaults, overrides, isRoot = true) {
+	if (typeof defaults === "function" || typeof overrides === "function") throw new Error(`Cannot merge config in form of callback`);
+	return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
+}
+function mergeAlias(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	if (isObject$1(a) && isObject$1(b)) return {
+		...a,
+		...b
+	};
+	return [...normalizeAlias(b), ...normalizeAlias(a)];
+}
+function normalizeAlias(o = []) {
+	return Array.isArray(o) ? o.map(normalizeSingleAlias) : Object.keys(o).map((find) => normalizeSingleAlias({
+		find,
+		replacement: o[find]
+	}));
+}
+function normalizeSingleAlias({ find, replacement, customResolver }) {
+	if (typeof find === "string" && find.endsWith("/") && replacement.endsWith("/")) {
+		find = find.slice(0, find.length - 1);
+		replacement = replacement.slice(0, replacement.length - 1);
+	}
+	const alias = {
+		find,
+		replacement
+	};
+	if (customResolver) alias.customResolver = customResolver;
+	return alias;
+}
+/**
+* Transforms transpiled code result where line numbers aren't altered,
+* so we can skip sourcemap generation during dev
+*/
+function transformStableResult(s, id, config) {
+	return {
+		code: s.toString(),
+		map: config.command === "build" && config.build.sourcemap ? s.generateMap({
+			hires: "boundary",
+			source: id
+		}) : null
+	};
+}
+async function asyncFlatten(arr) {
+	do
+		arr = (await Promise.all(arr)).flat(Infinity);
+	while (arr.some((v) => v?.then));
+	return arr;
+}
+function stripBomTag(content) {
+	if (content.charCodeAt(0) === 65279) return content.slice(1);
+	return content;
+}
+/**
+* Determine if a file is being requested with the correct case, to ensure
+* consistent behavior between dev and prod and across operating systems.
+*/
+function shouldServeFile(filePath, root) {
+	if (!isCaseInsensitiveFS) return true;
+	return hasCorrectCase(filePath, root);
+}
+/**
+* Note that we can't use realpath here, because we don't want to follow
+* symlinks.
+*/
+function hasCorrectCase(file, assets) {
+	if (file === assets) return true;
+	const parent = path.dirname(file);
+	if (fs.readdirSync(parent).includes(path.basename(file))) return hasCorrectCase(parent, assets);
+	return false;
+}
+function joinUrlSegments(a, b) {
+	if (!a || !b) return a || b || "";
+	if (a.endsWith("/")) a = a.substring(0, a.length - 1);
+	if (b[0] !== "/") b = "/" + b;
+	return a + b;
+}
+function removeLeadingSlash(str) {
+	return str[0] === "/" ? str.slice(1) : str;
+}
+function stripBase(path, base) {
+	if (path === base) return "/";
+	const devBase = withTrailingSlash(base);
+	return path.startsWith(devBase) ? path.slice(devBase.length - 1) : path;
+}
+function arrayEqual(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function evalValue(rawValue) {
+	return new Function(`
+    var console, exports, global, module, process, require
+    return (\n${rawValue}\n)
+  `)();
+}
+function getNpmPackageName(importPath) {
+	const parts = importPath.split("/");
+	if (parts[0][0] === "@") {
+		if (!parts[1]) return null;
+		return `${parts[0]}/${parts[1]}`;
+	} else return parts[0];
+}
+function getPkgName(name) {
+	return name[0] === "@" ? name.split("/")[1] : name;
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+	return str.replace(escapeRegexRE, "\\$&");
+}
+function getPackageManagerCommand(type = "install") {
+	const packageManager = process.env.npm_config_user_agent?.split(" ")[0].split("/")[0] || "npm";
+	switch (type) {
+		case "install": return packageManager === "npm" ? "npm install" : `${packageManager} add`;
+		case "uninstall": return packageManager === "npm" ? "npm uninstall" : `${packageManager} remove`;
+		case "update": return packageManager === "yarn" ? "yarn upgrade" : `${packageManager} update`;
+		default: throw new TypeError(`Unknown command type: ${type}`);
+	}
+}
+function isDevServer(server) {
+	return "pluginContainer" in server;
+}
+function createSerialPromiseQueue() {
+	let previousTask;
+	return { async run(f) {
+		const thisTask = f();
+		const depTasks = Promise.all([previousTask, thisTask]);
+		previousTask = depTasks;
+		const [, result] = await depTasks;
+		if (previousTask === depTasks) previousTask = void 0;
+		return result;
+	} };
+}
+function sortObjectKeys(obj) {
+	const sorted = {};
+	for (const key of Object.keys(obj).sort()) sorted[key] = obj[key];
+	return sorted;
+}
+function displayTime(time) {
+	if (time < 1e3) return `${time}ms`;
+	time = time / 1e3;
+	if (time < 60) return `${time.toFixed(2)}s`;
+	const mins = Math.floor(time / 60);
+	const seconds = Math.round(time % 60);
+	if (seconds === 60) return `${mins + 1}m`;
+	return `${mins}m${seconds < 1 ? "" : ` ${seconds}s`}`;
+}
+/**
+* Encodes the URI path portion (ignores part after ? or #)
+*/
+function encodeURIPath(uri) {
+	if (uri.startsWith("data:")) return uri;
+	const filePath = cleanUrl(uri);
+	const postfix = filePath !== uri ? uri.slice(filePath.length) : "";
+	return encodeURI(filePath) + postfix;
+}
+/**
+* Like `encodeURIPath`, but only replacing `%` as `%25`. This is useful for environments
+* that can handle un-encoded URIs, where `%` is the only ambiguous character.
+*/
+function partialEncodeURIPath(uri) {
+	if (uri.startsWith("data:")) return uri;
+	const filePath = cleanUrl(uri);
+	const postfix = filePath !== uri ? uri.slice(filePath.length) : "";
+	return filePath.replaceAll("%", "%25") + postfix;
+}
+function decodeURIIfPossible(input) {
+	try {
+		return decodeURI(input);
+	} catch {
+		return;
+	}
+}
+const sigtermCallbacks = /* @__PURE__ */ new Set();
+const parentSigtermCallback = async (signal, exitCode) => {
+	await Promise.all([...sigtermCallbacks].map((cb) => cb(signal, exitCode)));
+};
+const setupSIGTERMListener = (callback) => {
+	if (sigtermCallbacks.size === 0) {
+		process.once("SIGTERM", parentSigtermCallback);
+		if (process.env.CI !== "true") process.stdin.on("end", parentSigtermCallback);
+	}
+	sigtermCallbacks.add(callback);
+};
+const teardownSIGTERMListener = (callback) => {
+	sigtermCallbacks.delete(callback);
+	if (sigtermCallbacks.size === 0) {
+		process.off("SIGTERM", parentSigtermCallback);
+		if (process.env.CI !== "true") process.stdin.off("end", parentSigtermCallback);
+	}
+};
+function getServerUrlByHost(resolvedUrls, host) {
+	if (typeof host === "string") {
+		const matchedUrl = [...resolvedUrls?.local ?? [], ...resolvedUrls?.network ?? []].find((url) => url.includes(host));
+		if (matchedUrl) return matchedUrl;
+	}
+	return resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
+}
+let lastDateNow = 0;
+/**
+* Similar to `Date.now()`, but strictly monotonically increasing.
+*
+* This function will never return the same value.
+* Thus, the value may differ from the actual time.
+*
+* related: https://github.com/vitejs/vite/issues/19804
+*/
+function monotonicDateNow() {
+	const now = Date.now();
+	if (now > lastDateNow) {
+		lastDateNow = now;
+		return lastDateNow;
+	}
+	lastDateNow++;
+	return lastDateNow;
+}
+function formatAndTruncateFileList(files) {
+	const MAX_LOG_LENGTH = 500;
+	let log = "";
+	let truncated = false;
+	for (let i = 0; i < files.length; i++) {
+		const file = files[i];
+		if (log === "") log = file;
+		else if (log.length + 2 + file.length < MAX_LOG_LENGTH) log += ", " + file;
+		else {
+			log += ` and ${files.length - i} more`;
+			truncated = true;
+			break;
+		}
+	}
+	return {
+		formatted: log,
+		truncated
+	};
+}
+const hashbangRE = /^#!.*\n/;
+function getFileStartIndex(code) {
+	return hashbangRE.exec(code)?.[0].length ?? 0;
+}
+//#endregion
+//#region src/node/plugin.ts
+async function resolveEnvironmentPlugins(environment) {
+	const environmentPlugins = [];
+	for (const plugin of environment.getTopLevelConfig().plugins) {
+		if (plugin.applyToEnvironment) {
+			const applied = await plugin.applyToEnvironment(environment);
+			if (!applied) continue;
+			if (applied !== true) {
+				environmentPlugins.push(...(await asyncFlatten(arraify(applied))).filter(Boolean));
+				continue;
+			}
+		}
+		environmentPlugins.push(plugin);
+	}
+	return environmentPlugins;
+}
+/**
+* @experimental
+*/
+function perEnvironmentPlugin(name, applyToEnvironment) {
+	return {
+		name,
+		applyToEnvironment
+	};
+}
+//#endregion
+//#region src/node/plugins/reporter.ts
+function buildReporterPlugin(config) {
+	return perEnvironmentPlugin("native:reporter", (env) => {
+		const tty = process.stdout.isTTY && !process.env.CI;
+		const shouldLogInfo = LogLevels[config.logLevel || "info"] >= LogLevels.info;
+		const assetsDir = path.join(env.config.build.assetsDir, "/");
+		return viteReporterPlugin({
+			root: env.config.root,
+			isTty: !!tty,
+			isLib: !!env.config.build.lib,
+			assetsDir,
+			chunkLimit: env.config.build.chunkSizeWarningLimit,
+			logInfo: shouldLogInfo ? (msg) => env.logger.info(msg) : void 0,
+			reportCompressedSize: env.config.build.reportCompressedSize,
+			warnLargeChunks: env.config.build.minify && !env.config.build.lib && env.config.consumer === "client"
+		});
+	});
+}
+//#endregion
+//#region src/node/plugins/esbuild.ts
+const debug$14 = createDebugger("vite:esbuild");
+const IIFE_BEGIN_RE$1 = /(?:const|var)\s+\S+\s*=\s*\(?function\([^()]*\)\s*\{\s*"use strict";/;
+const validExtensionRE$1 = /\.\w+$/;
+const defaultEsbuildSupported = {
+	"dynamic-import": true,
+	"import-meta": true
+};
+let esbuild;
+const importEsbuild$1 = () => {
+	esbuild ||= import("esbuild");
+	return esbuild;
+};
+let warnedTransformWithEsbuild = false;
+const warnTransformWithEsbuildUsageOnce = () => {
+	if (warnedTransformWithEsbuild) return;
+	warnedTransformWithEsbuild = true;
+	console.warn(import_picocolors.default.yellow("`transformWithEsbuild` is deprecated and will be removed in the future. Please migrate to `transformWithOxc`."));
+};
+async function transformWithEsbuild(code, filename, options, inMap, config, watcher, ignoreEsbuildWarning = false) {
+	let loader = options?.loader;
+	if (!loader) {
+		const ext = path.extname(validExtensionRE$1.test(filename) ? filename : cleanUrl(filename)).slice(1);
+		if (ext === "cjs" || ext === "mjs") loader = "js";
+		else if (ext === "cts" || ext === "mts") loader = "ts";
+		else loader = ext;
+	}
+	let tsconfigRaw = options?.tsconfigRaw;
+	if (typeof tsconfigRaw !== "string") {
+		const meaningfulFields = [
+			"alwaysStrict",
+			"experimentalDecorators",
+			"importsNotUsedAsValues",
+			"jsx",
+			"jsxFactory",
+			"jsxFragmentFactory",
+			"jsxImportSource",
+			"preserveValueImports",
+			"target",
+			"useDefineForClassFields",
+			"verbatimModuleSyntax"
+		];
+		const compilerOptionsForFile = {};
+		if (loader === "ts" || loader === "tsx") {
+			const result = resolveTsconfig(filename, getTSConfigResolutionCache(config));
+			if (result) {
+				const { tsconfig: loadedTsconfig, tsconfigFilePaths } = result;
+				if (watcher && config) for (const tsconfigFile of tsconfigFilePaths) ensureWatchedFile(watcher, tsconfigFile, config.root);
+				const loadedCompilerOptions = loadedTsconfig.compilerOptions ?? {};
+				for (const field of meaningfulFields) if (field in loadedCompilerOptions) compilerOptionsForFile[field] = loadedCompilerOptions[field];
+			}
+		}
+		const compilerOptions = {
+			...compilerOptionsForFile,
+			...tsconfigRaw?.compilerOptions
+		};
+		if (compilerOptions.useDefineForClassFields === void 0 && compilerOptions.target === void 0) compilerOptions.useDefineForClassFields = false;
+		if (options) {
+			if (options.jsx) compilerOptions.jsx = void 0;
+			if (options.jsxFactory) compilerOptions.jsxFactory = void 0;
+			if (options.jsxFragment) compilerOptions.jsxFragmentFactory = void 0;
+			if (options.jsxImportSource) compilerOptions.jsxImportSource = void 0;
+		}
+		tsconfigRaw = {
+			...tsconfigRaw,
+			compilerOptions
+		};
+	}
+	const resolvedOptions = {
+		sourcemap: true,
+		sourcefile: filename,
+		...options,
+		loader,
+		tsconfigRaw
+	};
+	delete resolvedOptions.include;
+	delete resolvedOptions.exclude;
+	delete resolvedOptions.jsxInject;
+	let transform;
+	try {
+		transform = (await importEsbuild$1()).transform;
+	} catch (e) {
+		throw new Error("Failed to load `transformWithEsbuild`. It is deprecated and it now requires esbuild to be installed separately. If you are a package author, please migrate to `transformWithOxc` instead.", { cause: e });
+	}
+	if (!ignoreEsbuildWarning) warnTransformWithEsbuildUsageOnce();
+	try {
+		const result = await transform(code, resolvedOptions);
+		let map;
+		if (inMap && resolvedOptions.sourcemap) {
+			const nextMap = JSON.parse(result.map);
+			nextMap.sourcesContent = [];
+			map = combineSourcemaps(filename, [nextMap, inMap]);
+		} else map = resolvedOptions.sourcemap && resolvedOptions.sourcemap !== "inline" ? JSON.parse(result.map) : { mappings: "" };
+		return {
+			...result,
+			map
+		};
+	} catch (e) {
+		debug$14?.(`esbuild error with options used: `, resolvedOptions);
+		if (e.errors) {
+			e.frame = "";
+			e.errors.forEach((m) => {
+				if (m.text === "Experimental decorators are not currently enabled" || m.text === "Parameter decorators only work when experimental decorators are enabled") m.text += ". Vite 5 now uses esbuild 0.18 and you need to enable them by adding \"experimentalDecorators\": true in your \"tsconfig.json\" file.";
+				e.frame += `\n` + prettifyMessage(m, code);
+			});
+			e.loc = e.errors[0].location;
+		}
+		throw e;
+	}
+}
+const rollupToEsbuildFormatMap = {
+	es: "esm",
+	cjs: "cjs",
+	iife: void 0
+};
+const injectEsbuildHelpers = (esbuildCode, format) => {
+	const contentIndex = format === "iife" ? Math.max(esbuildCode.search(IIFE_BEGIN_RE$1), 0) : format === "umd" ? esbuildCode.indexOf(`(function(`) : 0;
+	if (contentIndex > 0) {
+		const esbuildHelpers = esbuildCode.slice(0, contentIndex);
+		return esbuildCode.slice(contentIndex).replace("\"use strict\";", (m) => m + esbuildHelpers);
+	}
+	return esbuildCode;
+};
+const buildEsbuildPlugin = () => {
+	return {
+		name: "vite:esbuild-transpile",
+		applyToEnvironment(environment) {
+			return environment.config.esbuild !== false;
+		},
+		async renderChunk(code, chunk, opts) {
+			if (this.environment.config.isOutputOptionsForLegacyChunks?.(opts)) return null;
+			const config = this.environment.config;
+			const options = resolveEsbuildTranspileOptions(config, opts.format);
+			if (!options) return null;
+			const res = await transformWithEsbuild(code, chunk.fileName, options, void 0, config, void 0, true);
+			if (config.build.lib) res.code = injectEsbuildHelpers(res.code, opts.format);
+			return res;
+		}
+	};
+};
+function resolveEsbuildTranspileOptions(config, format) {
+	const target = config.build.target;
+	const minify = config.build.minify === "esbuild";
+	if ((!target || target === "esnext") && !minify) return null;
+	const isEsLibBuild = config.build.lib && format === "es";
+	const esbuildOptions = config.esbuild || {};
+	const options = {
+		...esbuildOptions,
+		loader: "js",
+		target: target || void 0,
+		format: rollupToEsbuildFormatMap[format],
+		supported: {
+			...defaultEsbuildSupported,
+			...esbuildOptions.supported
+		}
+	};
+	if (!minify) return {
+		...options,
+		minify: false,
+		minifyIdentifiers: false,
+		minifySyntax: false,
+		minifyWhitespace: false,
+		treeShaking: false
+	};
+	if (options.minifyIdentifiers != null || options.minifySyntax != null || options.minifyWhitespace != null) if (isEsLibBuild) return {
+		...options,
+		minify: false,
+		minifyIdentifiers: options.minifyIdentifiers ?? true,
+		minifySyntax: options.minifySyntax ?? true,
+		minifyWhitespace: false,
+		treeShaking: true
+	};
+	else return {
+		...options,
+		minify: false,
+		minifyIdentifiers: options.minifyIdentifiers ?? true,
+		minifySyntax: options.minifySyntax ?? true,
+		minifyWhitespace: options.minifyWhitespace ?? true,
+		treeShaking: true
+	};
+	if (isEsLibBuild) return {
+		...options,
+		minify: false,
+		minifyIdentifiers: true,
+		minifySyntax: true,
+		minifyWhitespace: false,
+		treeShaking: true
+	};
+	else return {
+		...options,
+		minify: true,
+		treeShaking: true
+	};
+}
+function prettifyMessage(m, code) {
+	let res = import_picocolors.default.yellow(m.text);
+	if (m.location) res += `\n` + generateCodeFrame(code, m.location);
+	return res + `\n`;
+}
+let globalTSConfigResolutionCache;
+const tsconfigResolutionCacheMap = /* @__PURE__ */ new WeakMap();
+function getTSConfigResolutionCache(config) {
+	if (!config) return globalTSConfigResolutionCache ??= new TsconfigCache();
+	let cache = tsconfigResolutionCacheMap.get(config);
+	if (!cache) {
+		cache = new TsconfigCache();
+		tsconfigResolutionCacheMap.set(config, cache);
+	}
+	return cache;
+}
+function reloadOnTsconfigChange(server, changedFile) {
+	if (changedFile.endsWith(".json")) {
+		const cache = getTSConfigResolutionCache(server.config);
+		if (changedFile.endsWith("/tsconfig.json")) {
+			server.config.logger.info(`changed tsconfig file detected: ${changedFile} - Clearing cache and forcing full-reload to ensure TypeScript is compiled with updated config values.`, {
+				clear: server.config.clearScreen,
+				timestamp: true
+			});
+			for (const environment of Object.values(server.environments)) environment.moduleGraph.invalidateAll();
+			cache.clear();
+			for (const environment of Object.values(server.environments)) environment.hot.send({
+				type: "full-reload",
+				path: "*"
+			});
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/artichokie@0.4.3/node_modules/artichokie/dist/index.js
+const AsyncFunction = async function() {}.constructor;
+const codeToDataUrl = (code) => `data:application/javascript,${encodeURIComponent(code + "\n//# sourceURL=[worker-eval(artichokie)]")}`;
+const viteSsrDynamicImport = "__vite_ssr_dynamic_import__";
+const stackBlitzImport = "𝐢𝐦𝐩𝐨𝐫𝐭";
+var Worker$1 = class {
+	/** @internal */
+	_isModule;
+	/** @internal */
+	_code;
+	/** @internal */
+	_parentFunctions;
+	/** @internal */
+	_max;
+	/** @internal */
+	_pool;
+	/** @internal */
+	_idlePool;
+	/** @internal */
+	_queue;
+	constructor(fn, options = {}) {
+		this._isModule = options.type === "module";
+		this._code = genWorkerCode(fn, this._isModule, 5 * 1e3, options.parentFunctions ?? {});
+		this._parentFunctions = options.parentFunctions ?? {};
+		const defaultMax = Math.max(1, (os.availableParallelism?.() ?? os.cpus().length) - 1);
+		this._max = options.max || defaultMax;
+		this._pool = [];
+		this._idlePool = [];
+		this._queue = [];
+	}
+	async run(...args) {
+		const worker = await this._getAvailableWorker();
+		return new Promise((resolve, reject) => {
+			worker.currentResolve = resolve;
+			worker.currentReject = reject;
+			worker.postMessage({ args });
+		});
+	}
+	stop() {
+		this._pool.forEach((w) => w.unref());
+		this._queue.forEach(([, reject]) => reject(/* @__PURE__ */ new Error("Main worker pool stopped before a worker was available.")));
+		this._pool = [];
+		this._idlePool = [];
+		this._queue = [];
+	}
+	/** @internal */
+	_createWorker(parentFunctionSyncMessagePort, parentFunctionAsyncMessagePort, lockState) {
+		const options = {
+			workerData: [
+				parentFunctionSyncMessagePort,
+				parentFunctionAsyncMessagePort,
+				lockState
+			],
+			transferList: [parentFunctionSyncMessagePort, parentFunctionAsyncMessagePort]
+		};
+		if (this._isModule) return new Worker(new URL(codeToDataUrl(this._code)), options);
+		return new Worker(this._code, {
+			...options,
+			eval: true
+		});
+	}
+	/** @internal */
+	async _getAvailableWorker() {
+		if (this._idlePool.length) return this._idlePool.shift();
+		if (this._pool.length < this._max) {
+			const parentFunctionResponder = createParentFunctionResponder(this._parentFunctions);
+			const worker = this._createWorker(parentFunctionResponder.workerPorts.sync, parentFunctionResponder.workerPorts.async, parentFunctionResponder.lockState);
+			worker.on("message", async (args) => {
+				if ("result" in args) {
+					worker.currentResolve?.(args.result);
+					worker.currentResolve = null;
+				} else {
+					if (args.error instanceof ReferenceError) args.error.message += ". Maybe you forgot to pass the function to parentFunction?";
+					worker.currentReject?.(args.error);
+					worker.currentReject = null;
+				}
+				this._assignDoneWorker(worker);
+			});
+			worker.on("error", (err) => {
+				worker.currentReject?.(err);
+				worker.currentReject = null;
+				parentFunctionResponder.close();
+			});
+			worker.on("exit", (code) => {
+				const i = this._pool.indexOf(worker);
+				if (i > -1) this._pool.splice(i, 1);
+				if (code !== 0 && worker.currentReject) {
+					worker.currentReject(/* @__PURE__ */ new Error(`Worker stopped with non-0 exit code ${code}`));
+					worker.currentReject = null;
+					parentFunctionResponder.close();
+				}
+			});
+			this._pool.push(worker);
+			return worker;
+		}
+		let resolve;
+		let reject;
+		const onWorkerAvailablePromise = new Promise((r, rj) => {
+			resolve = r;
+			reject = rj;
+		});
+		this._queue.push([resolve, reject]);
+		return onWorkerAvailablePromise;
+	}
+	/** @internal */
+	_assignDoneWorker(worker) {
+		if (this._queue.length) {
+			const [resolve] = this._queue.shift();
+			resolve(worker);
+			return;
+		}
+		this._idlePool.push(worker);
+	}
+};
+function createParentFunctionResponder(parentFunctions) {
+	const lockState = new Int32Array(new SharedArrayBuffer(4));
+	const unlock = () => {
+		Atomics.store(lockState, 0, 0);
+		Atomics.notify(lockState, 0);
+	};
+	const parentFunctionSyncMessageChannel = new MessageChannel();
+	const parentFunctionAsyncMessageChannel = new MessageChannel();
+	const parentFunctionSyncMessagePort = parentFunctionSyncMessageChannel.port1;
+	const parentFunctionAsyncMessagePort = parentFunctionAsyncMessageChannel.port1;
+	const syncResponse = (data) => {
+		parentFunctionSyncMessagePort.postMessage(data);
+		unlock();
+	};
+	parentFunctionSyncMessagePort.on("message", async (args) => {
+		let syncResult;
+		try {
+			syncResult = parentFunctions[args.name](...args.args);
+		} catch (error) {
+			syncResponse({
+				id: args.id,
+				error
+			});
+			return;
+		}
+		if (!(typeof syncResult === "object" && syncResult !== null && "then" in syncResult && typeof syncResult.then === "function")) {
+			syncResponse({
+				id: args.id,
+				result: syncResult
+			});
+			return;
+		}
+		syncResponse({
+			id: args.id,
+			isAsync: true
+		});
+		try {
+			const result = await syncResult;
+			parentFunctionAsyncMessagePort.postMessage({
+				id: args.id,
+				result
+			});
+		} catch (error) {
+			parentFunctionAsyncMessagePort.postMessage({
+				id: args.id,
+				error
+			});
+		}
+	});
+	parentFunctionSyncMessagePort.unref();
+	return {
+		close: () => {
+			parentFunctionSyncMessagePort.close();
+			parentFunctionAsyncMessagePort.close();
+		},
+		lockState,
+		workerPorts: {
+			sync: parentFunctionSyncMessageChannel.port2,
+			async: parentFunctionAsyncMessageChannel.port2
+		}
+	};
+}
+function genWorkerCode(fn, isModule, waitTimeout, parentFunctions) {
+	const createLock = (performance, lockState) => {
+		return {
+			lock: () => {
+				Atomics.store(lockState, 0, 1);
+			},
+			waitUnlock: () => {
+				let utilizationBefore;
+				while (true) {
+					const status = Atomics.wait(lockState, 0, 1, waitTimeout);
+					if (status === "timed-out") {
+						if (utilizationBefore === void 0) {
+							utilizationBefore = performance.eventLoopUtilization();
+							continue;
+						}
+						utilizationBefore = performance.eventLoopUtilization(utilizationBefore);
+						if (utilizationBefore.utilization > .9) continue;
+						throw new Error(status);
+					}
+					break;
+				}
+			}
+		};
+	};
+	const createParentFunctionRequester = (syncPort, asyncPort, receive, lock) => {
+		let id = 0;
+		const resolvers = /* @__PURE__ */ new Map();
+		const call = (key) => (...args) => {
+			id++;
+			lock.lock();
+			syncPort.postMessage({
+				id,
+				name: key,
+				args
+			});
+			lock.waitUnlock();
+			const resArgs = receive(syncPort).message;
+			if (resArgs.isAsync) {
+				let resolve, reject;
+				const promise = new Promise((res, rej) => {
+					resolve = res;
+					reject = rej;
+				});
+				resolvers.set(id, {
+					resolve,
+					reject
+				});
+				return promise;
+			}
+			if ("error" in resArgs) throw resArgs.error;
+			else return resArgs.result;
+		};
+		asyncPort.on("message", (args) => {
+			const id = args.id;
+			if (resolvers.has(id)) {
+				const { resolve, reject } = resolvers.get(id);
+				resolvers.delete(id);
+				if ("result" in args) resolve(args.result);
+				else reject(args.error);
+			}
+		});
+		return { call };
+	};
+	const fnString = fn.toString().replaceAll(stackBlitzImport, "import").replaceAll(viteSsrDynamicImport, "import");
+	return `
+${isModule ? "import { parentPort, receiveMessageOnPort, workerData } from 'worker_threads'" : "const { parentPort, receiveMessageOnPort, workerData } = require('worker_threads')"}
+${isModule ? "import { performance } from 'node:perf_hooks'" : "const { performance } = require('node:perf_hooks')"}
+const [parentFunctionSyncMessagePort, parentFunctionAsyncMessagePort, lockState] = workerData
+const waitTimeout = ${waitTimeout}
+const createLock = ${createLock.toString()}
+const parentFunctionRequester = (${createParentFunctionRequester.toString()})(
+  parentFunctionSyncMessagePort,
+  parentFunctionAsyncMessagePort,
+  receiveMessageOnPort,
+  createLock(performance, lockState)
+)
+
+const doWorkPromise = (async () => {
+  ${Object.keys(parentFunctions).map((key) => `const ${key} = parentFunctionRequester.call(${JSON.stringify(key)});`).join("\n")}
+  return await (${fnString})()
+})()
+let doWork
+
+parentPort.on('message', async (args) => {
+  doWork ||= await doWorkPromise
+
+  try {
+    const res = await doWork(...args.args)
+    parentPort.postMessage({ result: res })
+  } catch (e) {
+    parentPort.postMessage({ error: e })
+  }
+})
+  `;
+}
+const importRe = /\bimport\s*\(/g;
+const internalImportName = "__artichokie_local_import__";
+var FakeWorker = class {
+	/** @internal */
+	_fn;
+	constructor(fn, options = {}) {
+		const declareRequire = options.type !== "module";
+		const argsAndCode = genFakeWorkerArgsAndCode(fn, declareRequire, options.parentFunctions ?? {});
+		const localImport = (specifier) => import(specifier);
+		const args = [
+			...declareRequire ? [createRequire(import.meta.url)] : [],
+			localImport,
+			options.parentFunctions
+		];
+		this._fn = new AsyncFunction(...argsAndCode)(...args);
+	}
+	async run(...args) {
+		try {
+			return await (await this._fn)(...args);
+		} catch (err) {
+			if (err instanceof ReferenceError) err.message += ". Maybe you forgot to pass the function to parentFunction?";
+			throw err;
+		}
+	}
+	stop() {}
+};
+function genFakeWorkerArgsAndCode(fn, declareRequire, parentFunctions) {
+	const fnString = fn.toString().replace(importRe, `${internalImportName}(`).replaceAll(stackBlitzImport, internalImportName).replaceAll(viteSsrDynamicImport, internalImportName);
+	return [
+		...declareRequire ? ["require"] : [],
+		internalImportName,
+		"parentFunctions",
+		`
+${Object.keys(parentFunctions).map((key) => `const ${key} = parentFunctions[${JSON.stringify(key)}];`).join("\n")}
+return await (${fnString})()
+  `
+	];
+}
+var WorkerWithFallback = class {
+	/** @internal */
+	_disableReal;
+	/** @internal */
+	_realWorker;
+	/** @internal */
+	_fakeWorker;
+	/** @internal */
+	_shouldUseFake;
+	constructor(fn, options) {
+		this._disableReal = options.max !== void 0 && options.max <= 0;
+		this._realWorker = new Worker$1(fn, options);
+		this._fakeWorker = new FakeWorker(fn, options);
+		this._shouldUseFake = options.shouldUseFake;
+	}
+	async run(...args) {
+		const useFake = this._disableReal || this._shouldUseFake(...args);
+		return this[useFake ? "_fakeWorker" : "_realWorker"].run(...args);
+	}
+	stop() {
+		this._realWorker.stop();
+		this._fakeWorker.stop();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/resolve.exports@2.0.3/node_modules/resolve.exports/dist/index.mjs
+function e(e, n, r) {
+	throw new Error(r ? `No known conditions for "${n}" specifier in "${e}" package` : `Missing "${n}" specifier in "${e}" package`);
+}
+function n$1(n, i, o, f) {
+	let s, u, l = r(n, o), c = function(e) {
+		let n = new Set(["default", ...e.conditions || []]);
+		return e.unsafe || n.add(e.require ? "require" : "import"), e.unsafe || n.add(e.browser ? "browser" : "node"), n;
+	}(f || {}), a = i[l];
+	if (void 0 === a) {
+		let e, n, r, t;
+		for (t in i) n && t.length < n.length || ("/" === t[t.length - 1] && l.startsWith(t) ? (u = l.substring(t.length), n = t) : t.length > 1 && (r = t.indexOf("*", 1), ~r && (e = RegExp("^" + t.substring(0, r) + "(.*)" + t.substring(1 + r) + "$").exec(l), e && e[1] && (u = e[1], n = t))));
+		a = i[n];
+	}
+	return a || e(n, l), s = t(a, c), s || e(n, l, 1), u && function(e, n) {
+		let r, t = 0, i = e.length, o = /[*]/g, f = /[/]$/;
+		for (; t < i; t++) e[t] = o.test(r = e[t]) ? r.replace(o, n) : f.test(r) ? r + n : r;
+	}(s, u), s;
+}
+function r(e, n, r) {
+	if (e === n || "." === n) return ".";
+	let t = e + "/", i = t.length, o = n.slice(0, i) === t, f = o ? n.slice(i) : n;
+	return "#" === f[0] ? f : o || !r ? "./" === f.slice(0, 2) ? f : "./" + f : f;
+}
+function t(e, n, r) {
+	if (e) {
+		if ("string" == typeof e) return r && r.add(e), [e];
+		let i, o;
+		if (Array.isArray(e)) {
+			for (o = r || /* @__PURE__ */ new Set(), i = 0; i < e.length; i++) t(e[i], n, o);
+			if (!r && o.size) return [...o];
+		} else for (i in e) if (n.has(i)) return t(e[i], n, r);
+	}
+}
+function o(e, r, t) {
+	let i, o = e.exports;
+	if (o) {
+		if ("string" == typeof o) o = { ".": o };
+		else for (i in o) {
+			"." !== i[0] && (o = { ".": o });
+			break;
+		}
+		return n$1(e.name, o, r || ".", t);
+	}
+}
+function f(e, r, t) {
+	if (e.imports) return n$1(e.name, e.imports, r, t);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/es-module-lexer@1.7.0/node_modules/es-module-lexer/dist/lexer.js
+var ImportType;
+(function(A) {
+	A[A.Static = 1] = "Static", A[A.Dynamic = 2] = "Dynamic", A[A.ImportMeta = 3] = "ImportMeta", A[A.StaticSourcePhase = 4] = "StaticSourcePhase", A[A.DynamicSourcePhase = 5] = "DynamicSourcePhase", A[A.StaticDeferPhase = 6] = "StaticDeferPhase", A[A.DynamicDeferPhase = 7] = "DynamicDeferPhase";
+})(ImportType || (ImportType = {}));
+const A = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
+function parse$2(E, g = "@") {
+	if (!C) return init.then((() => parse$2(E)));
+	const I = E.length + 1, w = (C.__heap_base.value || C.__heap_base) + 4 * I - C.memory.buffer.byteLength;
+	w > 0 && C.memory.grow(Math.ceil(w / 65536));
+	const K = C.sa(I - 1);
+	if ((A ? B : Q)(E, new Uint16Array(C.memory.buffer, K, I)), !C.parse()) throw Object.assign(/* @__PURE__ */ new Error(`Parse error ${g}:${E.slice(0, C.e()).split("\n").length}:${C.e() - E.lastIndexOf("\n", C.e() - 1)}`), { idx: C.e() });
+	const o = [], D = [];
+	for (; C.ri();) {
+		const A = C.is(), Q = C.ie(), B = C.it(), g = C.ai(), I = C.id(), w = C.ss(), K = C.se();
+		let D;
+		C.ip() && (D = k(E.slice(-1 === I ? A - 1 : A, -1 === I ? Q + 1 : Q))), o.push({
+			n: D,
+			t: B,
+			s: A,
+			e: Q,
+			ss: w,
+			se: K,
+			d: I,
+			a: g
+		});
+	}
+	for (; C.re();) {
+		const A = C.es(), Q = C.ee(), B = C.els(), g = C.ele(), I = E.slice(A, Q), w = I[0], K = B < 0 ? void 0 : E.slice(B, g), o = K ? K[0] : "";
+		D.push({
+			s: A,
+			e: Q,
+			ls: B,
+			le: g,
+			n: "\"" === w || "'" === w ? k(I) : I,
+			ln: "\"" === o || "'" === o ? k(K) : K
+		});
+	}
+	function k(A) {
+		try {
+			return (0, eval)(A);
+		} catch (A) {}
+	}
+	return [
+		o,
+		D,
+		!!C.f(),
+		!!C.ms()
+	];
+}
+function Q(A, Q) {
+	const B = A.length;
+	let C = 0;
+	for (; C < B;) {
+		const B = A.charCodeAt(C);
+		Q[C++] = (255 & B) << 8 | B >>> 8;
+	}
+}
+function B(A, Q) {
+	const B = A.length;
+	let C = 0;
+	for (; C < B;) Q[C] = A.charCodeAt(C++);
+}
+let C;
+const E = () => {
+	return A = "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", "undefined" != typeof Buffer ? Buffer.from(A, "base64") : Uint8Array.from(atob(A), ((A) => A.charCodeAt(0)));
+	var A;
+};
+const init = WebAssembly.compile(E()).then(WebAssembly.instantiate).then((({ exports: A }) => {
+	C = A;
+}));
+//#endregion
+//#region src/node/plugins/oxc.ts
+const IIFE_BEGIN_RE = /(?:(?:(?:const|var)\s+[^.\s]+|[^.\s]+\.[^.\s]+\.[^.\s]+)\s*=\s*|^|\n)\(?function\([^()]*\)\s*\{(?:\s*"use strict";)?/;
+const UMD_BEGIN_RE = /\}\)\((?:this,\s*)?function\([^()]*\)\s*\{(?:\s*"use strict";)?/;
+const jsxExtensionsRE = /\.(?:j|t)sx\b/;
+const validExtensionRE = /\.\w+$/;
+function getRollupJsxPresets(preset) {
+	switch (preset) {
+		case "react": return {
+			runtime: "classic",
+			pragma: "React.createElement",
+			pragmaFrag: "React.Fragment",
+			importSource: "react"
+		};
+		case "react-jsx": return {
+			runtime: "automatic",
+			pragma: "React.createElement",
+			importSource: "react"
+		};
+	}
+}
+function joinNewLine(s1, s2) {
+	return s1.replace(/\n+$/, "") + "\n" + s2.replace(/^\n+/, "");
+}
+function getErrorMessage(e) {
+	if (Object.hasOwn(e, "kind")) return e.message;
+	let s = "";
+	if (e.plugin) s += `[plugin ${e.plugin}]`;
+	const id = e.id ?? e.loc?.file;
+	if (id) {
+		s += " " + id;
+		if (e.loc) s += `:${e.loc.line}:${e.loc.column}`;
+	}
+	if (s) s += "\n";
+	const message = `${e.name ?? "Error"}: ${e.message}`;
+	s += message;
+	if (e.frame) s = joinNewLine(s, e.frame);
+	if (e.stack) s = joinNewLine(s, e.stack.replace(message, ""));
+	if (e.cause) {
+		s = joinNewLine(s, "Caused by:");
+		s = joinNewLine(s, getErrorMessage(e.cause).split("\n").map((line) => "  " + line).join("\n"));
+	}
+	return s;
+}
+async function transformWithOxc(code, filename, options, inMap, config, watcher) {
+	let lang = options?.lang;
+	if (!lang) {
+		const ext = path.extname(validExtensionRE.test(filename) ? filename : cleanUrl(filename)).slice(1);
+		if (ext === "cjs" || ext === "mjs") lang = "js";
+		else if (ext === "cts" || ext === "mts") lang = "ts";
+		else lang = ext;
+	}
+	const result = transformSync(filename, code, {
+		sourcemap: true,
+		...options,
+		inputMap: inMap,
+		lang
+	}, getTSConfigResolutionCache(config));
+	if (watcher && config && result.tsconfigFilePaths && result.tsconfigFilePaths.length > 0) for (const tsconfigFile of result.tsconfigFilePaths) ensureWatchedFile(watcher, normalizePath(tsconfigFile), config.root);
+	if (result.errors.length > 0) {
+		let summary = `Transform failed with ${result.errors.length} error${result.errors.length < 2 ? "" : "s"}:\n`;
+		for (let i = 0; i < result.errors.length; i++) {
+			summary += "\n";
+			if (i >= 5) {
+				summary += "...";
+				break;
+			}
+			summary += getErrorMessage(result.errors[i]);
+		}
+		const wrapper = new Error(summary);
+		Object.defineProperty(wrapper, "errors", {
+			configurable: true,
+			enumerable: true,
+			get: () => result.errors,
+			set: (value) => Object.defineProperty(wrapper, "errors", {
+				configurable: true,
+				enumerable: true,
+				value
+			})
+		});
+		throw wrapper;
+	}
+	return result;
+}
+const warnedMessages = /* @__PURE__ */ new Set();
+function shouldSkipWarning(warning) {
+	if (warning.code === "UNSUPPORTED_TSCONFIG_OPTION") {
+		if (warnedMessages.has(warning.message)) return true;
+		warnedMessages.add(warning.message);
+	}
+	return false;
+}
+function oxcPlugin(config) {
+	const { jsxInject, include, exclude, jsxRefreshInclude, jsxRefreshExclude, ...oxcTransformOptions } = config.oxc;
+	const filter = createFilter$1(include || /\.(m?ts|[jt]sx)$/, exclude || /\.js$/);
+	const jsxRefreshFilter = jsxRefreshInclude || jsxRefreshExclude ? createFilter$1(jsxRefreshInclude, jsxRefreshExclude) : void 0;
+	const jsxImportSource = typeof oxcTransformOptions.jsx === "object" && oxcTransformOptions.jsx.importSource || "react";
+	const jsxImportRuntime = `${jsxImportSource}/jsx-runtime`;
+	const jsxImportDevRuntime = `${jsxImportSource}/jsx-dev-runtime`;
+	const getModifiedOxcTransformOptions = (oxcTransformOptions, id, code, environment) => {
+		const result = {
+			...oxcTransformOptions,
+			sourcemap: environment.mode !== "build" || !!environment.config.build.sourcemap
+		};
+		const jsxOptions = result.jsx;
+		const [filepath] = id.split("?");
+		const isJSX = filepath.endsWith("x");
+		if (typeof jsxOptions === "object" && jsxOptions.refresh && (environment.config.consumer === "server" || jsxRefreshFilter && !jsxRefreshFilter(id) || !(isJSX || code.includes(jsxImportRuntime) || code.includes(jsxImportDevRuntime)))) result.jsx = {
+			...jsxOptions,
+			refresh: false
+		};
+		if (jsxRefreshFilter?.(id) && !JS_TYPES_RE.test(cleanUrl(id))) result.lang = "js";
+		return result;
+	};
+	let server;
+	return {
+		name: "vite:oxc",
+		applyToEnvironment(environment) {
+			if (environment.config.isBundled) {
+				const { jsxInject, include = /\.(m?ts|[jt]sx)$/, exclude = /\.js$/, jsxRefreshInclude, jsxRefreshExclude, ..._transformOptions } = environment.config.oxc;
+				const transformOptions = _transformOptions;
+				transformOptions.sourcemap = environment.config.mode !== "build" || !!environment.config.build.sourcemap;
+				return viteTransformPlugin({
+					root: environment.config.root,
+					include,
+					exclude,
+					jsxRefreshInclude,
+					jsxRefreshExclude,
+					isServerConsumer: environment.config.consumer === "server",
+					jsxInject,
+					transformOptions
+				});
+			}
+			return true;
+		},
+		configureServer(_server) {
+			server = _server;
+		},
+		async transform(code, id) {
+			if (filter(id) || filter(cleanUrl(id)) || jsxRefreshFilter?.(id)) {
+				const result = await transformWithOxc(code, id, getModifiedOxcTransformOptions(oxcTransformOptions, id, code, this.environment), void 0, config, server?.watcher);
+				if (jsxInject && jsxExtensionsRE.test(id)) result.code = jsxInject + ";" + result.code;
+				for (const warning of result.warnings) if (!shouldSkipWarning(warning)) this.warn(warning);
+				return {
+					code: result.code,
+					map: result.map,
+					moduleType: "js"
+				};
+			}
+		}
+	};
+}
+function convertEsbuildConfigToOxcConfig(esbuildConfig, logger) {
+	const { jsxInject, include, exclude, ...esbuildTransformOptions } = esbuildConfig;
+	const oxcOptions = {
+		jsxInject,
+		include,
+		exclude
+	};
+	if (esbuildTransformOptions.jsx === "preserve") oxcOptions.jsx = "preserve";
+	else {
+		const jsxOptions = {};
+		switch (esbuildTransformOptions.jsx) {
+			case "automatic":
+				jsxOptions.runtime = "automatic";
+				if (esbuildTransformOptions.jsxImportSource) jsxOptions.importSource = esbuildTransformOptions.jsxImportSource;
+				break;
+			case "transform":
+				jsxOptions.runtime = "classic";
+				if (esbuildTransformOptions.jsxFactory) jsxOptions.pragma = esbuildTransformOptions.jsxFactory;
+				if (esbuildTransformOptions.jsxFragment) jsxOptions.pragmaFrag = esbuildTransformOptions.jsxFragment;
+				break;
+			default: break;
+		}
+		if (esbuildTransformOptions.jsxDev !== void 0) jsxOptions.development = esbuildTransformOptions.jsxDev;
+		if (esbuildTransformOptions.jsxSideEffects !== void 0) jsxOptions.pure = esbuildTransformOptions.jsxSideEffects;
+		oxcOptions.jsx = jsxOptions;
+	}
+	if (esbuildTransformOptions.define) oxcOptions.define = esbuildTransformOptions.define;
+	if (esbuildTransformOptions.banner) warnDeprecatedShouldBeConvertedToPluginOptions(logger, "banner");
+	if (esbuildTransformOptions.footer) warnDeprecatedShouldBeConvertedToPluginOptions(logger, "footer");
+	return oxcOptions;
+}
+function warnDeprecatedShouldBeConvertedToPluginOptions(logger, name) {
+	logger.warn(import_picocolors.default.yellow(`\`esbuild.${name}\` option was specified. But this option is deprecated and will be removed in future versions. This option can be achieved by using a plugin with transform hook, please use that instead.`));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/magic-string@0.30.21/node_modules/magic-string/dist/magic-string.es.mjs
+var BitSet = class BitSet {
+	constructor(arg) {
+		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+	}
+	add(n) {
+		this.bits[n >> 5] |= 1 << (n & 31);
+	}
+	has(n) {
+		return !!(this.bits[n >> 5] & 1 << (n & 31));
+	}
+};
+var Chunk = class Chunk {
+	constructor(start, end, content) {
+		this.start = start;
+		this.end = end;
+		this.original = content;
+		this.intro = "";
+		this.outro = "";
+		this.content = content;
+		this.storeName = false;
+		this.edited = false;
+		this.previous = null;
+		this.next = null;
+	}
+	appendLeft(content) {
+		this.outro += content;
+	}
+	appendRight(content) {
+		this.intro = this.intro + content;
+	}
+	clone() {
+		const chunk = new Chunk(this.start, this.end, this.original);
+		chunk.intro = this.intro;
+		chunk.outro = this.outro;
+		chunk.content = this.content;
+		chunk.storeName = this.storeName;
+		chunk.edited = this.edited;
+		return chunk;
+	}
+	contains(index) {
+		return this.start < index && index < this.end;
+	}
+	eachNext(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.next;
+		}
+	}
+	eachPrevious(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.previous;
+		}
+	}
+	edit(content, storeName, contentOnly) {
+		this.content = content;
+		if (!contentOnly) {
+			this.intro = "";
+			this.outro = "";
+		}
+		this.storeName = storeName;
+		this.edited = true;
+		return this;
+	}
+	prependLeft(content) {
+		this.outro = content + this.outro;
+	}
+	prependRight(content) {
+		this.intro = content + this.intro;
+	}
+	reset() {
+		this.intro = "";
+		this.outro = "";
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+	split(index) {
+		const sliceIndex = index - this.start;
+		const originalBefore = this.original.slice(0, sliceIndex);
+		const originalAfter = this.original.slice(sliceIndex);
+		this.original = originalBefore;
+		const newChunk = new Chunk(index, this.end, originalAfter);
+		newChunk.outro = this.outro;
+		this.outro = "";
+		this.end = index;
+		if (this.edited) {
+			newChunk.edit("", false);
+			this.content = "";
+		} else this.content = originalBefore;
+		newChunk.next = this.next;
+		if (newChunk.next) newChunk.next.previous = newChunk;
+		newChunk.previous = this;
+		this.next = newChunk;
+		return newChunk;
+	}
+	toString() {
+		return this.intro + this.content + this.outro;
+	}
+	trimEnd(rx) {
+		this.outro = this.outro.replace(rx, "");
+		if (this.outro.length) return true;
+		const trimmed = this.content.replace(rx, "");
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				this.split(this.start + trimmed.length).edit("", void 0, true);
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+			}
+			return true;
+		} else {
+			this.edit("", void 0, true);
+			this.intro = this.intro.replace(rx, "");
+			if (this.intro.length) return true;
+		}
+	}
+	trimStart(rx) {
+		this.intro = this.intro.replace(rx, "");
+		if (this.intro.length) return true;
+		const trimmed = this.content.replace(rx, "");
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				const newChunk = this.split(this.end - trimmed.length);
+				if (this.edited) newChunk.edit(trimmed, this.storeName, true);
+				this.edit("", void 0, true);
+			}
+			return true;
+		} else {
+			this.edit("", void 0, true);
+			this.outro = this.outro.replace(rx, "");
+			if (this.outro.length) return true;
+		}
+	}
+};
+function getBtoa() {
+	if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	else if (typeof Buffer === "function") return (str) => Buffer.from(str, "utf-8").toString("base64");
+	else return () => {
+		throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+	};
+}
+const btoa$1 = /* @__PURE__ */ getBtoa();
+var SourceMap = class {
+	constructor(properties) {
+		this.version = 3;
+		this.file = properties.file;
+		this.sources = properties.sources;
+		this.sourcesContent = properties.sourcesContent;
+		this.names = properties.names;
+		this.mappings = encode$1(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== "undefined") this.x_google_ignoreList = properties.x_google_ignoreList;
+		if (typeof properties.debugId !== "undefined") this.debugId = properties.debugId;
+	}
+	toString() {
+		return JSON.stringify(this);
+	}
+	toUrl() {
+		return "data:application/json;charset=utf-8;base64," + btoa$1(this.toString());
+	}
+};
+function guessIndent(code) {
+	const lines = code.split("\n");
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+	if (tabbed.length === 0 && spaced.length === 0) return null;
+	if (tabbed.length >= spaced.length) return "	";
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+	return new Array(min + 1).join(" ");
+}
+function getRelativePath(from, to) {
+	const fromParts = from.split(/[/\\]/);
+	const toParts = to.split(/[/\\]/);
+	fromParts.pop();
+	while (fromParts[0] === toParts[0]) {
+		fromParts.shift();
+		toParts.shift();
+	}
+	if (fromParts.length) {
+		let i = fromParts.length;
+		while (i--) fromParts[i] = "..";
+	}
+	return fromParts.concat(toParts).join("/");
+}
+const toString = Object.prototype.toString;
+function isObject(thing) {
+	return toString.call(thing) === "[object Object]";
+}
+function getLocator(source) {
+	const originalLines = source.split("\n");
+	const lineOffsets = [];
+	for (let i = 0, pos = 0; i < originalLines.length; i++) {
+		lineOffsets.push(pos);
+		pos += originalLines[i].length + 1;
+	}
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = i + j >> 1;
+			if (index < lineOffsets[m]) j = m;
+			else i = m + 1;
+		}
+		const line = i - 1;
+		return {
+			line,
+			column: index - lineOffsets[line]
+		};
+	};
+}
+const wordRegex = /\w/;
+var Mappings = class {
+	constructor(hires) {
+		this.hires = hires;
+		this.generatedCodeLine = 0;
+		this.generatedCodeColumn = 0;
+		this.raw = [];
+		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.pending = null;
+	}
+	addEdit(sourceIndex, content, loc, nameIndex) {
+		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
+			let contentLineEnd = content.indexOf("\n", 0);
+			let previousContentLineEnd = -1;
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+				const segment = [
+					this.generatedCodeColumn,
+					sourceIndex,
+					loc.line,
+					loc.column
+				];
+				if (nameIndex >= 0) segment.push(nameIndex);
+				this.rawSegments.push(segment);
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
+			}
+			const segment = [
+				this.generatedCodeColumn,
+				sourceIndex,
+				loc.line,
+				loc.column
+			];
+			if (nameIndex >= 0) segment.push(nameIndex);
+			this.rawSegments.push(segment);
+			this.advance(content.slice(previousContentLineEnd + 1));
+		} else if (this.pending) {
+			this.rawSegments.push(this.pending);
+			this.advance(content);
+		}
+		this.pending = null;
+	}
+	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+		let originalCharIndex = chunk.start;
+		let first = true;
+		let charInHiresBoundary = false;
+		while (originalCharIndex < chunk.end) {
+			if (original[originalCharIndex] === "\n") {
+				loc.line += 1;
+				loc.column = 0;
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+				first = true;
+				charInHiresBoundary = false;
+			} else {
+				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+					const segment = [
+						this.generatedCodeColumn,
+						sourceIndex,
+						loc.line,
+						loc.column
+					];
+					if (this.hires === "boundary") if (wordRegex.test(original[originalCharIndex])) {
+						if (!charInHiresBoundary) {
+							this.rawSegments.push(segment);
+							charInHiresBoundary = true;
+						}
+					} else {
+						this.rawSegments.push(segment);
+						charInHiresBoundary = false;
+					}
+					else this.rawSegments.push(segment);
+				}
+				loc.column += 1;
+				this.generatedCodeColumn += 1;
+				first = false;
+			}
+			originalCharIndex += 1;
+		}
+		this.pending = null;
+	}
+	advance(str) {
+		if (!str) return;
+		const lines = str.split("\n");
+		if (lines.length > 1) {
+			for (let i = 0; i < lines.length - 1; i++) {
+				this.generatedCodeLine++;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+			}
+			this.generatedCodeColumn = 0;
+		}
+		this.generatedCodeColumn += lines[lines.length - 1].length;
+	}
+};
+const n = "\n";
+const warned = {
+	insertLeft: false,
+	insertRight: false,
+	storeName: false
+};
+var MagicString = class MagicString {
+	constructor(string, options = {}) {
+		const chunk = new Chunk(0, string.length, string);
+		Object.defineProperties(this, {
+			original: {
+				writable: true,
+				value: string
+			},
+			outro: {
+				writable: true,
+				value: ""
+			},
+			intro: {
+				writable: true,
+				value: ""
+			},
+			firstChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastSearchedChunk: {
+				writable: true,
+				value: chunk
+			},
+			byStart: {
+				writable: true,
+				value: {}
+			},
+			byEnd: {
+				writable: true,
+				value: {}
+			},
+			filename: {
+				writable: true,
+				value: options.filename
+			},
+			indentExclusionRanges: {
+				writable: true,
+				value: options.indentExclusionRanges
+			},
+			sourcemapLocations: {
+				writable: true,
+				value: new BitSet()
+			},
+			storedNames: {
+				writable: true,
+				value: {}
+			},
+			indentStr: {
+				writable: true,
+				value: void 0
+			},
+			ignoreList: {
+				writable: true,
+				value: options.ignoreList
+			},
+			offset: {
+				writable: true,
+				value: options.offset || 0
+			}
+		});
+		this.byStart[0] = chunk;
+		this.byEnd[string.length] = chunk;
+	}
+	addSourcemapLocation(char) {
+		this.sourcemapLocations.add(char);
+	}
+	append(content) {
+		if (typeof content !== "string") throw new TypeError("outro content must be a string");
+		this.outro += content;
+		return this;
+	}
+	appendLeft(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		this._split(index);
+		const chunk = this.byEnd[index];
+		if (chunk) chunk.appendLeft(content);
+		else this.intro += content;
+		return this;
+	}
+	appendRight(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		this._split(index);
+		const chunk = this.byStart[index];
+		if (chunk) chunk.appendRight(content);
+		else this.outro += content;
+		return this;
+	}
+	clone() {
+		const cloned = new MagicString(this.original, {
+			filename: this.filename,
+			offset: this.offset
+		});
+		let originalChunk = this.firstChunk;
+		let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+		while (originalChunk) {
+			cloned.byStart[clonedChunk.start] = clonedChunk;
+			cloned.byEnd[clonedChunk.end] = clonedChunk;
+			const nextOriginalChunk = originalChunk.next;
+			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+			if (nextClonedChunk) {
+				clonedChunk.next = nextClonedChunk;
+				nextClonedChunk.previous = clonedChunk;
+				clonedChunk = nextClonedChunk;
+			}
+			originalChunk = nextOriginalChunk;
+		}
+		cloned.lastChunk = clonedChunk;
+		if (this.indentExclusionRanges) cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+		cloned.intro = this.intro;
+		cloned.outro = this.outro;
+		return cloned;
+	}
+	generateDecodedMap(options) {
+		options = options || {};
+		const sourceIndex = 0;
+		const names = Object.keys(this.storedNames);
+		const mappings = new Mappings(options.hires);
+		const locate = getLocator(this.original);
+		if (this.intro) mappings.advance(this.intro);
+		this.firstChunk.eachNext((chunk) => {
+			const loc = locate(chunk.start);
+			if (chunk.intro.length) mappings.advance(chunk.intro);
+			if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
+			else mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+			if (chunk.outro.length) mappings.advance(chunk.outro);
+		});
+		if (this.outro) mappings.advance(this.outro);
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+			sources: [options.source ? getRelativePath(options.file || "", options.source) : options.file || ""],
+			sourcesContent: options.includeContent ? [this.original] : void 0,
+			names,
+			mappings: mappings.raw,
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
+		};
+	}
+	generateMap(options) {
+		return new SourceMap(this.generateDecodedMap(options));
+	}
+	_ensureindentStr() {
+		if (this.indentStr === void 0) this.indentStr = guessIndent(this.original);
+	}
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+	getIndentString() {
+		this._ensureindentStr();
+		return this.indentStr === null ? "	" : this.indentStr;
+	}
+	indent(indentStr, options) {
+		const pattern = /^[^\r\n]/gm;
+		if (isObject(indentStr)) {
+			options = indentStr;
+			indentStr = void 0;
+		}
+		if (indentStr === void 0) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || "	";
+		}
+		if (indentStr === "") return this;
+		options = options || {};
+		const isExcluded = {};
+		if (options.exclude) (typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude).forEach((exclusion) => {
+			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
+		});
+		let shouldIndentNextCharacter = options.indentStart !== false;
+		const replacer = (match) => {
+			if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+			shouldIndentNextCharacter = true;
+			return match;
+		};
+		this.intro = this.intro.replace(pattern, replacer);
+		let charIndex = 0;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			const end = chunk.end;
+			if (chunk.edited) {
+				if (!isExcluded[charIndex]) {
+					chunk.content = chunk.content.replace(pattern, replacer);
+					if (chunk.content.length) shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
+				}
+			} else {
+				charIndex = chunk.start;
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original[charIndex];
+						if (char === "\n") shouldIndentNextCharacter = true;
+						else if (char !== "\r" && shouldIndentNextCharacter) {
+							shouldIndentNextCharacter = false;
+							if (charIndex === chunk.start) chunk.prependRight(indentStr);
+							else {
+								this._splitChunk(chunk, charIndex);
+								chunk = chunk.next;
+								chunk.prependRight(indentStr);
+							}
+						}
+					}
+					charIndex += 1;
+				}
+			}
+			charIndex = chunk.end;
+			chunk = chunk.next;
+		}
+		this.outro = this.outro.replace(pattern, replacer);
+		return this;
+	}
+	insert() {
+		throw new Error("magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)");
+	}
+	insertLeft(index, content) {
+		if (!warned.insertLeft) {
+			console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
+			warned.insertLeft = true;
+		}
+		return this.appendLeft(index, content);
+	}
+	insertRight(index, content) {
+		if (!warned.insertRight) {
+			console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
+			warned.insertRight = true;
+		}
+		return this.prependRight(index, content);
+	}
+	move(start, end, index) {
+		start = start + this.offset;
+		end = end + this.offset;
+		index = index + this.offset;
+		if (index >= start && index <= end) throw new Error("Cannot move a selection inside itself");
+		this._split(start);
+		this._split(end);
+		this._split(index);
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+		const oldLeft = first.previous;
+		const oldRight = last.next;
+		const newRight = this.byStart[index];
+		if (!newRight && last === this.lastChunk) return this;
+		const newLeft = newRight ? newRight.previous : this.lastChunk;
+		if (oldLeft) oldLeft.next = oldRight;
+		if (oldRight) oldRight.previous = oldLeft;
+		if (newLeft) newLeft.next = first;
+		if (newRight) newRight.previous = last;
+		if (!first.previous) this.firstChunk = last.next;
+		if (!last.next) {
+			this.lastChunk = first.previous;
+			this.lastChunk.next = null;
+		}
+		first.previous = newLeft;
+		last.next = newRight || null;
+		if (!newLeft) this.firstChunk = first;
+		if (!newRight) this.lastChunk = last;
+		return this;
+	}
+	overwrite(start, end, content, options) {
+		options = options || {};
+		return this.update(start, end, content, {
+			...options,
+			overwrite: !options.contentOnly
+		});
+	}
+	update(start, end, content, options) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (typeof content !== "string") throw new TypeError("replacement content must be a string");
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+		if (end > this.original.length) throw new Error("end is out of bounds");
+		if (start === end) throw new Error("Cannot overwrite a zero-length range – use appendLeft or prependRight instead");
+		this._split(start);
+		this._split(end);
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn("The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string");
+				warned.storeName = true;
+			}
+			options = { storeName: true };
+		}
+		const storeName = options !== void 0 ? options.storeName : false;
+		const overwrite = options !== void 0 ? options.overwrite : false;
+		if (storeName) {
+			const original = this.original.slice(start, end);
+			Object.defineProperty(this.storedNames, original, {
+				writable: true,
+				value: true,
+				enumerable: true
+			});
+		}
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+		if (first) {
+			let chunk = first;
+			while (chunk !== last) {
+				if (chunk.next !== this.byStart[chunk.end]) throw new Error("Cannot overwrite across a split point");
+				chunk = chunk.next;
+				chunk.edit("", false);
+			}
+			first.edit(content, storeName, !overwrite);
+		} else {
+			const newChunk = new Chunk(start, end, "").edit(content, storeName);
+			last.next = newChunk;
+			newChunk.previous = last;
+		}
+		return this;
+	}
+	prepend(content) {
+		if (typeof content !== "string") throw new TypeError("outro content must be a string");
+		this.intro = content + this.intro;
+		return this;
+	}
+	prependLeft(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		this._split(index);
+		const chunk = this.byEnd[index];
+		if (chunk) chunk.prependLeft(content);
+		else this.intro = content + this.intro;
+		return this;
+	}
+	prependRight(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+		this._split(index);
+		const chunk = this.byStart[index];
+		if (chunk) chunk.prependRight(content);
+		else this.outro = content + this.outro;
+		return this;
+	}
+	remove(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+		if (start === end) return this;
+		if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+		if (start > end) throw new Error("end must be greater than start");
+		this._split(start);
+		this._split(end);
+		let chunk = this.byStart[start];
+		while (chunk) {
+			chunk.intro = "";
+			chunk.outro = "";
+			chunk.edit("");
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+	reset(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+		if (start === end) return this;
+		if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+		if (start > end) throw new Error("end must be greater than start");
+		this._split(start);
+		this._split(end);
+		let chunk = this.byStart[start];
+		while (chunk) {
+			chunk.reset();
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+	lastChar() {
+		if (this.outro.length) return this.outro[this.outro.length - 1];
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+		} while (chunk = chunk.previous);
+		if (this.intro.length) return this.intro[this.intro.length - 1];
+		return "";
+	}
+	lastLine() {
+		let lineIndex = this.outro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		let lineStr = this.outro;
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length > 0) {
+				lineIndex = chunk.outro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.outro + lineStr;
+			}
+			if (chunk.content.length > 0) {
+				lineIndex = chunk.content.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.content + lineStr;
+			}
+			if (chunk.intro.length > 0) {
+				lineIndex = chunk.intro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.intro + lineStr;
+			}
+		} while (chunk = chunk.previous);
+		lineIndex = this.intro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		return this.intro + lineStr;
+	}
+	slice(start = 0, end = this.original.length - this.offset) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+		let result = "";
+		let chunk = this.firstChunk;
+		while (chunk && (chunk.start > start || chunk.end <= start)) {
+			if (chunk.start < end && chunk.end >= end) return result;
+			chunk = chunk.next;
+		}
+		if (chunk && chunk.edited && chunk.start !== start) throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+		const startChunk = chunk;
+		while (chunk) {
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) result += chunk.intro;
+			const containsEnd = chunk.start < end && chunk.end >= end;
+			if (containsEnd && chunk.edited && chunk.end !== end) throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+			result += chunk.content.slice(sliceStart, sliceEnd);
+			if (chunk.outro && (!containsEnd || chunk.end === end)) result += chunk.outro;
+			if (containsEnd) break;
+			chunk = chunk.next;
+		}
+		return result;
+	}
+	snip(start, end) {
+		const clone = this.clone();
+		clone.remove(0, start);
+		clone.remove(end, clone.original.length);
+		return clone;
+	}
+	_split(index) {
+		if (this.byStart[index] || this.byEnd[index]) return;
+		let chunk = this.lastSearchedChunk;
+		let previousChunk = chunk;
+		const searchForward = index > chunk.end;
+		while (chunk) {
+			if (chunk.contains(index)) return this._splitChunk(chunk, index);
+			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+			if (chunk === previousChunk) return;
+			previousChunk = chunk;
+		}
+	}
+	_splitChunk(chunk, index) {
+		if (chunk.edited && chunk.content.length) {
+			const loc = getLocator(this.original)(index);
+			throw new Error(`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
+		}
+		const newChunk = chunk.split(index);
+		this.byEnd[index] = chunk;
+		this.byStart[index] = newChunk;
+		this.byEnd[newChunk.end] = newChunk;
+		if (chunk === this.lastChunk) this.lastChunk = newChunk;
+		this.lastSearchedChunk = chunk;
+		return true;
+	}
+	toString() {
+		let str = this.intro;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			str += chunk.toString();
+			chunk = chunk.next;
+		}
+		return str + this.outro;
+	}
+	isEmpty() {
+		let chunk = this.firstChunk;
+		do
+			if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
+		while (chunk = chunk.next);
+		return true;
+	}
+	length() {
+		let chunk = this.firstChunk;
+		let length = 0;
+		do
+			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+		while (chunk = chunk.next);
+		return length;
+	}
+	trimLines() {
+		return this.trim("[\\r\\n]");
+	}
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+	trimEndAborted(charType) {
+		const rx = new RegExp((charType || "\\s") + "+$");
+		this.outro = this.outro.replace(rx, "");
+		if (this.outro.length) return true;
+		let chunk = this.lastChunk;
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimEnd(rx);
+			if (chunk.end !== end) {
+				if (this.lastChunk === chunk) this.lastChunk = chunk.next;
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+			if (aborted) return true;
+			chunk = chunk.previous;
+		} while (chunk);
+		return false;
+	}
+	trimEnd(charType) {
+		this.trimEndAborted(charType);
+		return this;
+	}
+	trimStartAborted(charType) {
+		const rx = new RegExp("^" + (charType || "\\s") + "+");
+		this.intro = this.intro.replace(rx, "");
+		if (this.intro.length) return true;
+		let chunk = this.firstChunk;
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimStart(rx);
+			if (chunk.end !== end) {
+				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+			if (aborted) return true;
+			chunk = chunk.next;
+		} while (chunk);
+		return false;
+	}
+	trimStart(charType) {
+		this.trimStartAborted(charType);
+		return this;
+	}
+	hasChanged() {
+		return this.original !== this.toString();
+	}
+	_replaceRegexp(searchValue, replacement) {
+		function getReplacement(match, str) {
+			if (typeof replacement === "string") return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+				if (i === "$") return "$";
+				if (i === "&") return match[0];
+				if (+i < match.length) return match[+i];
+				return `$${i}`;
+			});
+			else return replacement(...match, match.index, str, match.groups);
+		}
+		function matchAll(re, str) {
+			let match;
+			const matches = [];
+			while (match = re.exec(str)) matches.push(match);
+			return matches;
+		}
+		if (searchValue.global) matchAll(searchValue, this.original).forEach((match) => {
+			if (match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
+			}
+		});
+		else {
+			const match = this.original.match(searchValue);
+			if (match && match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
+			}
+		}
+		return this;
+	}
+	_replaceString(string, replacement) {
+		const { original } = this;
+		const index = original.indexOf(string);
+		if (index !== -1) {
+			if (typeof replacement === "function") replacement = replacement(string, index, original);
+			if (string !== replacement) this.overwrite(index, index + string.length, replacement);
+		}
+		return this;
+	}
+	replace(searchValue, replacement) {
+		if (typeof searchValue === "string") return this._replaceString(searchValue, replacement);
+		return this._replaceRegexp(searchValue, replacement);
+	}
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+			const previous = original.slice(index, index + stringLength);
+			let _replacement = replacement;
+			if (typeof replacement === "function") _replacement = replacement(previous, index, original);
+			if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
+		}
+		return this;
+	}
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === "string") return this._replaceAllString(searchValue, replacement);
+		if (!searchValue.global) throw new TypeError("MagicString.prototype.replaceAll called with a non-global RegExp argument");
+		return this._replaceRegexp(searchValue, replacement);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@rollup+plugin-alias@6.0.0_rollup@4.59.0/node_modules/@rollup/plugin-alias/dist/index.js
+function matches$1(pattern, importee) {
+	if (pattern instanceof RegExp) return pattern.test(importee);
+	if (importee.length < pattern.length) return false;
+	if (importee === pattern) return true;
+	return importee.startsWith(pattern + "/");
+}
+function getEntries({ entries, customResolver }) {
+	if (!entries) return [];
+	const resolverFunctionFromOptions = resolveCustomResolver(customResolver);
+	if (Array.isArray(entries)) return entries.map((entry) => {
+		return {
+			find: entry.find,
+			replacement: entry.replacement,
+			resolverFunction: resolveCustomResolver(entry.customResolver) || resolverFunctionFromOptions
+		};
+	});
+	return Object.entries(entries).map(([key, value]) => {
+		return {
+			find: key,
+			replacement: value,
+			resolverFunction: resolverFunctionFromOptions
+		};
+	});
+}
+function getHookFunction(hook) {
+	if (typeof hook === "function") return hook;
+	if (hook && "handler" in hook && typeof hook.handler === "function") return hook.handler;
+	return null;
+}
+function resolveCustomResolver(customResolver) {
+	if (typeof customResolver === "function") return customResolver;
+	if (customResolver) return getHookFunction(customResolver.resolveId);
+	return null;
+}
+function alias$1(options = {}) {
+	const entries = getEntries(options);
+	if (entries.length === 0) return {
+		name: "alias",
+		resolveId: () => null
+	};
+	return {
+		name: "alias",
+		async buildStart(inputOptions) {
+			await Promise.all([...Array.isArray(options.entries) ? options.entries : [], options].map(({ customResolver }) => customResolver && getHookFunction(customResolver.buildStart)?.call(this, inputOptions)));
+		},
+		resolveId(importee, importer, resolveOptions) {
+			const matchedEntry = entries.find((entry) => matches$1(entry.find, importee));
+			if (!matchedEntry) return null;
+			const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
+			if (matchedEntry.resolverFunction) return matchedEntry.resolverFunction.call(this, updatedId, importer, resolveOptions);
+			return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => {
+				if (resolved) return resolved;
+				if (!path.isAbsolute(updatedId)) this.warn(`rewrote ${importee} to ${updatedId} but was not an absolute path and was not handled by other plugins. This will lead to duplicated modules for the same path. To avoid duplicating modules, you should resolve to an absolute path.`);
+				return { id: updatedId };
+			});
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/optimizedDeps.ts
+const debug$13 = createDebugger("vite:optimize-deps");
+function optimizedDepsPlugin() {
+	return {
+		name: "vite:optimized-deps",
+		applyToEnvironment(environment) {
+			if (environment.config.isBundled) return false;
+			return !isDepOptimizationDisabled(environment.config.optimizeDeps);
+		},
+		resolveId(id) {
+			if (this.environment.depsOptimizer?.isOptimizedDepFile(id)) return id;
+		},
+		async load(id) {
+			const environment = this.environment;
+			const depsOptimizer = environment.depsOptimizer;
+			if (depsOptimizer?.isOptimizedDepFile(id)) {
+				const metadata = depsOptimizer.metadata;
+				const file = cleanUrl(id);
+				const versionMatch = DEP_VERSION_RE.exec(id);
+				const browserHash = versionMatch ? versionMatch[1].split("=")[1] : void 0;
+				const info = optimizedDepInfoFromFile(metadata, file);
+				if (info) {
+					if (browserHash && info.browserHash !== browserHash && !environment.config.optimizeDeps.ignoreOutdatedRequests) throwOutdatedRequest(id);
+					try {
+						await info.processing;
+					} catch {
+						throwProcessingError(id);
+					}
+					const newMetadata = depsOptimizer.metadata;
+					if (metadata !== newMetadata) {
+						const currentInfo = optimizedDepInfoFromFile(newMetadata, file);
+						if (info.browserHash !== currentInfo?.browserHash && !environment.config.optimizeDeps.ignoreOutdatedRequests) throwOutdatedRequest(id);
+					}
+				}
+				debug$13?.(`load ${import_picocolors.default.cyan(file)}`);
+				try {
+					return await fsp.readFile(file, "utf-8");
+				} catch {
+					if (browserHash && !environment.config.optimizeDeps.ignoreOutdatedRequests) throwOutdatedRequest(id);
+					throwFileNotFoundInOptimizedDep(id);
+				}
+			}
+		}
+	};
+}
+function throwProcessingError(id) {
+	const err = /* @__PURE__ */ new Error(`Something unexpected happened while optimizing "${id}". The current page should have reloaded by now`);
+	err.code = ERR_OPTIMIZE_DEPS_PROCESSING_ERROR;
+	throw err;
+}
+function throwOutdatedRequest(id) {
+	const err = /* @__PURE__ */ new Error(`There is a new version of the pre-bundle for "${id}", a page reload is going to ask for it.`);
+	err.code = ERR_OUTDATED_OPTIMIZED_DEP;
+	throw err;
+}
+function throwFileNotFoundInOptimizedDep(id) {
+	const err = /* @__PURE__ */ new Error(`The file does not exist at "${id}" which is in the optimize deps directory. The dependency might be incompatible with the dep optimizer. Try adding it to \`optimizeDeps.exclude\`.`);
+	err.code = ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR;
+	throw err;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ufo@1.6.4/node_modules/ufo/dist/index.mjs
+const HASH_RE = /#/g;
+const AMPERSAND_RE = /&/g;
+const SLASH_RE = /\//g;
+const EQUAL_RE = /=/g;
+const PLUS_RE = /\+/g;
+const ENC_CARET_RE = /%5e/gi;
+const ENC_BACKTICK_RE = /%60/gi;
+const ENC_PIPE_RE = /%7c/gi;
+const ENC_SPACE_RE = /%20/gi;
+function encode(text) {
+	return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
+}
+function encodeQueryValue(input) {
+	return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
+}
+function encodeQueryKey(text) {
+	return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
+}
+function encodeQueryItem(key, value) {
+	if (typeof value === "number" || typeof value === "boolean") value = String(value);
+	if (!value) return encodeQueryKey(key);
+	if (Array.isArray(value)) return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
+	return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
+}
+function stringifyQuery(query) {
+	return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
+}
+new Set(builtinModules);
+function clearImports(imports) {
+	return (imports || "").replace(/\/\/[^\n]*\n|\/\*.*\*\//g, "").replace(/\s+/g, " ");
+}
+function getImportNames(cleanedImports) {
+	const topLevelImports = cleanedImports.replace(/{[^}]*}/, "");
+	return {
+		namespacedImport: topLevelImports.match(/\* as \s*(\S*)/)?.[1],
+		defaultImport: topLevelImports.split(",").find((index) => !/[*{}]/.test(index))?.trim() || void 0
+	};
+}
+/**
+* @typedef ErrnoExceptionFields
+* @property {number | undefined} [errnode]
+* @property {string | undefined} [code]
+* @property {string | undefined} [path]
+* @property {string | undefined} [syscall]
+* @property {string | undefined} [url]
+*
+* @typedef {Error & ErrnoExceptionFields} ErrnoException
+*/
+const own$1 = {}.hasOwnProperty;
+const classRegExp = /^([A-Z][a-z\d]*)+$/;
+const kTypes = new Set([
+	"string",
+	"function",
+	"number",
+	"object",
+	"Function",
+	"Object",
+	"boolean",
+	"bigint",
+	"symbol"
+]);
+const codes = {};
+/**
+* Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.
+* We cannot use Intl.ListFormat because it's not available in
+* --without-intl builds.
+*
+* @param {Array<string>} array
+*   An array of strings.
+* @param {string} [type]
+*   The list type to be inserted before the last element.
+* @returns {string}
+*/
+function formatList(array, type = "and") {
+	return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array[array.length - 1]}`;
+}
+/** @type {Map<string, MessageFunction | string>} */
+const messages = /* @__PURE__ */ new Map();
+const nodeInternalPrefix = "__node_internal_";
+/** @type {number} */
+let userStackTraceLimit;
+codes.ERR_INVALID_ARG_TYPE = createError(
+	"ERR_INVALID_ARG_TYPE",
+	/**
+	* @param {string} name
+	* @param {Array<string> | string} expected
+	* @param {unknown} actual
+	*/
+	(name, expected, actual) => {
+		assert.ok(typeof name === "string", "'name' must be a string");
+		if (!Array.isArray(expected)) expected = [expected];
+		let message = "The ";
+		if (name.endsWith(" argument")) message += `${name} `;
+		else {
+			const type = name.includes(".") ? "property" : "argument";
+			message += `"${name}" ${type} `;
+		}
+		message += "must be ";
+		/** @type {Array<string>} */
+		const types = [];
+		/** @type {Array<string>} */
+		const instances = [];
+		/** @type {Array<string>} */
+		const other = [];
+		for (const value of expected) {
+			assert.ok(typeof value === "string", "All expected entries have to be of type string");
+			if (kTypes.has(value)) types.push(value.toLowerCase());
+			else if (classRegExp.exec(value) === null) {
+				assert.ok(value !== "object", "The value \"object\" should be written as \"Object\"");
+				other.push(value);
+			} else instances.push(value);
+		}
+		if (instances.length > 0) {
+			const pos = types.indexOf("object");
+			if (pos !== -1) {
+				types.slice(pos, 1);
+				instances.push("Object");
+			}
+		}
+		if (types.length > 0) {
+			message += `${types.length > 1 ? "one of type" : "of type"} ${formatList(types, "or")}`;
+			if (instances.length > 0 || other.length > 0) message += " or ";
+		}
+		if (instances.length > 0) {
+			message += `an instance of ${formatList(instances, "or")}`;
+			if (other.length > 0) message += " or ";
+		}
+		if (other.length > 0) if (other.length > 1) message += `one of ${formatList(other, "or")}`;
+		else {
+			if (other[0].toLowerCase() !== other[0]) message += "an ";
+			message += `${other[0]}`;
+		}
+		message += `. Received ${determineSpecificType(actual)}`;
+		return message;
+	},
+	TypeError
+);
+codes.ERR_INVALID_MODULE_SPECIFIER = createError(
+	"ERR_INVALID_MODULE_SPECIFIER",
+	/**
+	* @param {string} request
+	* @param {string} reason
+	* @param {string} [base]
+	*/
+	(request, reason, base = void 0) => {
+		return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+	},
+	TypeError
+);
+codes.ERR_INVALID_PACKAGE_CONFIG = createError(
+	"ERR_INVALID_PACKAGE_CONFIG",
+	/**
+	* @param {string} path
+	* @param {string} [base]
+	* @param {string} [message]
+	*/
+	(path, base, message) => {
+		return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+	},
+	Error
+);
+codes.ERR_INVALID_PACKAGE_TARGET = createError(
+	"ERR_INVALID_PACKAGE_TARGET",
+	/**
+	* @param {string} packagePath
+	* @param {string} key
+	* @param {unknown} target
+	* @param {boolean} [isImport=false]
+	* @param {string} [base]
+	*/
+	(packagePath, key, target, isImport = false, base = void 0) => {
+		const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+		if (key === ".") {
+			assert.ok(isImport === false);
+			return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? "; targets must start with \"./\"" : ""}`;
+		}
+		return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? "; targets must start with \"./\"" : ""}`;
+	},
+	Error
+);
+codes.ERR_MODULE_NOT_FOUND = createError(
+	"ERR_MODULE_NOT_FOUND",
+	/**
+	* @param {string} path
+	* @param {string} base
+	* @param {boolean} [exactUrl]
+	*/
+	(path, base, exactUrl = false) => {
+		return `Cannot find ${exactUrl ? "module" : "package"} '${path}' imported from ${base}`;
+	},
+	Error
+);
+codes.ERR_NETWORK_IMPORT_DISALLOWED = createError("ERR_NETWORK_IMPORT_DISALLOWED", "import of '%s' by %s is not supported: %s", Error);
+codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
+	"ERR_PACKAGE_IMPORT_NOT_DEFINED",
+	/**
+	* @param {string} specifier
+	* @param {string} packagePath
+	* @param {string} base
+	*/
+	(specifier, packagePath, base) => {
+		return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
+	},
+	TypeError
+);
+codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
+	"ERR_PACKAGE_PATH_NOT_EXPORTED",
+	/**
+	* @param {string} packagePath
+	* @param {string} subpath
+	* @param {string} [base]
+	*/
+	(packagePath, subpath, base = void 0) => {
+		if (subpath === ".") return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+		return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+	},
+	Error
+);
+codes.ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error);
+codes.ERR_UNSUPPORTED_RESOLVE_REQUEST = createError("ERR_UNSUPPORTED_RESOLVE_REQUEST", "Failed to resolve module specifier \"%s\" from \"%s\": Invalid relative URL or base scheme is not hierarchical.", TypeError);
+codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
+	"ERR_UNKNOWN_FILE_EXTENSION",
+	/**
+	* @param {string} extension
+	* @param {string} path
+	*/
+	(extension, path) => {
+		return `Unknown file extension "${extension}" for ${path}`;
+	},
+	TypeError
+);
+codes.ERR_INVALID_ARG_VALUE = createError(
+	"ERR_INVALID_ARG_VALUE",
+	/**
+	* @param {string} name
+	* @param {unknown} value
+	* @param {string} [reason='is invalid']
+	*/
+	(name, value, reason = "is invalid") => {
+		let inspected = inspect(value);
+		if (inspected.length > 128) inspected = `${inspected.slice(0, 128)}...`;
+		return `The ${name.includes(".") ? "property" : "argument"} '${name}' ${reason}. Received ${inspected}`;
+	},
+	TypeError
+);
+/**
+* Utility function for registering the error codes. Only used here. Exported
+* *only* to allow for testing.
+* @param {string} sym
+* @param {MessageFunction | string} value
+* @param {ErrorConstructor} constructor
+* @returns {new (...parameters: Array<any>) => Error}
+*/
+function createError(sym, value, constructor) {
+	messages.set(sym, value);
+	return makeNodeErrorWithCode(constructor, sym);
+}
+/**
+* @param {ErrorConstructor} Base
+* @param {string} key
+* @returns {ErrorConstructor}
+*/
+function makeNodeErrorWithCode(Base, key) {
+	return NodeError;
+	/**
+	* @param {Array<unknown>} parameters
+	*/
+	function NodeError(...parameters) {
+		const limit = Error.stackTraceLimit;
+		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+		const error = new Base();
+		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+		const message = getMessage(key, parameters, error);
+		Object.defineProperties(error, {
+			message: {
+				value: message,
+				enumerable: false,
+				writable: true,
+				configurable: true
+			},
+			toString: {
+				/** @this {Error} */
+				value() {
+					return `${this.name} [${key}]: ${this.message}`;
+				},
+				enumerable: false,
+				writable: true,
+				configurable: true
+			}
+		});
+		captureLargerStackTrace(error);
+		error.code = key;
+		return error;
+	}
+}
+/**
+* @returns {boolean}
+*/
+function isErrorStackTraceLimitWritable() {
+	try {
+		if (v8.startupSnapshot.isBuildingSnapshot()) return false;
+	} catch {}
+	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+	if (desc === void 0) return Object.isExtensible(Error);
+	return own$1.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
+}
+/**
+* This function removes unnecessary frames from Node.js core errors.
+* @template {(...parameters: unknown[]) => unknown} T
+* @param {T} wrappedFunction
+* @returns {T}
+*/
+function hideStackFrames(wrappedFunction) {
+	const hidden = nodeInternalPrefix + wrappedFunction.name;
+	Object.defineProperty(wrappedFunction, "name", { value: hidden });
+	return wrappedFunction;
+}
+const captureLargerStackTrace = hideStackFrames(
+	/**
+	* @param {Error} error
+	* @returns {Error}
+	*/
+	function(error) {
+		const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+		if (stackTraceLimitIsWritable) {
+			userStackTraceLimit = Error.stackTraceLimit;
+			Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+		}
+		Error.captureStackTrace(error);
+		if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+		return error;
+	}
+);
+/**
+* @param {string} key
+* @param {Array<unknown>} parameters
+* @param {Error} self
+* @returns {string}
+*/
+function getMessage(key, parameters, self) {
+	const message = messages.get(key);
+	assert.ok(message !== void 0, "expected `message` to be found");
+	if (typeof message === "function") {
+		assert.ok(message.length <= parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`);
+		return Reflect.apply(message, self, parameters);
+	}
+	const regex = /%[dfijoOs]/g;
+	let expectedLength = 0;
+	while (regex.exec(message) !== null) expectedLength++;
+	assert.ok(expectedLength === parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`);
+	if (parameters.length === 0) return message;
+	parameters.unshift(message);
+	return Reflect.apply(format, null, parameters);
+}
+/**
+* Determine the specific type of a value for type-mismatch errors.
+* @param {unknown} value
+* @returns {string}
+*/
+function determineSpecificType(value) {
+	if (value === null || value === void 0) return String(value);
+	if (typeof value === "function" && value.name) return `function ${value.name}`;
+	if (typeof value === "object") {
+		if (value.constructor && value.constructor.name) return `an instance of ${value.constructor.name}`;
+		return `${inspect(value, { depth: -1 })}`;
+	}
+	let inspected = inspect(value, { colors: false });
+	if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
+	return `type ${typeof value} (${inspected})`;
+}
+const DEFAULT_CONDITIONS = Object.freeze(["node", "import"]);
+new Set(DEFAULT_CONDITIONS);
+const ESM_STATIC_IMPORT_RE = /(?<=\s|^|;|\})import\s*(?:[\s"']*(?<imports>[\p{L}\p{M}\w\t\n\r $*,/{}@.]+)from\s*)?["']\s*(?<specifier>(?<="\s*)[^"]*[^\s"](?=\s*")|(?<='\s*)[^']*[^\s'](?=\s*'))\s*["'][\s;]*/gmu;
+const TYPE_RE = /^\s*?type\s/;
+function parseStaticImport(matched) {
+	const cleanedImports = clearImports(matched.imports);
+	const namedImports = {};
+	const _matches = cleanedImports.match(/{([^}]*)}/)?.[1]?.split(",") || [];
+	for (const namedImport of _matches) {
+		const _match = namedImport.match(/^\s*(\S*) as (\S*)\s*$/);
+		const source = _match?.[1] || namedImport.trim();
+		const importName = _match?.[2] || source;
+		if (source && !TYPE_RE.test(source)) namedImports[source] = importName;
+	}
+	const { namespacedImport, defaultImport } = getImportNames(cleanedImports);
+	return {
+		...matched,
+		defaultImport,
+		namespacedImport,
+		namedImports
+	};
+}
+//#endregion
+//#region src/node/env.ts
+var import_main = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _resolveEscapeSequences(value) {
+		return value.replace(/\\\$/g, "$");
+	}
+	function expandValue(value, processEnv, runningParsed) {
+		const env = {
+			...runningParsed,
+			...processEnv
+		};
+		const regex = /(?<!\\)\${([^{}]+)}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g;
+		let result = value;
+		let match;
+		const seen = /* @__PURE__ */ new Set();
+		while ((match = regex.exec(result)) !== null) {
+			seen.add(result);
+			const [template, bracedExpression, unbracedExpression] = match;
+			const expression = bracedExpression || unbracedExpression;
+			const opMatch = expression.match(/(:\+|\+|:-|-)/);
+			const splitter = opMatch ? opMatch[0] : null;
+			const r = expression.split(splitter);
+			let defaultValue;
+			let value;
+			const key = r.shift();
+			if ([":+", "+"].includes(splitter)) {
+				defaultValue = env[key] ? r.join(splitter) : "";
+				value = null;
+			} else {
+				defaultValue = r.join(splitter);
+				value = env[key];
+			}
+			if (value) if (seen.has(value)) result = result.replace(template, defaultValue);
+			else result = result.replace(template, value);
+			else result = result.replace(template, defaultValue);
+			if (result === runningParsed[key]) break;
+			regex.lastIndex = 0;
+		}
+		return result;
+	}
+	function expand(options) {
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		for (const key in options.parsed) {
+			let value = options.parsed[key];
+			if (processEnv[key] && processEnv[key] !== value) value = processEnv[key];
+			else value = expandValue(value, processEnv, options.parsed);
+			options.parsed[key] = _resolveEscapeSequences(value);
+		}
+		for (const processKey in options.parsed) processEnv[processKey] = options.parsed[processKey];
+		return options;
+	}
+	module.exports.expand = expand;
+})))();
+const debug$12 = createDebugger("vite:env");
+function getEnvFilesForMode(mode, envDir) {
+	if (envDir !== false) return [
+		`.env`,
+		`.env.local`,
+		`.env.${mode}`,
+		`.env.${mode}.local`
+	].map((file) => normalizePath(path.join(envDir, file)));
+	return [];
+}
+function loadEnv(mode, envDir, prefixes = "VITE_") {
+	const start = performance.now();
+	const getTime = () => `${(performance.now() - start).toFixed(2)}ms`;
+	if (mode === "local") throw new Error("\"local\" cannot be used as a mode name because it conflicts with the .local postfix for .env files.");
+	prefixes = arraify(prefixes);
+	const env = {};
+	const envFiles = getEnvFilesForMode(mode, envDir);
+	debug$12?.(`loading env files: %O`, envFiles);
+	const parsed = Object.fromEntries(envFiles.flatMap((filePath) => {
+		const stat = tryStatSync(filePath);
+		if (!stat || !stat.isFile() && !stat.isFIFO()) return [];
+		const parsedEnv = parseEnv(fs.readFileSync(filePath, "utf-8"));
+		return Object.entries(parsedEnv);
+	}));
+	debug$12?.(`env files loaded in ${getTime()}`);
+	if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === void 0) process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV;
+	if (parsed.BROWSER && process.env.BROWSER === void 0) process.env.BROWSER = parsed.BROWSER;
+	if (parsed.BROWSER_ARGS && process.env.BROWSER_ARGS === void 0) process.env.BROWSER_ARGS = parsed.BROWSER_ARGS;
+	(0, import_main.expand)({
+		parsed,
+		processEnv: { ...process.env }
+	});
+	for (const [key, value] of Object.entries(parsed)) if (prefixes.some((prefix) => key.startsWith(prefix))) env[key] = value;
+	for (const key in process.env) if (prefixes.some((prefix) => key.startsWith(prefix))) env[key] = process.env[key];
+	debug$12?.(`using resolved env: %O`, env);
+	return env;
+}
+function resolveEnvPrefix({ envPrefix = "VITE_" }) {
+	envPrefix = arraify(envPrefix);
+	if (envPrefix.includes("")) throw new Error(`envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`);
+	if (envPrefix.some((prefix) => /\s/.test(prefix))) console.warn(import_picocolors.default.yellow(`[vite] Warning: envPrefix option contains values with whitespace, which does not work in practice.`));
+	return envPrefix;
+}
+//#endregion
+//#region src/node/deprecations.ts
+const docsURL = "https://vite.dev";
+const deprecationCode = {
+	removePluginHookSsrArgument: "this-environment-in-hooks",
+	removePluginHookHandleHotUpdate: "hotupdate-hook",
+	removeServerModuleGraph: "per-environment-apis",
+	removeServerReloadModule: "per-environment-apis",
+	removeServerPluginContainer: "per-environment-apis",
+	removeServerHot: "per-environment-apis",
+	removeServerTransformRequest: "per-environment-apis",
+	removeServerWarmupRequest: "per-environment-apis",
+	removeSsrLoadModule: "ssr-using-modulerunner"
+};
+const deprecationMessages = {
+	removePluginHookSsrArgument: "Plugin hook `options.ssr` is replaced with `this.environment.config.consumer === 'server'`.",
+	removePluginHookHandleHotUpdate: "Plugin hook `handleHotUpdate()` is replaced with `hotUpdate()`.",
+	removeServerModuleGraph: "The `server.moduleGraph` is replaced with `this.environment.moduleGraph`.",
+	removeServerReloadModule: "The `server.reloadModule` is replaced with `environment.reloadModule`.",
+	removeServerPluginContainer: "The `server.pluginContainer` is replaced with `this.environment.pluginContainer`.",
+	removeServerHot: "The `server.hot` is replaced with `this.environment.hot`.",
+	removeServerTransformRequest: "The `server.transformRequest` is replaced with `this.environment.transformRequest`.",
+	removeServerWarmupRequest: "The `server.warmupRequest` is replaced with `this.environment.warmupRequest`.",
+	removeSsrLoadModule: "The `server.ssrLoadModule` is replaced with Environment Runner."
+};
+let _ignoreDeprecationWarnings = false;
+function isFutureDeprecationEnabled(config, type) {
+	return !!config.future?.[type];
+}
+/**
+* Warn about future deprecations.
+*/
+function warnFutureDeprecation(config, type, extraMessage, stacktrace = true) {
+	if (_ignoreDeprecationWarnings || !config.future || config.future[type] !== "warn") return;
+	let msg = `[vite future] ${deprecationMessages[type]}`;
+	if (extraMessage) msg += ` ${extraMessage}`;
+	msg = import_picocolors.default.yellow(msg);
+	const docs = `${docsURL}/changes/${deprecationCode[type].toLowerCase()}`;
+	msg += import_picocolors.default.gray(`\n  ${stacktrace ? "├" : "└"}─── `) + import_picocolors.default.underline(docs) + "\n";
+	if (stacktrace) {
+		const stack = (/* @__PURE__ */ new Error()).stack;
+		if (stack) {
+			let stacks = stack.split("\n").slice(3).filter((i) => !i.includes("/node_modules/vite/dist/"));
+			if (stacks.length === 0) stacks.push("No stack trace found.");
+			stacks = stacks.map((i, idx) => `  ${idx === stacks.length - 1 ? "└" : "│"} ${i.trim()}`);
+			msg += import_picocolors.default.dim(stacks.join("\n")) + "\n";
+		}
+	}
+	config.logger.warnOnce(msg);
+}
+function ignoreDeprecationWarnings(fn) {
+	const before = _ignoreDeprecationWarnings;
+	_ignoreDeprecationWarnings = true;
+	const ret = fn();
+	_ignoreDeprecationWarnings = before;
+	return ret;
+}
+//#endregion
+//#region src/node/server/middlewares/error.ts
+function prepareError(err) {
+	return {
+		message: stripVTControlCharacters(err.message),
+		stack: stripVTControlCharacters(cleanStack(err.stack || "")),
+		id: err.id,
+		frame: stripVTControlCharacters(err.frame || ""),
+		plugin: err.plugin,
+		pluginCode: err.pluginCode?.toString(),
+		loc: err.loc
+	};
+}
+function buildErrorMessage(err, args = [], includeStack = true) {
+	if (err.plugin) args.push(`  Plugin: ${import_picocolors.default.magenta(err.plugin)}`);
+	const loc = err.loc ? `:${err.loc.line}:${err.loc.column}` : "";
+	if (err.id) args.push(`  File: ${import_picocolors.default.cyan(err.id)}${loc}`);
+	if (err.frame) args.push(import_picocolors.default.yellow(pad(err.frame)));
+	if (includeStack && err.stack) args.push(pad(cleanStack(err.stack)));
+	return args.join("\n");
+}
+function cleanStack(stack) {
+	return stack.split(/\n/).filter((l) => /^\s*at/.test(l)).join("\n");
+}
+function logError(server, err) {
+	const msg = buildErrorMessage(err, [import_picocolors.default.red(`Internal server error: ${err.message}`)]);
+	server.config.logger.error(msg, {
+		clear: true,
+		timestamp: true,
+		error: err
+	});
+	server.environments.client.hot.send({
+		type: "error",
+		err: prepareError(err)
+	});
+}
+function errorMiddleware(server, allowNext = false) {
+	return function viteErrorMiddleware(err, _req, res, next) {
+		logError(server, err);
+		if (allowNext) next();
+		else {
+			res.statusCode = 500;
+			res.end(`
+        <!DOCTYPE html>
+        <html lang="en">
+          <head>
+            <meta charset="UTF-8" />
+            <title>Error</title>
+            <script type="module">
+              const error = ${JSON.stringify(prepareError(err)).replace(/</g, "\\u003c")}
+              try {
+                const { ErrorOverlay } = await import(${JSON.stringify(path.posix.join(server.config.base, CLIENT_PUBLIC_PATH))})
+                document.body.appendChild(new ErrorOverlay(error))
+              } catch {
+                const h = (tag, text) => {
+                  const el = document.createElement(tag)
+                  el.textContent = text
+                  return el
+                }
+                document.body.appendChild(h('h1', 'Internal Server Error'))
+                document.body.appendChild(h('h2', error.message))
+                document.body.appendChild(h('pre', error.stack))
+                document.body.appendChild(h('p', '(Error overlay failed to load)'))
+              }
+            <\/script>
+          </head>
+          <body>
+          </body>
+        </html>
+      `);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/encodeurl@1.0.2/node_modules/encodeurl/index.js
+/*!
+* encodeurl
+* Copyright(c) 2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_encodeurl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = encodeUrl;
+	/**
+	* RegExp to match non-URL code points, *after* encoding (i.e. not including "%")
+	* and including invalid escape sequences.
+	* @private
+	*/
+	var ENCODE_CHARS_REGEXP = /(?:[^\x21\x25\x26-\x3B\x3D\x3F-\x5B\x5D\x5F\x61-\x7A\x7E]|%(?:[^0-9A-Fa-f]|[0-9A-Fa-f][^0-9A-Fa-f]|$))+/g;
+	/**
+	* RegExp to match unmatched surrogate pair.
+	* @private
+	*/
+	var UNMATCHED_SURROGATE_PAIR_REGEXP = /(^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/g;
+	/**
+	* String to replace unmatched surrogate pair with.
+	* @private
+	*/
+	var UNMATCHED_SURROGATE_PAIR_REPLACE = "$1�$2";
+	/**
+	* Encode a URL to a percent-encoded form, excluding already-encoded sequences.
+	*
+	* This function will take an already-encoded URL and encode all the non-URL
+	* code points. This function will not encode the "%" character unless it is
+	* not part of a valid sequence (`%20` will be left as-is, but `%foo` will
+	* be encoded as `%25foo`).
+	*
+	* This encode is meant to be "safe" and does not throw errors. It will try as
+	* hard as it can to properly encode the given URL, including replacing any raw,
+	* unpaired surrogate pairs with the Unicode replacement character prior to
+	* encoding.
+	*
+	* @param {string} url
+	* @return {string}
+	* @public
+	*/
+	function encodeUrl(url) {
+		return String(url).replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE).replace(ENCODE_CHARS_REGEXP, encodeURI);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/escape-html@1.0.3/node_modules/escape-html/index.js
+/*!
+* escape-html
+* Copyright(c) 2012-2013 TJ Holowaychuk
+* Copyright(c) 2015 Andreas Lubbe
+* Copyright(c) 2015 Tiancheng "Timothy" Gu
+* MIT Licensed
+*/
+var require_escape_html = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module variables.
+	* @private
+	*/
+	var matchHtmlRegExp = /["'&<>]/;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = escapeHtml;
+	/**
+	* Escape special characters in the given string of html.
+	*
+	* @param  {string} string The string to escape for inserting into HTML
+	* @return {string}
+	* @public
+	*/
+	function escapeHtml(string) {
+		var str = "" + string;
+		var match = matchHtmlRegExp.exec(str);
+		if (!match) return str;
+		var escape;
+		var html = "";
+		var index = 0;
+		var lastIndex = 0;
+		for (index = match.index; index < str.length; index++) {
+			switch (str.charCodeAt(index)) {
+				case 34:
+					escape = "&quot;";
+					break;
+				case 38:
+					escape = "&amp;";
+					break;
+				case 39:
+					escape = "&#39;";
+					break;
+				case 60:
+					escape = "&lt;";
+					break;
+				case 62:
+					escape = "&gt;";
+					break;
+				default: continue;
+			}
+			if (lastIndex !== index) html += str.substring(lastIndex, index);
+			lastIndex = index + 1;
+			html += escape;
+		}
+		return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ee-first@1.1.1/node_modules/ee-first/index.js
+/*!
+* ee-first
+* Copyright(c) 2014 Jonathan Ong
+* MIT Licensed
+*/
+var require_ee_first = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = first;
+	/**
+	* Get the first event in a set of event emitters and event pairs.
+	*
+	* @param {array} stuff
+	* @param {function} done
+	* @public
+	*/
+	function first(stuff, done) {
+		if (!Array.isArray(stuff)) throw new TypeError("arg must be an array of [ee, events...] arrays");
+		var cleanups = [];
+		for (var i = 0; i < stuff.length; i++) {
+			var arr = stuff[i];
+			if (!Array.isArray(arr) || arr.length < 2) throw new TypeError("each array member must be [ee, events...]");
+			var ee = arr[0];
+			for (var j = 1; j < arr.length; j++) {
+				var event = arr[j];
+				var fn = listener(event, callback);
+				ee.on(event, fn);
+				cleanups.push({
+					ee,
+					event,
+					fn
+				});
+			}
+		}
+		function callback() {
+			cleanup();
+			done.apply(null, arguments);
+		}
+		function cleanup() {
+			var x;
+			for (var i = 0; i < cleanups.length; i++) {
+				x = cleanups[i];
+				x.ee.removeListener(x.event, x.fn);
+			}
+		}
+		function thunk(fn) {
+			done = fn;
+		}
+		thunk.cancel = cleanup;
+		return thunk;
+	}
+	/**
+	* Create the event listener.
+	* @private
+	*/
+	function listener(event, done) {
+		return function onevent(arg1) {
+			var args = new Array(arguments.length);
+			var ee = this;
+			var err = event === "error" ? arg1 : null;
+			for (var i = 0; i < args.length; i++) args[i] = arguments[i];
+			done(err, ee, event, args);
+		};
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/on-finished@2.3.0/node_modules/on-finished/index.js
+/*!
+* on-finished
+* Copyright(c) 2013 Jonathan Ong
+* Copyright(c) 2014 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_on_finished = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = onFinished;
+	module.exports.isFinished = isFinished;
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var first = require_ee_first();
+	/**
+	* Variables.
+	* @private
+	*/
+	/* istanbul ignore next */
+	var defer = typeof setImmediate === "function" ? setImmediate : function(fn) {
+		process.nextTick(fn.bind.apply(fn, arguments));
+	};
+	/**
+	* Invoke callback when the response has finished, useful for
+	* cleaning up resources afterwards.
+	*
+	* @param {object} msg
+	* @param {function} listener
+	* @return {object}
+	* @public
+	*/
+	function onFinished(msg, listener) {
+		if (isFinished(msg) !== false) {
+			defer(listener, null, msg);
+			return msg;
+		}
+		attachListener(msg, listener);
+		return msg;
+	}
+	/**
+	* Determine if message is already finished.
+	*
+	* @param {object} msg
+	* @return {boolean}
+	* @public
+	*/
+	function isFinished(msg) {
+		var socket = msg.socket;
+		if (typeof msg.finished === "boolean") return Boolean(msg.finished || socket && !socket.writable);
+		if (typeof msg.complete === "boolean") return Boolean(msg.upgrade || !socket || !socket.readable || msg.complete && !msg.readable);
+	}
+	/**
+	* Attach a finished listener to the message.
+	*
+	* @param {object} msg
+	* @param {function} callback
+	* @private
+	*/
+	function attachFinishedListener(msg, callback) {
+		var eeMsg;
+		var eeSocket;
+		var finished = false;
+		function onFinish(error) {
+			eeMsg.cancel();
+			eeSocket.cancel();
+			finished = true;
+			callback(error);
+		}
+		eeMsg = eeSocket = first([[
+			msg,
+			"end",
+			"finish"
+		]], onFinish);
+		function onSocket(socket) {
+			msg.removeListener("socket", onSocket);
+			if (finished) return;
+			if (eeMsg !== eeSocket) return;
+			eeSocket = first([[
+				socket,
+				"error",
+				"close"
+			]], onFinish);
+		}
+		if (msg.socket) {
+			onSocket(msg.socket);
+			return;
+		}
+		msg.on("socket", onSocket);
+		if (msg.socket === void 0) patchAssignSocket(msg, onSocket);
+	}
+	/**
+	* Attach the listener to the message.
+	*
+	* @param {object} msg
+	* @return {function}
+	* @private
+	*/
+	function attachListener(msg, listener) {
+		var attached = msg.__onFinished;
+		if (!attached || !attached.queue) {
+			attached = msg.__onFinished = createListener(msg);
+			attachFinishedListener(msg, attached);
+		}
+		attached.queue.push(listener);
+	}
+	/**
+	* Create listener on message.
+	*
+	* @param {object} msg
+	* @return {function}
+	* @private
+	*/
+	function createListener(msg) {
+		function listener(err) {
+			if (msg.__onFinished === listener) msg.__onFinished = null;
+			if (!listener.queue) return;
+			var queue = listener.queue;
+			listener.queue = null;
+			for (var i = 0; i < queue.length; i++) queue[i](err, msg);
+		}
+		listener.queue = [];
+		return listener;
+	}
+	/**
+	* Patch ServerResponse.prototype.assignSocket for node.js 0.8.
+	*
+	* @param {ServerResponse} res
+	* @param {function} callback
+	* @private
+	*/
+	function patchAssignSocket(res, callback) {
+		var assignSocket = res.assignSocket;
+		if (typeof assignSocket !== "function") return;
+		res.assignSocket = function _assignSocket(socket) {
+			assignSocket.call(this, socket);
+			callback(socket);
+		};
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/parseurl@1.3.3/node_modules/parseurl/index.js
+/*!
+* parseurl
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2014-2017 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_parseurl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var url$2 = __require("url");
+	var parse = url$2.parse;
+	var Url = url$2.Url;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = parseurl;
+	module.exports.original = originalurl;
+	/**
+	* Parse the `req` url with memoization.
+	*
+	* @param {ServerRequest} req
+	* @return {Object}
+	* @public
+	*/
+	function parseurl(req) {
+		var url = req.url;
+		if (url === void 0) return;
+		var parsed = req._parsedUrl;
+		if (fresh(url, parsed)) return parsed;
+		parsed = fastparse(url);
+		parsed._raw = url;
+		return req._parsedUrl = parsed;
+	}
+	/**
+	* Parse the `req` original url with fallback and memoization.
+	*
+	* @param {ServerRequest} req
+	* @return {Object}
+	* @public
+	*/
+	function originalurl(req) {
+		var url = req.originalUrl;
+		if (typeof url !== "string") return parseurl(req);
+		var parsed = req._parsedOriginalUrl;
+		if (fresh(url, parsed)) return parsed;
+		parsed = fastparse(url);
+		parsed._raw = url;
+		return req._parsedOriginalUrl = parsed;
+	}
+	/**
+	* Parse the `str` url with fast-path short-cut.
+	*
+	* @param {string} str
+	* @return {Object}
+	* @private
+	*/
+	function fastparse(str) {
+		if (typeof str !== "string" || str.charCodeAt(0) !== 47) return parse(str);
+		var pathname = str;
+		var query = null;
+		var search = null;
+		for (var i = 1; i < str.length; i++) switch (str.charCodeAt(i)) {
+			case 63:
+				if (search === null) {
+					pathname = str.substring(0, i);
+					query = str.substring(i + 1);
+					search = str.substring(i);
+				}
+				break;
+			case 9:
+			case 10:
+			case 12:
+			case 13:
+			case 32:
+			case 35:
+			case 160:
+			case 65279: return parse(str);
+		}
+		var url = Url !== void 0 ? new Url() : {};
+		url.path = str;
+		url.href = str;
+		url.pathname = pathname;
+		if (search !== null) {
+			url.query = query;
+			url.search = search;
+		}
+		return url;
+	}
+	/**
+	* Determine if parsed is still fresh for url.
+	*
+	* @param {string} url
+	* @param {object} parsedUrl
+	* @return {boolean}
+	* @private
+	*/
+	function fresh(url, parsedUrl) {
+		return typeof parsedUrl === "object" && parsedUrl !== null && (Url === void 0 || parsedUrl instanceof Url) && parsedUrl._raw === url;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/statuses@1.5.0/node_modules/statuses/codes.json
+var require_codes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"100": "Continue",
+		"101": "Switching Protocols",
+		"102": "Processing",
+		"103": "Early Hints",
+		"200": "OK",
+		"201": "Created",
+		"202": "Accepted",
+		"203": "Non-Authoritative Information",
+		"204": "No Content",
+		"205": "Reset Content",
+		"206": "Partial Content",
+		"207": "Multi-Status",
+		"208": "Already Reported",
+		"226": "IM Used",
+		"300": "Multiple Choices",
+		"301": "Moved Permanently",
+		"302": "Found",
+		"303": "See Other",
+		"304": "Not Modified",
+		"305": "Use Proxy",
+		"306": "(Unused)",
+		"307": "Temporary Redirect",
+		"308": "Permanent Redirect",
+		"400": "Bad Request",
+		"401": "Unauthorized",
+		"402": "Payment Required",
+		"403": "Forbidden",
+		"404": "Not Found",
+		"405": "Method Not Allowed",
+		"406": "Not Acceptable",
+		"407": "Proxy Authentication Required",
+		"408": "Request Timeout",
+		"409": "Conflict",
+		"410": "Gone",
+		"411": "Length Required",
+		"412": "Precondition Failed",
+		"413": "Payload Too Large",
+		"414": "URI Too Long",
+		"415": "Unsupported Media Type",
+		"416": "Range Not Satisfiable",
+		"417": "Expectation Failed",
+		"418": "I'm a teapot",
+		"421": "Misdirected Request",
+		"422": "Unprocessable Entity",
+		"423": "Locked",
+		"424": "Failed Dependency",
+		"425": "Unordered Collection",
+		"426": "Upgrade Required",
+		"428": "Precondition Required",
+		"429": "Too Many Requests",
+		"431": "Request Header Fields Too Large",
+		"451": "Unavailable For Legal Reasons",
+		"500": "Internal Server Error",
+		"501": "Not Implemented",
+		"502": "Bad Gateway",
+		"503": "Service Unavailable",
+		"504": "Gateway Timeout",
+		"505": "HTTP Version Not Supported",
+		"506": "Variant Also Negotiates",
+		"507": "Insufficient Storage",
+		"508": "Loop Detected",
+		"509": "Bandwidth Limit Exceeded",
+		"510": "Not Extended",
+		"511": "Network Authentication Required"
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/statuses@1.5.0/node_modules/statuses/index.js
+/*!
+* statuses
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_statuses = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var codes = require_codes();
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = status;
+	status.STATUS_CODES = codes;
+	status.codes = populateStatusesMap(status, codes);
+	status.redirect = {
+		300: true,
+		301: true,
+		302: true,
+		303: true,
+		305: true,
+		307: true,
+		308: true
+	};
+	status.empty = {
+		204: true,
+		205: true,
+		304: true
+	};
+	status.retry = {
+		502: true,
+		503: true,
+		504: true
+	};
+	/**
+	* Populate the statuses map for given codes.
+	* @private
+	*/
+	function populateStatusesMap(statuses, codes) {
+		var arr = [];
+		Object.keys(codes).forEach(function forEachCode(code) {
+			var message = codes[code];
+			var status = Number(code);
+			statuses[status] = message;
+			statuses[message] = status;
+			statuses[message.toLowerCase()] = status;
+			arr.push(status);
+		});
+		return arr;
+	}
+	/**
+	* Get the status code.
+	*
+	* Given a number, this will throw if it is not a known status
+	* code, otherwise the code will be returned. Given a string,
+	* the string will be parsed for a number and return the code
+	* if valid, otherwise will lookup the code assuming this is
+	* the status message.
+	*
+	* @param {string|number} code
+	* @returns {number}
+	* @public
+	*/
+	function status(code) {
+		if (typeof code === "number") {
+			if (!status[code]) throw new Error("invalid status code: " + code);
+			return code;
+		}
+		if (typeof code !== "string") throw new TypeError("code must be a number or string");
+		var n = parseInt(code, 10);
+		if (!isNaN(n)) {
+			if (!status[n]) throw new Error("invalid status code: " + n);
+			return n;
+		}
+		n = status[code.toLowerCase()];
+		if (!n) throw new Error("invalid status message: \"" + code + "\"");
+		return n;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/unpipe@1.0.0/node_modules/unpipe/index.js
+/*!
+* unpipe
+* Copyright(c) 2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_unpipe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = unpipe;
+	/**
+	* Determine if there are Node.js pipe-like data listeners.
+	* @private
+	*/
+	function hasPipeDataListeners(stream) {
+		var listeners = stream.listeners("data");
+		for (var i = 0; i < listeners.length; i++) if (listeners[i].name === "ondata") return true;
+		return false;
+	}
+	/**
+	* Unpipe a stream from all destinations.
+	*
+	* @param {object} stream
+	* @public
+	*/
+	function unpipe(stream) {
+		if (!stream) throw new TypeError("argument stream is required");
+		if (typeof stream.unpipe === "function") {
+			stream.unpipe();
+			return;
+		}
+		if (!hasPipeDataListeners(stream)) return;
+		var listener;
+		var listeners = stream.listeners("close");
+		for (var i = 0; i < listeners.length; i++) {
+			listener = listeners[i];
+			if (listener.name !== "cleanup" && listener.name !== "onclose") continue;
+			listener.call(stream);
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/finalhandler@1.1.2_ms@2.1.3/node_modules/finalhandler/index.js
+/*!
+* finalhandler
+* Copyright(c) 2014-2017 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_finalhandler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var debug = (init_node(), __toCommonJS(node_exports))("finalhandler");
+	var encodeUrl = require_encodeurl();
+	var escapeHtml = require_escape_html();
+	var onFinished = require_on_finished();
+	var parseUrl = require_parseurl();
+	var statuses = require_statuses();
+	var unpipe = require_unpipe();
+	/**
+	* Module variables.
+	* @private
+	*/
+	var DOUBLE_SPACE_REGEXP = /\x20{2}/g;
+	var NEWLINE_REGEXP = /\n/g;
+	/* istanbul ignore next */
+	var defer = typeof setImmediate === "function" ? setImmediate : function(fn) {
+		process.nextTick(fn.bind.apply(fn, arguments));
+	};
+	var isFinished = onFinished.isFinished;
+	/**
+	* Create a minimal HTML document.
+	*
+	* @param {string} message
+	* @private
+	*/
+	function createHtmlDocument(message) {
+		return "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<title>Error</title>\n</head>\n<body>\n<pre>" + escapeHtml(message).replace(NEWLINE_REGEXP, "<br>").replace(DOUBLE_SPACE_REGEXP, " &nbsp;") + "</pre>\n</body>\n</html>\n";
+	}
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = finalhandler;
+	/**
+	* Create a function to handle the final response.
+	*
+	* @param {Request} req
+	* @param {Response} res
+	* @param {Object} [options]
+	* @return {Function}
+	* @public
+	*/
+	function finalhandler(req, res, options) {
+		var opts = options || {};
+		var env = opts.env || process.env.NODE_ENV || "development";
+		var onerror = opts.onerror;
+		return function(err) {
+			var headers;
+			var msg;
+			var status;
+			if (!err && headersSent(res)) {
+				debug("cannot 404 after headers sent");
+				return;
+			}
+			if (err) {
+				status = getErrorStatusCode(err);
+				if (status === void 0) status = getResponseStatusCode(res);
+				else headers = getErrorHeaders(err);
+				msg = getErrorMessage(err, status, env);
+			} else {
+				status = 404;
+				msg = "Cannot " + req.method + " " + encodeUrl(getResourceName(req));
+			}
+			debug("default %s", status);
+			if (err && onerror) defer(onerror, err, req, res);
+			if (headersSent(res)) {
+				debug("cannot %d after headers sent", status);
+				req.socket.destroy();
+				return;
+			}
+			send(req, res, status, headers, msg);
+		};
+	}
+	/**
+	* Get headers from Error object.
+	*
+	* @param {Error} err
+	* @return {object}
+	* @private
+	*/
+	function getErrorHeaders(err) {
+		if (!err.headers || typeof err.headers !== "object") return;
+		var headers = Object.create(null);
+		var keys = Object.keys(err.headers);
+		for (var i = 0; i < keys.length; i++) {
+			var key = keys[i];
+			headers[key] = err.headers[key];
+		}
+		return headers;
+	}
+	/**
+	* Get message from Error object, fallback to status message.
+	*
+	* @param {Error} err
+	* @param {number} status
+	* @param {string} env
+	* @return {string}
+	* @private
+	*/
+	function getErrorMessage(err, status, env) {
+		var msg;
+		if (env !== "production") {
+			msg = err.stack;
+			if (!msg && typeof err.toString === "function") msg = err.toString();
+		}
+		return msg || statuses[status];
+	}
+	/**
+	* Get status code from Error object.
+	*
+	* @param {Error} err
+	* @return {number}
+	* @private
+	*/
+	function getErrorStatusCode(err) {
+		if (typeof err.status === "number" && err.status >= 400 && err.status < 600) return err.status;
+		if (typeof err.statusCode === "number" && err.statusCode >= 400 && err.statusCode < 600) return err.statusCode;
+	}
+	/**
+	* Get resource name for the request.
+	*
+	* This is typically just the original pathname of the request
+	* but will fallback to "resource" is that cannot be determined.
+	*
+	* @param {IncomingMessage} req
+	* @return {string}
+	* @private
+	*/
+	function getResourceName(req) {
+		try {
+			return parseUrl.original(req).pathname;
+		} catch (e) {
+			return "resource";
+		}
+	}
+	/**
+	* Get status code from response.
+	*
+	* @param {OutgoingMessage} res
+	* @return {number}
+	* @private
+	*/
+	function getResponseStatusCode(res) {
+		var status = res.statusCode;
+		if (typeof status !== "number" || status < 400 || status > 599) status = 500;
+		return status;
+	}
+	/**
+	* Determine if the response headers have been sent.
+	*
+	* @param {object} res
+	* @returns {boolean}
+	* @private
+	*/
+	function headersSent(res) {
+		return typeof res.headersSent !== "boolean" ? Boolean(res._header) : res.headersSent;
+	}
+	/**
+	* Send response.
+	*
+	* @param {IncomingMessage} req
+	* @param {OutgoingMessage} res
+	* @param {number} status
+	* @param {object} headers
+	* @param {string} message
+	* @private
+	*/
+	function send(req, res, status, headers, message) {
+		function write() {
+			var body = createHtmlDocument(message);
+			res.statusCode = status;
+			res.statusMessage = statuses[status];
+			setHeaders(res, headers);
+			res.setHeader("Content-Security-Policy", "default-src 'none'");
+			res.setHeader("X-Content-Type-Options", "nosniff");
+			res.setHeader("Content-Type", "text/html; charset=utf-8");
+			res.setHeader("Content-Length", Buffer.byteLength(body, "utf8"));
+			if (req.method === "HEAD") {
+				res.end();
+				return;
+			}
+			res.end(body, "utf8");
+		}
+		if (isFinished(req)) {
+			write();
+			return;
+		}
+		unpipe(req);
+		onFinished(req, write);
+		req.resume();
+	}
+	/**
+	* Set response headers from an object.
+	*
+	* @param {OutgoingMessage} res
+	* @param {object} headers
+	* @private
+	*/
+	function setHeaders(res, headers) {
+		if (!headers) return;
+		var keys = Object.keys(headers);
+		for (var i = 0; i < keys.length; i++) {
+			var key = keys[i];
+			res.setHeader(key, headers[key]);
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/utils-merge@1.0.1/node_modules/utils-merge/index.js
+var require_utils_merge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Merge object b with object a.
+	*
+	*     var a = { foo: 'bar' }
+	*       , b = { bar: 'baz' };
+	*
+	*     merge(a, b);
+	*     // => { foo: 'bar', bar: 'baz' }
+	*
+	* @param {Object} a
+	* @param {Object} b
+	* @return {Object}
+	* @api public
+	*/
+	exports = module.exports = function(a, b) {
+		if (a && b) for (var key in b) a[key] = b[key];
+		return a;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/connect@3.7.0_ms@2.1.3/node_modules/connect/index.js
+/*!
+* connect
+* Copyright(c) 2010 Sencha Inc.
+* Copyright(c) 2011 TJ Holowaychuk
+* Copyright(c) 2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var debug = (init_node(), __toCommonJS(node_exports))("connect:dispatcher");
+	var EventEmitter$4 = __require("events").EventEmitter;
+	var finalhandler = require_finalhandler();
+	var http$6 = __require("http");
+	var merge = require_utils_merge();
+	var parseUrl = require_parseurl();
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = createServer;
+	/**
+	* Module variables.
+	* @private
+	*/
+	var env = process.env.NODE_ENV || "development";
+	var proto = {};
+	/* istanbul ignore next */
+	var defer = typeof setImmediate === "function" ? setImmediate : function(fn) {
+		process.nextTick(fn.bind.apply(fn, arguments));
+	};
+	/**
+	* Create a new connect server.
+	*
+	* @return {function}
+	* @public
+	*/
+	function createServer() {
+		function app(req, res, next) {
+			app.handle(req, res, next);
+		}
+		merge(app, proto);
+		merge(app, EventEmitter$4.prototype);
+		app.route = "/";
+		app.stack = [];
+		return app;
+	}
+	/**
+	* Utilize the given middleware `handle` to the given `route`,
+	* defaulting to _/_. This "route" is the mount-point for the
+	* middleware, when given a value other than _/_ the middleware
+	* is only effective when that segment is present in the request's
+	* pathname.
+	*
+	* For example if we were to mount a function at _/admin_, it would
+	* be invoked on _/admin_, and _/admin/settings_, however it would
+	* not be invoked for _/_, or _/posts_.
+	*
+	* @param {String|Function|Server} route, callback or server
+	* @param {Function|Server} callback or server
+	* @return {Server} for chaining
+	* @public
+	*/
+	proto.use = function use(route, fn) {
+		var handle = fn;
+		var path = route;
+		if (typeof route !== "string") {
+			handle = route;
+			path = "/";
+		}
+		if (typeof handle.handle === "function") {
+			var server = handle;
+			server.route = path;
+			handle = function(req, res, next) {
+				server.handle(req, res, next);
+			};
+		}
+		if (handle instanceof http$6.Server) handle = handle.listeners("request")[0];
+		if (path[path.length - 1] === "/") path = path.slice(0, -1);
+		debug("use %s %s", path || "/", handle.name || "anonymous");
+		this.stack.push({
+			route: path,
+			handle
+		});
+		return this;
+	};
+	/**
+	* Handle server requests, punting them down
+	* the middleware stack.
+	*
+	* @private
+	*/
+	proto.handle = function handle(req, res, out) {
+		var index = 0;
+		var protohost = getProtohost(req.url) || "";
+		var removed = "";
+		var slashAdded = false;
+		var stack = this.stack;
+		var done = out || finalhandler(req, res, {
+			env,
+			onerror: logerror
+		});
+		req.originalUrl = req.originalUrl || req.url;
+		function next(err) {
+			if (slashAdded) {
+				req.url = req.url.substr(1);
+				slashAdded = false;
+			}
+			if (removed.length !== 0) {
+				req.url = protohost + removed + req.url.substr(protohost.length);
+				removed = "";
+			}
+			var layer = stack[index++];
+			if (!layer) {
+				defer(done, err);
+				return;
+			}
+			var path = parseUrl(req).pathname || "/";
+			var route = layer.route;
+			if (path.toLowerCase().substr(0, route.length) !== route.toLowerCase()) return next(err);
+			var c = path.length > route.length && path[route.length];
+			if (c && c !== "/" && c !== ".") return next(err);
+			if (route.length !== 0 && route !== "/") {
+				removed = route;
+				req.url = protohost + req.url.substr(protohost.length + removed.length);
+				if (!protohost && req.url[0] !== "/") {
+					req.url = "/" + req.url;
+					slashAdded = true;
+				}
+			}
+			call(layer.handle, route, err, req, res, next);
+		}
+		next();
+	};
+	/**
+	* Listen for connections.
+	*
+	* This method takes the same arguments
+	* as node's `http.Server#listen()`.
+	*
+	* HTTP and HTTPS:
+	*
+	* If you run your application both as HTTP
+	* and HTTPS you may wrap them individually,
+	* since your Connect "server" is really just
+	* a JavaScript `Function`.
+	*
+	*      var connect = require('connect')
+	*        , http = require('http')
+	*        , https = require('https');
+	*
+	*      var app = connect();
+	*
+	*      http.createServer(app).listen(80);
+	*      https.createServer(options, app).listen(443);
+	*
+	* @return {http.Server}
+	* @api public
+	*/
+	proto.listen = function listen() {
+		var server = http$6.createServer(this);
+		return server.listen.apply(server, arguments);
+	};
+	/**
+	* Invoke a route handle.
+	* @private
+	*/
+	function call(handle, route, err, req, res, next) {
+		var arity = handle.length;
+		var error = err;
+		var hasError = Boolean(err);
+		debug("%s %s : %s", handle.name || "<anonymous>", route, req.originalUrl);
+		try {
+			if (hasError && arity === 4) {
+				handle(err, req, res, next);
+				return;
+			} else if (!hasError && arity < 4) {
+				handle(req, res, next);
+				return;
+			}
+		} catch (e) {
+			error = e;
+		}
+		next(error);
+	}
+	/**
+	* Log error using console.error.
+	*
+	* @param {Error} err
+	* @private
+	*/
+	function logerror(err) {
+		if (env !== "test") console.error(err.stack || err.toString());
+	}
+	/**
+	* Get get protocol + host for a URL.
+	*
+	* @param {string} url
+	* @private
+	*/
+	function getProtohost(url) {
+		if (url.length === 0 || url[0] === "/") return;
+		var fqdnIndex = url.indexOf("://");
+		return fqdnIndex !== -1 && url.lastIndexOf("?", fqdnIndex) === -1 ? url.substr(0, url.indexOf("/", 3 + fqdnIndex)) : void 0;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var require_object_assign = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+	function toObject(val) {
+		if (val === null || val === void 0) throw new TypeError("Object.assign cannot be called with null or undefined");
+		return Object(val);
+	}
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) return false;
+			var test1 = /* @__PURE__ */ new String("abc");
+			test1[5] = "de";
+			if (Object.getOwnPropertyNames(test1)[0] === "5") return false;
+			var test2 = {};
+			for (var i = 0; i < 10; i++) test2["_" + String.fromCharCode(i)] = i;
+			if (Object.getOwnPropertyNames(test2).map(function(n) {
+				return test2[n];
+			}).join("") !== "0123456789") return false;
+			var test3 = {};
+			"abcdefghijklmnopqrst".split("").forEach(function(letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") return false;
+			return true;
+		} catch (err) {
+			return false;
+		}
+	}
+	module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+			for (var key in from) if (hasOwnProperty.call(from, key)) to[key] = from[key];
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) if (propIsEnumerable.call(from, symbols[i])) to[symbols[i]] = from[symbols[i]];
+			}
+		}
+		return to;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/vary@1.1.2/node_modules/vary/index.js
+/*!
+* vary
+* Copyright(c) 2014-2017 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_vary = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	*/
+	module.exports = vary;
+	module.exports.append = append;
+	/**
+	* RegExp to match field-name in RFC 7230 sec 3.2
+	*
+	* field-name    = token
+	* token         = 1*tchar
+	* tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+	*               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+	*               / DIGIT / ALPHA
+	*               ; any VCHAR, except delimiters
+	*/
+	var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+	/**
+	* Append a field to a vary header.
+	*
+	* @param {String} header
+	* @param {String|Array} field
+	* @return {String}
+	* @public
+	*/
+	function append(header, field) {
+		if (typeof header !== "string") throw new TypeError("header argument is required");
+		if (!field) throw new TypeError("field argument is required");
+		var fields = !Array.isArray(field) ? parse(String(field)) : field;
+		for (var j = 0; j < fields.length; j++) if (!FIELD_NAME_REGEXP.test(fields[j])) throw new TypeError("field argument contains an invalid header name");
+		if (header === "*") return header;
+		var val = header;
+		var vals = parse(header.toLowerCase());
+		if (fields.indexOf("*") !== -1 || vals.indexOf("*") !== -1) return "*";
+		for (var i = 0; i < fields.length; i++) {
+			var fld = fields[i].toLowerCase();
+			if (vals.indexOf(fld) === -1) {
+				vals.push(fld);
+				val = val ? val + ", " + fields[i] : fields[i];
+			}
+		}
+		return val;
+	}
+	/**
+	* Parse a vary header into an array.
+	*
+	* @param {String} header
+	* @return {Array}
+	* @private
+	*/
+	function parse(header) {
+		var end = 0;
+		var list = [];
+		var start = 0;
+		for (var i = 0, len = header.length; i < len; i++) switch (header.charCodeAt(i)) {
+			case 32:
+				if (start === end) start = end = i + 1;
+				break;
+			case 44:
+				list.push(header.substring(start, end));
+				start = end = i + 1;
+				break;
+			default:
+				end = i + 1;
+				break;
+		}
+		list.push(header.substring(start, end));
+		return list;
+	}
+	/**
+	* Mark that a request is varied on a header field.
+	*
+	* @param {Object} res
+	* @param {String|Array} field
+	* @public
+	*/
+	function vary(res, field) {
+		if (!res || !res.getHeader || !res.setHeader) throw new TypeError("res argument is required");
+		var val = res.getHeader("Vary") || "";
+		if (val = append(Array.isArray(val) ? val.join(", ") : String(val), field)) res.setHeader("Vary", val);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cors@2.8.6/node_modules/cors/lib/index.js
+var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function() {
+		"use strict";
+		var assign = require_object_assign();
+		var vary = require_vary();
+		var defaults = {
+			origin: "*",
+			methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
+			preflightContinue: false,
+			optionsSuccessStatus: 204
+		};
+		function isString(s) {
+			return typeof s === "string" || s instanceof String;
+		}
+		function isOriginAllowed(origin, allowedOrigin) {
+			if (Array.isArray(allowedOrigin)) {
+				for (var i = 0; i < allowedOrigin.length; ++i) if (isOriginAllowed(origin, allowedOrigin[i])) return true;
+				return false;
+			} else if (isString(allowedOrigin)) return origin === allowedOrigin;
+			else if (allowedOrigin instanceof RegExp) return allowedOrigin.test(origin);
+			else return !!allowedOrigin;
+		}
+		function configureOrigin(options, req) {
+			var requestOrigin = req.headers.origin, headers = [], isAllowed;
+			if (!options.origin || options.origin === "*") headers.push([{
+				key: "Access-Control-Allow-Origin",
+				value: "*"
+			}]);
+			else if (isString(options.origin)) {
+				headers.push([{
+					key: "Access-Control-Allow-Origin",
+					value: options.origin
+				}]);
+				headers.push([{
+					key: "Vary",
+					value: "Origin"
+				}]);
+			} else {
+				isAllowed = isOriginAllowed(requestOrigin, options.origin);
+				headers.push([{
+					key: "Access-Control-Allow-Origin",
+					value: isAllowed ? requestOrigin : false
+				}]);
+				headers.push([{
+					key: "Vary",
+					value: "Origin"
+				}]);
+			}
+			return headers;
+		}
+		function configureMethods(options) {
+			var methods = options.methods;
+			if (methods.join) methods = options.methods.join(",");
+			return {
+				key: "Access-Control-Allow-Methods",
+				value: methods
+			};
+		}
+		function configureCredentials(options) {
+			if (options.credentials === true) return {
+				key: "Access-Control-Allow-Credentials",
+				value: "true"
+			};
+			return null;
+		}
+		function configureAllowedHeaders(options, req) {
+			var allowedHeaders = options.allowedHeaders || options.headers;
+			var headers = [];
+			if (!allowedHeaders) {
+				allowedHeaders = req.headers["access-control-request-headers"];
+				headers.push([{
+					key: "Vary",
+					value: "Access-Control-Request-Headers"
+				}]);
+			} else if (allowedHeaders.join) allowedHeaders = allowedHeaders.join(",");
+			if (allowedHeaders && allowedHeaders.length) headers.push([{
+				key: "Access-Control-Allow-Headers",
+				value: allowedHeaders
+			}]);
+			return headers;
+		}
+		function configureExposedHeaders(options) {
+			var headers = options.exposedHeaders;
+			if (!headers) return null;
+			else if (headers.join) headers = headers.join(",");
+			if (headers && headers.length) return {
+				key: "Access-Control-Expose-Headers",
+				value: headers
+			};
+			return null;
+		}
+		function configureMaxAge(options) {
+			var maxAge = (typeof options.maxAge === "number" || options.maxAge) && options.maxAge.toString();
+			if (maxAge && maxAge.length) return {
+				key: "Access-Control-Max-Age",
+				value: maxAge
+			};
+			return null;
+		}
+		function applyHeaders(headers, res) {
+			for (var i = 0, n = headers.length; i < n; i++) {
+				var header = headers[i];
+				if (header) {
+					if (Array.isArray(header)) applyHeaders(header, res);
+					else if (header.key === "Vary" && header.value) vary(res, header.value);
+					else if (header.value) res.setHeader(header.key, header.value);
+				}
+			}
+		}
+		function cors(options, req, res, next) {
+			var headers = [];
+			if ((req.method && req.method.toUpperCase && req.method.toUpperCase()) === "OPTIONS") {
+				headers.push(configureOrigin(options, req));
+				headers.push(configureCredentials(options));
+				headers.push(configureMethods(options));
+				headers.push(configureAllowedHeaders(options, req));
+				headers.push(configureMaxAge(options));
+				headers.push(configureExposedHeaders(options));
+				applyHeaders(headers, res);
+				if (options.preflightContinue) next();
+				else {
+					res.statusCode = options.optionsSuccessStatus;
+					res.setHeader("Content-Length", "0");
+					res.end();
+				}
+			} else {
+				headers.push(configureOrigin(options, req));
+				headers.push(configureCredentials(options));
+				headers.push(configureExposedHeaders(options));
+				applyHeaders(headers, res);
+				next();
+			}
+		}
+		function middlewareWrapper(o) {
+			var optionsCallback = null;
+			if (typeof o === "function") optionsCallback = o;
+			else optionsCallback = function(req, cb) {
+				cb(null, o);
+			};
+			return function corsMiddleware(req, res, next) {
+				optionsCallback(req, function(err, options) {
+					if (err) next(err);
+					else {
+						var corsOptions = assign({}, defaults, options);
+						var originCallback = null;
+						if (corsOptions.origin && typeof corsOptions.origin === "function") originCallback = corsOptions.origin;
+						else if (corsOptions.origin) originCallback = function(origin, cb) {
+							cb(null, corsOptions.origin);
+						};
+						if (originCallback) originCallback(req.headers.origin, function(err2, origin) {
+							if (err2 || !origin) next(err2);
+							else {
+								corsOptions.origin = origin;
+								cors(corsOptions, req, res, next);
+							}
+						});
+						else next();
+					}
+				});
+			};
+		}
+		module.exports = middlewareWrapper;
+	})();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/readdirp@3.6.0/node_modules/readdirp/index.js
+var require_readdirp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$10 = __require("fs");
+	const { Readable: Readable$1 } = __require("stream");
+	const sysPath$3 = __require("path");
+	const { promisify: promisify$4 } = __require("util");
+	const picomatch$2 = __require("picomatch");
+	const readdir = promisify$4(fs$10.readdir);
+	const stat = promisify$4(fs$10.stat);
+	const lstat = promisify$4(fs$10.lstat);
+	const realpath = promisify$4(fs$10.realpath);
+	/**
+	* @typedef {Object} EntryInfo
+	* @property {String} path
+	* @property {String} fullPath
+	* @property {fs.Stats=} stats
+	* @property {fs.Dirent=} dirent
+	* @property {String} basename
+	*/
+	const BANG = "!";
+	const RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+	const NORMAL_FLOW_ERRORS = new Set([
+		"ENOENT",
+		"EPERM",
+		"EACCES",
+		"ELOOP",
+		RECURSIVE_ERROR_CODE
+	]);
+	const FILE_TYPE = "files";
+	const DIR_TYPE = "directories";
+	const FILE_DIR_TYPE = "files_directories";
+	const EVERYTHING_TYPE = "all";
+	const ALL_TYPES = [
+		FILE_TYPE,
+		DIR_TYPE,
+		FILE_DIR_TYPE,
+		EVERYTHING_TYPE
+	];
+	const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+	const [maj, min] = process.versions.node.split(".").slice(0, 2).map((n) => Number.parseInt(n, 10));
+	const wantBigintFsStats = process.platform === "win32" && (maj > 10 || maj === 10 && min >= 5);
+	const normalizeFilter = (filter) => {
+		if (filter === void 0) return;
+		if (typeof filter === "function") return filter;
+		if (typeof filter === "string") {
+			const glob = picomatch$2(filter.trim());
+			return (entry) => glob(entry.basename);
+		}
+		if (Array.isArray(filter)) {
+			const positive = [];
+			const negative = [];
+			for (const item of filter) {
+				const trimmed = item.trim();
+				if (trimmed.charAt(0) === BANG) negative.push(picomatch$2(trimmed.slice(1)));
+				else positive.push(picomatch$2(trimmed));
+			}
+			if (negative.length > 0) {
+				if (positive.length > 0) return (entry) => positive.some((f) => f(entry.basename)) && !negative.some((f) => f(entry.basename));
+				return (entry) => !negative.some((f) => f(entry.basename));
+			}
+			return (entry) => positive.some((f) => f(entry.basename));
+		}
+	};
+	var ReaddirpStream = class ReaddirpStream extends Readable$1 {
+		static get defaultOptions() {
+			return {
+				root: ".",
+				fileFilter: (path) => true,
+				directoryFilter: (path) => true,
+				type: FILE_TYPE,
+				lstat: false,
+				depth: 2147483648,
+				alwaysStat: false
+			};
+		}
+		constructor(options = {}) {
+			super({
+				objectMode: true,
+				autoDestroy: true,
+				highWaterMark: options.highWaterMark || 4096
+			});
+			const opts = {
+				...ReaddirpStream.defaultOptions,
+				...options
+			};
+			const { root, type } = opts;
+			this._fileFilter = normalizeFilter(opts.fileFilter);
+			this._directoryFilter = normalizeFilter(opts.directoryFilter);
+			const statMethod = opts.lstat ? lstat : stat;
+			if (wantBigintFsStats) this._stat = (path) => statMethod(path, { bigint: true });
+			else this._stat = statMethod;
+			this._maxDepth = opts.depth;
+			this._wantsDir = [
+				DIR_TYPE,
+				FILE_DIR_TYPE,
+				EVERYTHING_TYPE
+			].includes(type);
+			this._wantsFile = [
+				FILE_TYPE,
+				FILE_DIR_TYPE,
+				EVERYTHING_TYPE
+			].includes(type);
+			this._wantsEverything = type === EVERYTHING_TYPE;
+			this._root = sysPath$3.resolve(root);
+			this._isDirent = "Dirent" in fs$10 && !opts.alwaysStat;
+			this._statsProp = this._isDirent ? "dirent" : "stats";
+			this._rdOptions = {
+				encoding: "utf8",
+				withFileTypes: this._isDirent
+			};
+			this.parents = [this._exploreDir(root, 1)];
+			this.reading = false;
+			this.parent = void 0;
+		}
+		async _read(batch) {
+			if (this.reading) return;
+			this.reading = true;
+			try {
+				while (!this.destroyed && batch > 0) {
+					const { path, depth, files = [] } = this.parent || {};
+					if (files.length > 0) {
+						const slice = files.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+						for (const entry of await Promise.all(slice)) {
+							if (this.destroyed) return;
+							const entryType = await this._getEntryType(entry);
+							if (entryType === "directory" && this._directoryFilter(entry)) {
+								if (depth <= this._maxDepth) this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+								if (this._wantsDir) {
+									this.push(entry);
+									batch--;
+								}
+							} else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+								if (this._wantsFile) {
+									this.push(entry);
+									batch--;
+								}
+							}
+						}
+					} else {
+						const parent = this.parents.pop();
+						if (!parent) {
+							this.push(null);
+							break;
+						}
+						this.parent = await parent;
+						if (this.destroyed) return;
+					}
+				}
+			} catch (error) {
+				this.destroy(error);
+			} finally {
+				this.reading = false;
+			}
+		}
+		async _exploreDir(path, depth) {
+			let files;
+			try {
+				files = await readdir(path, this._rdOptions);
+			} catch (error) {
+				this._onError(error);
+			}
+			return {
+				files,
+				depth,
+				path
+			};
+		}
+		async _formatEntry(dirent, path) {
+			let entry;
+			try {
+				const basename = this._isDirent ? dirent.name : dirent;
+				const fullPath = sysPath$3.resolve(sysPath$3.join(path, basename));
+				entry = {
+					path: sysPath$3.relative(this._root, fullPath),
+					fullPath,
+					basename
+				};
+				entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+			} catch (err) {
+				this._onError(err);
+			}
+			return entry;
+		}
+		_onError(err) {
+			if (isNormalFlowError(err) && !this.destroyed) this.emit("warn", err);
+			else this.destroy(err);
+		}
+		async _getEntryType(entry) {
+			const stats = entry && entry[this._statsProp];
+			if (!stats) return;
+			if (stats.isFile()) return "file";
+			if (stats.isDirectory()) return "directory";
+			if (stats && stats.isSymbolicLink()) {
+				const full = entry.fullPath;
+				try {
+					const entryRealPath = await realpath(full);
+					const entryRealPathStats = await lstat(entryRealPath);
+					if (entryRealPathStats.isFile()) return "file";
+					if (entryRealPathStats.isDirectory()) {
+						const len = entryRealPath.length;
+						if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath$3.sep) {
+							const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+							recursiveError.code = RECURSIVE_ERROR_CODE;
+							return this._onError(recursiveError);
+						}
+						return "directory";
+					}
+				} catch (error) {
+					this._onError(error);
+				}
+			}
+		}
+		_includeAsFile(entry) {
+			const stats = entry && entry[this._statsProp];
+			return stats && this._wantsEverything && !stats.isDirectory();
+		}
+	};
+	/**
+	* @typedef {Object} ReaddirpArguments
+	* @property {Function=} fileFilter
+	* @property {Function=} directoryFilter
+	* @property {String=} type
+	* @property {Number=} depth
+	* @property {String=} root
+	* @property {Boolean=} lstat
+	* @property {Boolean=} bigint
+	*/
+	/**
+	* Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
+	* @param {String} root Root directory
+	* @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
+	*/
+	const readdirp = (root, options = {}) => {
+		let type = options.entryType || options.type;
+		if (type === "both") type = FILE_DIR_TYPE;
+		if (type) options.type = type;
+		if (!root) throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+		else if (typeof root !== "string") throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+		else if (type && !ALL_TYPES.includes(type)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+		options.root = root;
+		return new ReaddirpStream(options);
+	};
+	const readdirpPromise = (root, options = {}) => {
+		return new Promise((resolve, reject) => {
+			const files = [];
+			readdirp(root, options).on("data", (entry) => files.push(entry)).on("end", () => resolve(files)).on("error", (error) => reject(error));
+		});
+	};
+	readdirp.promise = readdirpPromise;
+	readdirp.ReaddirpStream = ReaddirpStream;
+	readdirp.default = readdirp;
+	module.exports = readdirp;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-path@3.0.0/node_modules/normalize-path/index.js
+var require_normalize_path = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/*!
+	* normalize-path <https://github.com/jonschlinkert/normalize-path>
+	*
+	* Copyright (c) 2014-2018, Jon Schlinkert.
+	* Released under the MIT License.
+	*/
+	module.exports = function(path, stripTrailing) {
+		if (typeof path !== "string") throw new TypeError("expected path to be a string");
+		if (path === "\\" || path === "/") return "/";
+		var len = path.length;
+		if (len <= 1) return path;
+		var prefix = "";
+		if (len > 4 && path[3] === "\\") {
+			var ch = path[2];
+			if ((ch === "?" || ch === ".") && path.slice(0, 2) === "\\\\") {
+				path = path.slice(2);
+				prefix = "//";
+			}
+		}
+		var segs = path.split(/[/\\]+/);
+		if (stripTrailing !== false && segs[segs.length - 1] === "") segs.pop();
+		return prefix + segs.join("/");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/anymatch@3.1.3/node_modules/anymatch/index.js
+var require_anymatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const picomatch$1 = __require("picomatch");
+	const normalizePath = require_normalize_path();
+	/**
+	* @typedef {(testString: string) => boolean} AnymatchFn
+	* @typedef {string|RegExp|AnymatchFn} AnymatchPattern
+	* @typedef {AnymatchPattern|AnymatchPattern[]} AnymatchMatcher
+	*/
+	const BANG = "!";
+	const DEFAULT_OPTIONS = { returnIndex: false };
+	const arrify = (item) => Array.isArray(item) ? item : [item];
+	/**
+	* @param {AnymatchPattern} matcher
+	* @param {object} options
+	* @returns {AnymatchFn}
+	*/
+	const createPattern = (matcher, options) => {
+		if (typeof matcher === "function") return matcher;
+		if (typeof matcher === "string") {
+			const glob = picomatch$1(matcher, options);
+			return (string) => matcher === string || glob(string);
+		}
+		if (matcher instanceof RegExp) return (string) => matcher.test(string);
+		return (string) => false;
+	};
+	/**
+	* @param {Array<Function>} patterns
+	* @param {Array<Function>} negPatterns
+	* @param {String|Array} args
+	* @param {Boolean} returnIndex
+	* @returns {boolean|number}
+	*/
+	const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
+		const isList = Array.isArray(args);
+		const _path = isList ? args[0] : args;
+		if (!isList && typeof _path !== "string") throw new TypeError("anymatch: second argument must be a string: got " + Object.prototype.toString.call(_path));
+		const path = normalizePath(_path, false);
+		for (let index = 0; index < negPatterns.length; index++) {
+			const nglob = negPatterns[index];
+			if (nglob(path)) return returnIndex ? -1 : false;
+		}
+		const applied = isList && [path].concat(args.slice(1));
+		for (let index = 0; index < patterns.length; index++) {
+			const pattern = patterns[index];
+			if (isList ? pattern(...applied) : pattern(path)) return returnIndex ? index : true;
+		}
+		return returnIndex ? -1 : false;
+	};
+	/**
+	* @param {AnymatchMatcher} matchers
+	* @param {Array|string} testString
+	* @param {object} options
+	* @returns {boolean|number|Function}
+	*/
+	const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
+		if (matchers == null) throw new TypeError("anymatch: specify first argument");
+		const opts = typeof options === "boolean" ? { returnIndex: options } : options;
+		const returnIndex = opts.returnIndex || false;
+		const mtchers = arrify(matchers);
+		const negatedGlobs = mtchers.filter((item) => typeof item === "string" && item.charAt(0) === BANG).map((item) => item.slice(1)).map((item) => picomatch$1(item, opts));
+		const patterns = mtchers.filter((item) => typeof item !== "string" || typeof item === "string" && item.charAt(0) !== BANG).map((matcher) => createPattern(matcher, opts));
+		if (testString == null) return (testString, ri = false) => {
+			return matchPatterns(patterns, negatedGlobs, testString, typeof ri === "boolean" ? ri : false);
+		};
+		return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+	};
+	anymatch.default = anymatch;
+	module.exports = anymatch;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js
+var require_is_extglob = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/*!
+	* is-extglob <https://github.com/jonschlinkert/is-extglob>
+	*
+	* Copyright (c) 2014-2016, Jon Schlinkert.
+	* Licensed under the MIT License.
+	*/
+	module.exports = function isExtglob(str) {
+		if (typeof str !== "string" || str === "") return false;
+		var match;
+		while (match = /(\\).|([@?!+*]\(.*\))/g.exec(str)) {
+			if (match[2]) return true;
+			str = str.slice(match.index + match[0].length);
+		}
+		return false;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js
+var require_is_glob = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/*!
+	* is-glob <https://github.com/jonschlinkert/is-glob>
+	*
+	* Copyright (c) 2014-2017, Jon Schlinkert.
+	* Released under the MIT License.
+	*/
+	var isExtglob = require_is_extglob();
+	var chars = {
+		"{": "}",
+		"(": ")",
+		"[": "]"
+	};
+	var strictCheck = function(str) {
+		if (str[0] === "!") return true;
+		var index = 0;
+		var pipeIndex = -2;
+		var closeSquareIndex = -2;
+		var closeCurlyIndex = -2;
+		var closeParenIndex = -2;
+		var backSlashIndex = -2;
+		while (index < str.length) {
+			if (str[index] === "*") return true;
+			if (str[index + 1] === "?" && /[\].+)]/.test(str[index])) return true;
+			if (closeSquareIndex !== -1 && str[index] === "[" && str[index + 1] !== "]") {
+				if (closeSquareIndex < index) closeSquareIndex = str.indexOf("]", index);
+				if (closeSquareIndex > index) {
+					if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) return true;
+					backSlashIndex = str.indexOf("\\", index);
+					if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) return true;
+				}
+			}
+			if (closeCurlyIndex !== -1 && str[index] === "{" && str[index + 1] !== "}") {
+				closeCurlyIndex = str.indexOf("}", index);
+				if (closeCurlyIndex > index) {
+					backSlashIndex = str.indexOf("\\", index);
+					if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) return true;
+				}
+			}
+			if (closeParenIndex !== -1 && str[index] === "(" && str[index + 1] === "?" && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ")") {
+				closeParenIndex = str.indexOf(")", index);
+				if (closeParenIndex > index) {
+					backSlashIndex = str.indexOf("\\", index);
+					if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) return true;
+				}
+			}
+			if (pipeIndex !== -1 && str[index] === "(" && str[index + 1] !== "|") {
+				if (pipeIndex < index) pipeIndex = str.indexOf("|", index);
+				if (pipeIndex !== -1 && str[pipeIndex + 1] !== ")") {
+					closeParenIndex = str.indexOf(")", pipeIndex);
+					if (closeParenIndex > pipeIndex) {
+						backSlashIndex = str.indexOf("\\", pipeIndex);
+						if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) return true;
+					}
+				}
+			}
+			if (str[index] === "\\") {
+				var open = str[index + 1];
+				index += 2;
+				var close = chars[open];
+				if (close) {
+					var n = str.indexOf(close, index);
+					if (n !== -1) index = n + 1;
+				}
+				if (str[index] === "!") return true;
+			} else index++;
+		}
+		return false;
+	};
+	var relaxedCheck = function(str) {
+		if (str[0] === "!") return true;
+		var index = 0;
+		while (index < str.length) {
+			if (/[*?{}()[\]]/.test(str[index])) return true;
+			if (str[index] === "\\") {
+				var open = str[index + 1];
+				index += 2;
+				var close = chars[open];
+				if (close) {
+					var n = str.indexOf(close, index);
+					if (n !== -1) index = n + 1;
+				}
+				if (str[index] === "!") return true;
+			} else index++;
+		}
+		return false;
+	};
+	module.exports = function isGlob(str, options) {
+		if (typeof str !== "string" || str === "") return false;
+		if (isExtglob(str)) return true;
+		var check = strictCheck;
+		if (options && options.strict === false) check = relaxedCheck;
+		return check(str);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/glob-parent@5.1.2/node_modules/glob-parent/index.js
+var require_glob_parent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isGlob = require_is_glob();
+	var pathPosixDirname = __require("path").posix.dirname;
+	var isWin32 = __require("os").platform() === "win32";
+	var slash = "/";
+	var backslash = /\\/g;
+	var enclosure = /[\{\[].*[\}\]]$/;
+	var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+	var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+	/**
+	* @param {string} str
+	* @param {Object} opts
+	* @param {boolean} [opts.flipBackslashes=true]
+	* @returns {string}
+	*/
+	module.exports = function globParent(str, opts) {
+		if (Object.assign({ flipBackslashes: true }, opts).flipBackslashes && isWin32 && str.indexOf(slash) < 0) str = str.replace(backslash, slash);
+		if (enclosure.test(str)) str += slash;
+		str += "a";
+		do
+			str = pathPosixDirname(str);
+		while (isGlob(str) || globby.test(str));
+		return str.replace(escaped, "$1");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.isInteger = (num) => {
+		if (typeof num === "number") return Number.isInteger(num);
+		if (typeof num === "string" && num.trim() !== "") return Number.isInteger(Number(num));
+		return false;
+	};
+	/**
+	* Find a node of the given type
+	*/
+	exports.find = (node, type) => node.nodes.find((node) => node.type === type);
+	/**
+	* Find a node of the given type
+	*/
+	exports.exceedsLimit = (min, max, step = 1, limit) => {
+		if (limit === false) return false;
+		if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+		return (Number(max) - Number(min)) / Number(step) >= limit;
+	};
+	/**
+	* Escape the given node with '\\' before node.value
+	*/
+	exports.escapeNode = (block, n = 0, type) => {
+		const node = block.nodes[n];
+		if (!node) return;
+		if (type && node.type === type || node.type === "open" || node.type === "close") {
+			if (node.escaped !== true) {
+				node.value = "\\" + node.value;
+				node.escaped = true;
+			}
+		}
+	};
+	/**
+	* Returns true if the given brace node should be enclosed in literal braces
+	*/
+	exports.encloseBrace = (node) => {
+		if (node.type !== "brace") return false;
+		if (node.commas >> 0 + node.ranges >> 0 === 0) {
+			node.invalid = true;
+			return true;
+		}
+		return false;
+	};
+	/**
+	* Returns true if a brace node is invalid.
+	*/
+	exports.isInvalidBrace = (block) => {
+		if (block.type !== "brace") return false;
+		if (block.invalid === true || block.dollar) return true;
+		if (block.commas >> 0 + block.ranges >> 0 === 0) {
+			block.invalid = true;
+			return true;
+		}
+		if (block.open !== true || block.close !== true) {
+			block.invalid = true;
+			return true;
+		}
+		return false;
+	};
+	/**
+	* Returns true if a node is an open or close node
+	*/
+	exports.isOpenOrClose = (node) => {
+		if (node.type === "open" || node.type === "close") return true;
+		return node.open === true || node.close === true;
+	};
+	/**
+	* Reduce an array of text nodes.
+	*/
+	exports.reduce = (nodes) => nodes.reduce((acc, node) => {
+		if (node.type === "text") acc.push(node.value);
+		if (node.type === "range") node.type = "text";
+		return acc;
+	}, []);
+	/**
+	* Flatten an array
+	*/
+	exports.flatten = (...args) => {
+		const result = [];
+		const flat = (arr) => {
+			for (let i = 0; i < arr.length; i++) {
+				const ele = arr[i];
+				if (Array.isArray(ele)) {
+					flat(ele);
+					continue;
+				}
+				if (ele !== void 0) result.push(ele);
+			}
+			return result;
+		};
+		flat(args);
+		return result;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js
+var require_stringify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const utils = require_utils();
+	module.exports = (ast, options = {}) => {
+		const stringify = (node, parent = {}) => {
+			const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+			const invalidNode = node.invalid === true && options.escapeInvalid === true;
+			let output = "";
+			if (node.value) {
+				if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) return "\\" + node.value;
+				return node.value;
+			}
+			if (node.value) return node.value;
+			if (node.nodes) for (const child of node.nodes) output += stringify(child);
+			return output;
+		};
+		return stringify(ast);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js
+/*!
+* is-number <https://github.com/jonschlinkert/is-number>
+*
+* Copyright (c) 2014-present, Jon Schlinkert.
+* Released under the MIT License.
+*/
+var require_is_number = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function(num) {
+		if (typeof num === "number") return num - num === 0;
+		if (typeof num === "string" && num.trim() !== "") return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+		return false;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js
+/*!
+* to-regex-range <https://github.com/micromatch/to-regex-range>
+*
+* Copyright (c) 2015-present, Jon Schlinkert.
+* Released under the MIT License.
+*/
+var require_to_regex_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isNumber = require_is_number();
+	const toRegexRange = (min, max, options) => {
+		if (isNumber(min) === false) throw new TypeError("toRegexRange: expected the first argument to be a number");
+		if (max === void 0 || min === max) return String(min);
+		if (isNumber(max) === false) throw new TypeError("toRegexRange: expected the second argument to be a number.");
+		let opts = {
+			relaxZeros: true,
+			...options
+		};
+		if (typeof opts.strictZeros === "boolean") opts.relaxZeros = opts.strictZeros === false;
+		let relax = String(opts.relaxZeros);
+		let shorthand = String(opts.shorthand);
+		let capture = String(opts.capture);
+		let wrap = String(opts.wrap);
+		let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap;
+		if (toRegexRange.cache.hasOwnProperty(cacheKey)) return toRegexRange.cache[cacheKey].result;
+		let a = Math.min(min, max);
+		let b = Math.max(min, max);
+		if (Math.abs(a - b) === 1) {
+			let result = min + "|" + max;
+			if (opts.capture) return `(${result})`;
+			if (opts.wrap === false) return result;
+			return `(?:${result})`;
+		}
+		let isPadded = hasPadding(min) || hasPadding(max);
+		let state = {
+			min,
+			max,
+			a,
+			b
+		};
+		let positives = [];
+		let negatives = [];
+		if (isPadded) {
+			state.isPadded = isPadded;
+			state.maxLen = String(state.max).length;
+		}
+		if (a < 0) {
+			negatives = splitToPatterns(b < 0 ? Math.abs(b) : 1, Math.abs(a), state, opts);
+			a = state.a = 0;
+		}
+		if (b >= 0) positives = splitToPatterns(a, b, state, opts);
+		state.negatives = negatives;
+		state.positives = positives;
+		state.result = collatePatterns(negatives, positives, opts);
+		if (opts.capture === true) state.result = `(${state.result})`;
+		else if (opts.wrap !== false && positives.length + negatives.length > 1) state.result = `(?:${state.result})`;
+		toRegexRange.cache[cacheKey] = state;
+		return state.result;
+	};
+	function collatePatterns(neg, pos, options) {
+		let onlyNegative = filterPatterns(neg, pos, "-", false, options) || [];
+		let onlyPositive = filterPatterns(pos, neg, "", false, options) || [];
+		let intersected = filterPatterns(neg, pos, "-?", true, options) || [];
+		return onlyNegative.concat(intersected).concat(onlyPositive).join("|");
+	}
+	function splitToRanges(min, max) {
+		let nines = 1;
+		let zeros = 1;
+		let stop = countNines(min, nines);
+		let stops = new Set([max]);
+		while (min <= stop && stop <= max) {
+			stops.add(stop);
+			nines += 1;
+			stop = countNines(min, nines);
+		}
+		stop = countZeros(max + 1, zeros) - 1;
+		while (min < stop && stop <= max) {
+			stops.add(stop);
+			zeros += 1;
+			stop = countZeros(max + 1, zeros) - 1;
+		}
+		stops = [...stops];
+		stops.sort(compare);
+		return stops;
+	}
+	/**
+	* Convert a range to a regex pattern
+	* @param {Number} `start`
+	* @param {Number} `stop`
+	* @return {String}
+	*/
+	function rangeToPattern(start, stop, options) {
+		if (start === stop) return {
+			pattern: start,
+			count: [],
+			digits: 0
+		};
+		let zipped = zip(start, stop);
+		let digits = zipped.length;
+		let pattern = "";
+		let count = 0;
+		for (let i = 0; i < digits; i++) {
+			let [startDigit, stopDigit] = zipped[i];
+			if (startDigit === stopDigit) pattern += startDigit;
+			else if (startDigit !== "0" || stopDigit !== "9") pattern += toCharacterClass(startDigit, stopDigit, options);
+			else count++;
+		}
+		if (count) pattern += options.shorthand === true ? "\\d" : "[0-9]";
+		return {
+			pattern,
+			count: [count],
+			digits
+		};
+	}
+	function splitToPatterns(min, max, tok, options) {
+		let ranges = splitToRanges(min, max);
+		let tokens = [];
+		let start = min;
+		let prev;
+		for (let i = 0; i < ranges.length; i++) {
+			let max = ranges[i];
+			let obj = rangeToPattern(String(start), String(max), options);
+			let zeros = "";
+			if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+				if (prev.count.length > 1) prev.count.pop();
+				prev.count.push(obj.count[0]);
+				prev.string = prev.pattern + toQuantifier(prev.count);
+				start = max + 1;
+				continue;
+			}
+			if (tok.isPadded) zeros = padZeros(max, tok, options);
+			obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+			tokens.push(obj);
+			start = max + 1;
+			prev = obj;
+		}
+		return tokens;
+	}
+	function filterPatterns(arr, comparison, prefix, intersection, options) {
+		let result = [];
+		for (let ele of arr) {
+			let { string } = ele;
+			if (!intersection && !contains(comparison, "string", string)) result.push(prefix + string);
+			if (intersection && contains(comparison, "string", string)) result.push(prefix + string);
+		}
+		return result;
+	}
+	/**
+	* Zip strings
+	*/
+	function zip(a, b) {
+		let arr = [];
+		for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+		return arr;
+	}
+	function compare(a, b) {
+		return a > b ? 1 : b > a ? -1 : 0;
+	}
+	function contains(arr, key, val) {
+		return arr.some((ele) => ele[key] === val);
+	}
+	function countNines(min, len) {
+		return Number(String(min).slice(0, -len) + "9".repeat(len));
+	}
+	function countZeros(integer, zeros) {
+		return integer - integer % Math.pow(10, zeros);
+	}
+	function toQuantifier(digits) {
+		let [start = 0, stop = ""] = digits;
+		if (stop || start > 1) return `{${start + (stop ? "," + stop : "")}}`;
+		return "";
+	}
+	function toCharacterClass(a, b, options) {
+		return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
+	}
+	function hasPadding(str) {
+		return /^-?(0+)\d/.test(str);
+	}
+	function padZeros(value, tok, options) {
+		if (!tok.isPadded) return value;
+		let diff = Math.abs(tok.maxLen - String(value).length);
+		let relax = options.relaxZeros !== false;
+		switch (diff) {
+			case 0: return "";
+			case 1: return relax ? "0?" : "0";
+			case 2: return relax ? "0{0,2}" : "00";
+			default: return relax ? `0{0,${diff}}` : `0{${diff}}`;
+		}
+	}
+	/**
+	* Cache
+	*/
+	toRegexRange.cache = {};
+	toRegexRange.clearCache = () => toRegexRange.cache = {};
+	/**
+	* Expose `toRegexRange`
+	*/
+	module.exports = toRegexRange;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js
+/*!
+* fill-range <https://github.com/jonschlinkert/fill-range>
+*
+* Copyright (c) 2014-present, Jon Schlinkert.
+* Licensed under the MIT License.
+*/
+var require_fill_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const util = __require("util");
+	const toRegexRange = require_to_regex_range();
+	const isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+	const transform = (toNumber) => {
+		return (value) => toNumber === true ? Number(value) : String(value);
+	};
+	const isValidValue = (value) => {
+		return typeof value === "number" || typeof value === "string" && value !== "";
+	};
+	const isNumber = (num) => Number.isInteger(+num);
+	const zeros = (input) => {
+		let value = `${input}`;
+		let index = -1;
+		if (value[0] === "-") value = value.slice(1);
+		if (value === "0") return false;
+		while (value[++index] === "0");
+		return index > 0;
+	};
+	const stringify = (start, end, options) => {
+		if (typeof start === "string" || typeof end === "string") return true;
+		return options.stringify === true;
+	};
+	const pad = (input, maxLength, toNumber) => {
+		if (maxLength > 0) {
+			let dash = input[0] === "-" ? "-" : "";
+			if (dash) input = input.slice(1);
+			input = dash + input.padStart(dash ? maxLength - 1 : maxLength, "0");
+		}
+		if (toNumber === false) return String(input);
+		return input;
+	};
+	const toMaxLen = (input, maxLength) => {
+		let negative = input[0] === "-" ? "-" : "";
+		if (negative) {
+			input = input.slice(1);
+			maxLength--;
+		}
+		while (input.length < maxLength) input = "0" + input;
+		return negative ? "-" + input : input;
+	};
+	const toSequence = (parts, options, maxLen) => {
+		parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+		parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+		let prefix = options.capture ? "" : "?:";
+		let positives = "";
+		let negatives = "";
+		let result;
+		if (parts.positives.length) positives = parts.positives.map((v) => toMaxLen(String(v), maxLen)).join("|");
+		if (parts.negatives.length) negatives = `-(${prefix}${parts.negatives.map((v) => toMaxLen(String(v), maxLen)).join("|")})`;
+		if (positives && negatives) result = `${positives}|${negatives}`;
+		else result = positives || negatives;
+		if (options.wrap) return `(${prefix}${result})`;
+		return result;
+	};
+	const toRange = (a, b, isNumbers, options) => {
+		if (isNumbers) return toRegexRange(a, b, {
+			wrap: false,
+			...options
+		});
+		let start = String.fromCharCode(a);
+		if (a === b) return start;
+		return `[${start}-${String.fromCharCode(b)}]`;
+	};
+	const toRegex = (start, end, options) => {
+		if (Array.isArray(start)) return options.wrap === true ? `(${options.capture ? "" : "?:"}${start.join("|")})` : start.join("|");
+		return toRegexRange(start, end, options);
+	};
+	const rangeError = (...args) => {
+		return /* @__PURE__ */ new RangeError("Invalid range arguments: " + util.inspect(...args));
+	};
+	const invalidRange = (start, end, options) => {
+		if (options.strictRanges === true) throw rangeError([start, end]);
+		return [];
+	};
+	const invalidStep = (step, options) => {
+		if (options.strictRanges === true) throw new TypeError(`Expected step "${step}" to be a number`);
+		return [];
+	};
+	const fillNumbers = (start, end, step = 1, options = {}) => {
+		let a = Number(start);
+		let b = Number(end);
+		if (!Number.isInteger(a) || !Number.isInteger(b)) {
+			if (options.strictRanges === true) throw rangeError([start, end]);
+			return [];
+		}
+		if (a === 0) a = 0;
+		if (b === 0) b = 0;
+		let descending = a > b;
+		let startString = String(start);
+		let endString = String(end);
+		let stepString = String(step);
+		step = Math.max(Math.abs(step), 1);
+		let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+		let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+		let toNumber = padded === false && stringify(start, end, options) === false;
+		let format = options.transform || transform(toNumber);
+		if (options.toRegex && step === 1) return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+		let parts = {
+			negatives: [],
+			positives: []
+		};
+		let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
+		let range = [];
+		let index = 0;
+		while (descending ? a >= b : a <= b) {
+			if (options.toRegex === true && step > 1) push(a);
+			else range.push(pad(format(a, index), maxLen, toNumber));
+			a = descending ? a - step : a + step;
+			index++;
+		}
+		if (options.toRegex === true) return step > 1 ? toSequence(parts, options, maxLen) : toRegex(range, null, {
+			wrap: false,
+			...options
+		});
+		return range;
+	};
+	const fillLetters = (start, end, step = 1, options = {}) => {
+		if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) return invalidRange(start, end, options);
+		let format = options.transform || ((val) => String.fromCharCode(val));
+		let a = `${start}`.charCodeAt(0);
+		let b = `${end}`.charCodeAt(0);
+		let descending = a > b;
+		let min = Math.min(a, b);
+		let max = Math.max(a, b);
+		if (options.toRegex && step === 1) return toRange(min, max, false, options);
+		let range = [];
+		let index = 0;
+		while (descending ? a >= b : a <= b) {
+			range.push(format(a, index));
+			a = descending ? a - step : a + step;
+			index++;
+		}
+		if (options.toRegex === true) return toRegex(range, null, {
+			wrap: false,
+			options
+		});
+		return range;
+	};
+	const fill = (start, end, step, options = {}) => {
+		if (end == null && isValidValue(start)) return [start];
+		if (!isValidValue(start) || !isValidValue(end)) return invalidRange(start, end, options);
+		if (typeof step === "function") return fill(start, end, 1, { transform: step });
+		if (isObject(step)) return fill(start, end, 0, step);
+		let opts = { ...options };
+		if (opts.capture === true) opts.wrap = true;
+		step = step || opts.step || 1;
+		if (!isNumber(step)) {
+			if (step != null && !isObject(step)) return invalidStep(step, opts);
+			return fill(start, end, 1, step);
+		}
+		if (isNumber(start) && isNumber(end)) return fillNumbers(start, end, step, opts);
+		return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+	};
+	module.exports = fill;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js
+var require_compile = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fill = require_fill_range();
+	const utils = require_utils();
+	const compile = (ast, options = {}) => {
+		const walk = (node, parent = {}) => {
+			const invalid = utils.isInvalidBrace(parent) === true || (node.invalid === true && options.escapeInvalid === true) === true;
+			const prefix = options.escapeInvalid === true ? "\\" : "";
+			let output = "";
+			if (node.isOpen === true) return prefix + node.value;
+			if (node.isClose === true) {
+				console.log("node.isClose", prefix, node.value);
+				return prefix + node.value;
+			}
+			if (node.type === "open") return invalid ? prefix + node.value : "(";
+			if (node.type === "close") return invalid ? prefix + node.value : ")";
+			if (node.type === "comma") return node.prev.type === "comma" ? "" : invalid ? node.value : "|";
+			if (node.value) return node.value;
+			if (node.nodes && node.ranges > 0) {
+				const args = utils.reduce(node.nodes);
+				const range = fill(...args, {
+					...options,
+					wrap: false,
+					toRegex: true,
+					strictZeros: true
+				});
+				if (range.length !== 0) return args.length > 1 && range.length > 1 ? `(${range})` : range;
+			}
+			if (node.nodes) for (const child of node.nodes) output += walk(child, node);
+			return output;
+		};
+		return walk(ast);
+	};
+	module.exports = compile;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js
+var require_expand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fill = require_fill_range();
+	const stringify = require_stringify();
+	const utils = require_utils();
+	const append = (queue = "", stash = "", enclose = false) => {
+		const result = [];
+		queue = [].concat(queue);
+		stash = [].concat(stash);
+		if (!stash.length) return queue;
+		if (!queue.length) return enclose ? utils.flatten(stash).map((ele) => `{${ele}}`) : stash;
+		for (const item of queue) if (Array.isArray(item)) for (const value of item) result.push(append(value, stash, enclose));
+		else for (let ele of stash) {
+			if (enclose === true && typeof ele === "string") ele = `{${ele}}`;
+			result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
+		}
+		return utils.flatten(result);
+	};
+	const expand = (ast, options = {}) => {
+		const rangeLimit = options.rangeLimit === void 0 ? 1e3 : options.rangeLimit;
+		const walk = (node, parent = {}) => {
+			node.queue = [];
+			let p = parent;
+			let q = parent.queue;
+			while (p.type !== "brace" && p.type !== "root" && p.parent) {
+				p = p.parent;
+				q = p.queue;
+			}
+			if (node.invalid || node.dollar) {
+				q.push(append(q.pop(), stringify(node, options)));
+				return;
+			}
+			if (node.type === "brace" && node.invalid !== true && node.nodes.length === 2) {
+				q.push(append(q.pop(), ["{}"]));
+				return;
+			}
+			if (node.nodes && node.ranges > 0) {
+				const args = utils.reduce(node.nodes);
+				if (utils.exceedsLimit(...args, options.step, rangeLimit)) throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
+				let range = fill(...args, options);
+				if (range.length === 0) range = stringify(node, options);
+				q.push(append(q.pop(), range));
+				node.nodes = [];
+				return;
+			}
+			const enclose = utils.encloseBrace(node);
+			let queue = node.queue;
+			let block = node;
+			while (block.type !== "brace" && block.type !== "root" && block.parent) {
+				block = block.parent;
+				queue = block.queue;
+			}
+			for (let i = 0; i < node.nodes.length; i++) {
+				const child = node.nodes[i];
+				if (child.type === "comma" && node.type === "brace") {
+					if (i === 1) queue.push("");
+					queue.push("");
+					continue;
+				}
+				if (child.type === "close") {
+					q.push(append(q.pop(), queue, enclose));
+					continue;
+				}
+				if (child.value && child.type !== "open") {
+					queue.push(append(queue.pop(), child.value));
+					continue;
+				}
+				if (child.nodes) walk(child, node);
+			}
+			return queue;
+		};
+		return utils.flatten(walk(ast));
+	};
+	module.exports = expand;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js
+var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		MAX_LENGTH: 1e4,
+		CHAR_0: "0",
+		CHAR_9: "9",
+		CHAR_UPPERCASE_A: "A",
+		CHAR_LOWERCASE_A: "a",
+		CHAR_UPPERCASE_Z: "Z",
+		CHAR_LOWERCASE_Z: "z",
+		CHAR_LEFT_PARENTHESES: "(",
+		CHAR_RIGHT_PARENTHESES: ")",
+		CHAR_ASTERISK: "*",
+		CHAR_AMPERSAND: "&",
+		CHAR_AT: "@",
+		CHAR_BACKSLASH: "\\",
+		CHAR_BACKTICK: "`",
+		CHAR_CARRIAGE_RETURN: "\r",
+		CHAR_CIRCUMFLEX_ACCENT: "^",
+		CHAR_COLON: ":",
+		CHAR_COMMA: ",",
+		CHAR_DOLLAR: "$",
+		CHAR_DOT: ".",
+		CHAR_DOUBLE_QUOTE: "\"",
+		CHAR_EQUAL: "=",
+		CHAR_EXCLAMATION_MARK: "!",
+		CHAR_FORM_FEED: "\f",
+		CHAR_FORWARD_SLASH: "/",
+		CHAR_HASH: "#",
+		CHAR_HYPHEN_MINUS: "-",
+		CHAR_LEFT_ANGLE_BRACKET: "<",
+		CHAR_LEFT_CURLY_BRACE: "{",
+		CHAR_LEFT_SQUARE_BRACKET: "[",
+		CHAR_LINE_FEED: "\n",
+		CHAR_NO_BREAK_SPACE: "\xA0",
+		CHAR_PERCENT: "%",
+		CHAR_PLUS: "+",
+		CHAR_QUESTION_MARK: "?",
+		CHAR_RIGHT_ANGLE_BRACKET: ">",
+		CHAR_RIGHT_CURLY_BRACE: "}",
+		CHAR_RIGHT_SQUARE_BRACKET: "]",
+		CHAR_SEMICOLON: ";",
+		CHAR_SINGLE_QUOTE: "'",
+		CHAR_SPACE: " ",
+		CHAR_TAB: "	",
+		CHAR_UNDERSCORE: "_",
+		CHAR_VERTICAL_LINE: "|",
+		CHAR_ZERO_WIDTH_NOBREAK_SPACE: ""
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js
+var require_parse$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const stringify = require_stringify();
+	/**
+	* Constants
+	*/
+	const { MAX_LENGTH, CHAR_BACKSLASH, CHAR_BACKTICK, CHAR_COMMA, CHAR_DOT, CHAR_LEFT_PARENTHESES, CHAR_RIGHT_PARENTHESES, CHAR_LEFT_CURLY_BRACE, CHAR_RIGHT_CURLY_BRACE, CHAR_LEFT_SQUARE_BRACKET, CHAR_RIGHT_SQUARE_BRACKET, CHAR_DOUBLE_QUOTE, CHAR_SINGLE_QUOTE, CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = require_constants$2();
+	/**
+	* parse
+	*/
+	const parse = (input, options = {}) => {
+		if (typeof input !== "string") throw new TypeError("Expected a string");
+		const opts = options || {};
+		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+		if (input.length > max) throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+		const ast = {
+			type: "root",
+			input,
+			nodes: []
+		};
+		const stack = [ast];
+		let block = ast;
+		let prev = ast;
+		let brackets = 0;
+		const length = input.length;
+		let index = 0;
+		let depth = 0;
+		let value;
+		/**
+		* Helpers
+		*/
+		const advance = () => input[index++];
+		const push = (node) => {
+			if (node.type === "text" && prev.type === "dot") prev.type = "text";
+			if (prev && prev.type === "text" && node.type === "text") {
+				prev.value += node.value;
+				return;
+			}
+			block.nodes.push(node);
+			node.parent = block;
+			node.prev = prev;
+			prev = node;
+			return node;
+		};
+		push({ type: "bos" });
+		while (index < length) {
+			block = stack[stack.length - 1];
+			value = advance();
+			/**
+			* Invalid chars
+			*/
+			if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) continue;
+			/**
+			* Escaped chars
+			*/
+			if (value === CHAR_BACKSLASH) {
+				push({
+					type: "text",
+					value: (options.keepEscaping ? value : "") + advance()
+				});
+				continue;
+			}
+			/**
+			* Right square bracket (literal): ']'
+			*/
+			if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+				push({
+					type: "text",
+					value: "\\" + value
+				});
+				continue;
+			}
+			/**
+			* Left square bracket: '['
+			*/
+			if (value === CHAR_LEFT_SQUARE_BRACKET) {
+				brackets++;
+				let next;
+				while (index < length && (next = advance())) {
+					value += next;
+					if (next === CHAR_LEFT_SQUARE_BRACKET) {
+						brackets++;
+						continue;
+					}
+					if (next === CHAR_BACKSLASH) {
+						value += advance();
+						continue;
+					}
+					if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+						brackets--;
+						if (brackets === 0) break;
+					}
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Parentheses
+			*/
+			if (value === CHAR_LEFT_PARENTHESES) {
+				block = push({
+					type: "paren",
+					nodes: []
+				});
+				stack.push(block);
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			if (value === CHAR_RIGHT_PARENTHESES) {
+				if (block.type !== "paren") {
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+				block = stack.pop();
+				push({
+					type: "text",
+					value
+				});
+				block = stack[stack.length - 1];
+				continue;
+			}
+			/**
+			* Quotes: '|"|`
+			*/
+			if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+				const open = value;
+				let next;
+				if (options.keepQuotes !== true) value = "";
+				while (index < length && (next = advance())) {
+					if (next === CHAR_BACKSLASH) {
+						value += next + advance();
+						continue;
+					}
+					if (next === open) {
+						if (options.keepQuotes === true) value += next;
+						break;
+					}
+					value += next;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Left curly brace: '{'
+			*/
+			if (value === CHAR_LEFT_CURLY_BRACE) {
+				depth++;
+				block = push({
+					type: "brace",
+					open: true,
+					close: false,
+					dollar: prev.value && prev.value.slice(-1) === "$" || block.dollar === true,
+					depth,
+					commas: 0,
+					ranges: 0,
+					nodes: []
+				});
+				stack.push(block);
+				push({
+					type: "open",
+					value
+				});
+				continue;
+			}
+			/**
+			* Right curly brace: '}'
+			*/
+			if (value === CHAR_RIGHT_CURLY_BRACE) {
+				if (block.type !== "brace") {
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+				const type = "close";
+				block = stack.pop();
+				block.close = true;
+				push({
+					type,
+					value
+				});
+				depth--;
+				block = stack[stack.length - 1];
+				continue;
+			}
+			/**
+			* Comma: ','
+			*/
+			if (value === CHAR_COMMA && depth > 0) {
+				if (block.ranges > 0) {
+					block.ranges = 0;
+					const open = block.nodes.shift();
+					block.nodes = [open, {
+						type: "text",
+						value: stringify(block)
+					}];
+				}
+				push({
+					type: "comma",
+					value
+				});
+				block.commas++;
+				continue;
+			}
+			/**
+			* Dot: '.'
+			*/
+			if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+				const siblings = block.nodes;
+				if (depth === 0 || siblings.length === 0) {
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+				if (prev.type === "dot") {
+					block.range = [];
+					prev.value += value;
+					prev.type = "range";
+					if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+						block.invalid = true;
+						block.ranges = 0;
+						prev.type = "text";
+						continue;
+					}
+					block.ranges++;
+					block.args = [];
+					continue;
+				}
+				if (prev.type === "range") {
+					siblings.pop();
+					const before = siblings[siblings.length - 1];
+					before.value += prev.value + value;
+					prev = before;
+					block.ranges--;
+					continue;
+				}
+				push({
+					type: "dot",
+					value
+				});
+				continue;
+			}
+			/**
+			* Text
+			*/
+			push({
+				type: "text",
+				value
+			});
+		}
+		do {
+			block = stack.pop();
+			if (block.type !== "root") {
+				block.nodes.forEach((node) => {
+					if (!node.nodes) {
+						if (node.type === "open") node.isOpen = true;
+						if (node.type === "close") node.isClose = true;
+						if (!node.nodes) node.type = "text";
+						node.invalid = true;
+					}
+				});
+				const parent = stack[stack.length - 1];
+				const index = parent.nodes.indexOf(block);
+				parent.nodes.splice(index, 1, ...block.nodes);
+			}
+		} while (stack.length > 0);
+		push({ type: "eos" });
+		return ast;
+	};
+	module.exports = parse;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js
+var require_braces = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const stringify = require_stringify();
+	const compile = require_compile();
+	const expand = require_expand();
+	const parse = require_parse$2();
+	/**
+	* Expand the given pattern or create a regex-compatible string.
+	*
+	* ```js
+	* const braces = require('braces');
+	* console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+	* console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+	* ```
+	* @param {String} `str`
+	* @param {Object} `options`
+	* @return {String}
+	* @api public
+	*/
+	const braces = (input, options = {}) => {
+		let output = [];
+		if (Array.isArray(input)) for (const pattern of input) {
+			const result = braces.create(pattern, options);
+			if (Array.isArray(result)) output.push(...result);
+			else output.push(result);
+		}
+		else output = [].concat(braces.create(input, options));
+		if (options && options.expand === true && options.nodupes === true) output = [...new Set(output)];
+		return output;
+	};
+	/**
+	* Parse the given `str` with the given `options`.
+	*
+	* ```js
+	* // braces.parse(pattern, [, options]);
+	* const ast = braces.parse('a/{b,c}/d');
+	* console.log(ast);
+	* ```
+	* @param {String} pattern Brace pattern to parse
+	* @param {Object} options
+	* @return {Object} Returns an AST
+	* @api public
+	*/
+	braces.parse = (input, options = {}) => parse(input, options);
+	/**
+	* Creates a braces string from an AST, or an AST node.
+	*
+	* ```js
+	* const braces = require('braces');
+	* let ast = braces.parse('foo/{a,b}/bar');
+	* console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+	* ```
+	* @param {String} `input` Brace pattern or AST.
+	* @param {Object} `options`
+	* @return {Array} Returns an array of expanded values.
+	* @api public
+	*/
+	braces.stringify = (input, options = {}) => {
+		if (typeof input === "string") return stringify(braces.parse(input, options), options);
+		return stringify(input, options);
+	};
+	/**
+	* Compiles a brace pattern into a regex-compatible, optimized string.
+	* This method is called by the main [braces](#braces) function by default.
+	*
+	* ```js
+	* const braces = require('braces');
+	* console.log(braces.compile('a/{b,c}/d'));
+	* //=> ['a/(b|c)/d']
+	* ```
+	* @param {String} `input` Brace pattern or AST.
+	* @param {Object} `options`
+	* @return {Array} Returns an array of expanded values.
+	* @api public
+	*/
+	braces.compile = (input, options = {}) => {
+		if (typeof input === "string") input = braces.parse(input, options);
+		return compile(input, options);
+	};
+	/**
+	* Expands a brace pattern into an array. This method is called by the
+	* main [braces](#braces) function when `options.expand` is true. Before
+	* using this method it's recommended that you read the [performance notes](#performance))
+	* and advantages of using [.compile](#compile) instead.
+	*
+	* ```js
+	* const braces = require('braces');
+	* console.log(braces.expand('a/{b,c}/d'));
+	* //=> ['a/b/d', 'a/c/d'];
+	* ```
+	* @param {String} `pattern` Brace pattern
+	* @param {Object} `options`
+	* @return {Array} Returns an array of expanded values.
+	* @api public
+	*/
+	braces.expand = (input, options = {}) => {
+		if (typeof input === "string") input = braces.parse(input, options);
+		let result = expand(input, options);
+		if (options.noempty === true) result = result.filter(Boolean);
+		if (options.nodupes === true) result = [...new Set(result)];
+		return result;
+	};
+	/**
+	* Processes a brace pattern and returns either an expanded array
+	* (if `options.expand` is true), a highly optimized regex-compatible string.
+	* This method is called by the main [braces](#braces) function.
+	*
+	* ```js
+	* const braces = require('braces');
+	* console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+	* //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+	* ```
+	* @param {String} `pattern` Brace pattern
+	* @param {Object} `options`
+	* @return {Array} Returns an array of expanded values.
+	* @api public
+	*/
+	braces.create = (input, options = {}) => {
+		if (input === "" || input.length < 3) return [input];
+		return options.expand !== true ? braces.compile(input, options) : braces.expand(input, options);
+	};
+	/**
+	* Expose "braces"
+	*/
+	module.exports = braces;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/binary-extensions@2.3.0/node_modules/binary-extensions/binary-extensions.json
+var require_binary_extensions$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = [
+		"3dm",
+		"3ds",
+		"3g2",
+		"3gp",
+		"7z",
+		"a",
+		"aac",
+		"adp",
+		"afdesign",
+		"afphoto",
+		"afpub",
+		"ai",
+		"aif",
+		"aiff",
+		"alz",
+		"ape",
+		"apk",
+		"appimage",
+		"ar",
+		"arj",
+		"asf",
+		"au",
+		"avi",
+		"bak",
+		"baml",
+		"bh",
+		"bin",
+		"bk",
+		"bmp",
+		"btif",
+		"bz2",
+		"bzip2",
+		"cab",
+		"caf",
+		"cgm",
+		"class",
+		"cmx",
+		"cpio",
+		"cr2",
+		"cur",
+		"dat",
+		"dcm",
+		"deb",
+		"dex",
+		"djvu",
+		"dll",
+		"dmg",
+		"dng",
+		"doc",
+		"docm",
+		"docx",
+		"dot",
+		"dotm",
+		"dra",
+		"DS_Store",
+		"dsk",
+		"dts",
+		"dtshd",
+		"dvb",
+		"dwg",
+		"dxf",
+		"ecelp4800",
+		"ecelp7470",
+		"ecelp9600",
+		"egg",
+		"eol",
+		"eot",
+		"epub",
+		"exe",
+		"f4v",
+		"fbs",
+		"fh",
+		"fla",
+		"flac",
+		"flatpak",
+		"fli",
+		"flv",
+		"fpx",
+		"fst",
+		"fvt",
+		"g3",
+		"gh",
+		"gif",
+		"graffle",
+		"gz",
+		"gzip",
+		"h261",
+		"h263",
+		"h264",
+		"icns",
+		"ico",
+		"ief",
+		"img",
+		"ipa",
+		"iso",
+		"jar",
+		"jpeg",
+		"jpg",
+		"jpgv",
+		"jpm",
+		"jxr",
+		"key",
+		"ktx",
+		"lha",
+		"lib",
+		"lvp",
+		"lz",
+		"lzh",
+		"lzma",
+		"lzo",
+		"m3u",
+		"m4a",
+		"m4v",
+		"mar",
+		"mdi",
+		"mht",
+		"mid",
+		"midi",
+		"mj2",
+		"mka",
+		"mkv",
+		"mmr",
+		"mng",
+		"mobi",
+		"mov",
+		"movie",
+		"mp3",
+		"mp4",
+		"mp4a",
+		"mpeg",
+		"mpg",
+		"mpga",
+		"mxu",
+		"nef",
+		"npx",
+		"numbers",
+		"nupkg",
+		"o",
+		"odp",
+		"ods",
+		"odt",
+		"oga",
+		"ogg",
+		"ogv",
+		"otf",
+		"ott",
+		"pages",
+		"pbm",
+		"pcx",
+		"pdb",
+		"pdf",
+		"pea",
+		"pgm",
+		"pic",
+		"png",
+		"pnm",
+		"pot",
+		"potm",
+		"potx",
+		"ppa",
+		"ppam",
+		"ppm",
+		"pps",
+		"ppsm",
+		"ppsx",
+		"ppt",
+		"pptm",
+		"pptx",
+		"psd",
+		"pya",
+		"pyc",
+		"pyo",
+		"pyv",
+		"qt",
+		"rar",
+		"ras",
+		"raw",
+		"resources",
+		"rgb",
+		"rip",
+		"rlc",
+		"rmf",
+		"rmvb",
+		"rpm",
+		"rtf",
+		"rz",
+		"s3m",
+		"s7z",
+		"scpt",
+		"sgi",
+		"shar",
+		"snap",
+		"sil",
+		"sketch",
+		"slk",
+		"smv",
+		"snk",
+		"so",
+		"stl",
+		"suo",
+		"sub",
+		"swf",
+		"tar",
+		"tbz",
+		"tbz2",
+		"tga",
+		"tgz",
+		"thmx",
+		"tif",
+		"tiff",
+		"tlz",
+		"ttc",
+		"ttf",
+		"txz",
+		"udf",
+		"uvh",
+		"uvi",
+		"uvm",
+		"uvp",
+		"uvs",
+		"uvu",
+		"viv",
+		"vob",
+		"war",
+		"wav",
+		"wax",
+		"wbmp",
+		"wdp",
+		"weba",
+		"webm",
+		"webp",
+		"whl",
+		"wim",
+		"wm",
+		"wma",
+		"wmv",
+		"wmx",
+		"woff",
+		"woff2",
+		"wrm",
+		"wvx",
+		"xbm",
+		"xif",
+		"xla",
+		"xlam",
+		"xls",
+		"xlsb",
+		"xlsm",
+		"xlsx",
+		"xlt",
+		"xltm",
+		"xltx",
+		"xm",
+		"xmind",
+		"xpi",
+		"xpm",
+		"xwd",
+		"xz",
+		"z",
+		"zip",
+		"zipx"
+	];
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/binary-extensions@2.3.0/node_modules/binary-extensions/index.js
+var require_binary_extensions = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_binary_extensions$1();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/is-binary-path@2.1.0/node_modules/is-binary-path/index.js
+var require_is_binary_path = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$10 = __require("path");
+	const binaryExtensions = require_binary_extensions();
+	const extensions = new Set(binaryExtensions);
+	module.exports = (filePath) => extensions.has(path$10.extname(filePath).slice(1).toLowerCase());
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/chokidar@3.6.0_patch_hash=8a4f9e2b397e6034b91a0508faae3cecb97f222313faa129d7cb0eb71e9d0e84/node_modules/chokidar/lib/constants.js
+var require_constants$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const { sep: sep$1 } = __require("path");
+	const { platform } = process;
+	const os$3 = __require("os");
+	exports.EV_ALL = "all";
+	exports.EV_READY = "ready";
+	exports.EV_ADD = "add";
+	exports.EV_CHANGE = "change";
+	exports.EV_ADD_DIR = "addDir";
+	exports.EV_UNLINK = "unlink";
+	exports.EV_UNLINK_DIR = "unlinkDir";
+	exports.EV_RAW = "raw";
+	exports.EV_ERROR = "error";
+	exports.STR_DATA = "data";
+	exports.STR_END = "end";
+	exports.STR_CLOSE = "close";
+	exports.FSEVENT_CREATED = "created";
+	exports.FSEVENT_MODIFIED = "modified";
+	exports.FSEVENT_DELETED = "deleted";
+	exports.FSEVENT_MOVED = "moved";
+	exports.FSEVENT_CLONED = "cloned";
+	exports.FSEVENT_UNKNOWN = "unknown";
+	exports.FSEVENT_FLAG_MUST_SCAN_SUBDIRS = 1;
+	exports.FSEVENT_TYPE_FILE = "file";
+	exports.FSEVENT_TYPE_DIRECTORY = "directory";
+	exports.FSEVENT_TYPE_SYMLINK = "symlink";
+	exports.KEY_LISTENERS = "listeners";
+	exports.KEY_ERR = "errHandlers";
+	exports.KEY_RAW = "rawEmitters";
+	exports.HANDLER_KEYS = [
+		exports.KEY_LISTENERS,
+		exports.KEY_ERR,
+		exports.KEY_RAW
+	];
+	exports.DOT_SLASH = `.${sep$1}`;
+	exports.BACK_SLASH_RE = /\\/g;
+	exports.DOUBLE_SLASH_RE = /\/\//;
+	exports.SLASH_OR_BACK_SLASH_RE = /[/\\]/;
+	exports.DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+	exports.REPLACER_RE = /^\.[/\\]/;
+	exports.SLASH = "/";
+	exports.SLASH_SLASH = "//";
+	exports.BRACE_START = "{";
+	exports.BANG = "!";
+	exports.ONE_DOT = ".";
+	exports.TWO_DOTS = "..";
+	exports.STAR = "*";
+	exports.GLOBSTAR = "**";
+	exports.ROOT_GLOBSTAR = "/**/*";
+	exports.SLASH_GLOBSTAR = "/**";
+	exports.DIR_SUFFIX = "Dir";
+	exports.ANYMATCH_OPTS = { dot: true };
+	exports.STRING_TYPE = "string";
+	exports.FUNCTION_TYPE = "function";
+	exports.EMPTY_STR = "";
+	exports.EMPTY_FN = () => {};
+	exports.IDENTITY_FN = (val) => val;
+	exports.isWindows = platform === "win32";
+	exports.isMacos = platform === "darwin";
+	exports.isLinux = platform === "linux";
+	exports.isIBMi = os$3.type() === "OS400";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/chokidar@3.6.0_patch_hash=8a4f9e2b397e6034b91a0508faae3cecb97f222313faa129d7cb0eb71e9d0e84/node_modules/chokidar/lib/nodefs-handler.js
+var require_nodefs_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$9 = __require("fs");
+	const sysPath$2 = __require("path");
+	const { promisify: promisify$3 } = __require("util");
+	const isBinaryPath = require_is_binary_path();
+	const { isWindows, isLinux, EMPTY_FN, EMPTY_STR, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, EV_CHANGE, EV_ADD, EV_ADD_DIR, EV_ERROR, STR_DATA, STR_END, BRACE_START, STAR } = require_constants$1();
+	const THROTTLE_MODE_WATCH = "watch";
+	const open = promisify$3(fs$9.open);
+	const stat = promisify$3(fs$9.stat);
+	const lstat = promisify$3(fs$9.lstat);
+	const close = promisify$3(fs$9.close);
+	const fsrealpath = promisify$3(fs$9.realpath);
+	const statMethods = {
+		lstat,
+		stat
+	};
+	const foreach = (val, fn) => {
+		if (val instanceof Set) val.forEach(fn);
+		else fn(val);
+	};
+	const addAndConvert = (main, prop, item) => {
+		let container = main[prop];
+		if (!(container instanceof Set)) main[prop] = container = new Set([container]);
+		container.add(item);
+	};
+	const clearItem = (cont) => (key) => {
+		const set = cont[key];
+		if (set instanceof Set) set.clear();
+		else delete cont[key];
+	};
+	const delFromSet = (main, prop, item) => {
+		const container = main[prop];
+		if (container instanceof Set) container.delete(item);
+		else if (container === item) delete main[prop];
+	};
+	const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+	/**
+	* @typedef {String} Path
+	*/
+	/**
+	* @typedef {Object} FsWatchContainer
+	* @property {Set} listeners
+	* @property {Set} errHandlers
+	* @property {Set} rawEmitters
+	* @property {fs.FSWatcher=} watcher
+	* @property {Boolean=} watcherUnusable
+	*/
+	/**
+	* @type {Map<String,FsWatchContainer>}
+	*/
+	const FsWatchInstances = /* @__PURE__ */ new Map();
+	/**
+	* Instantiates the fs_watch interface
+	* @param {String} path to be watched
+	* @param {Object} options to be passed to fs_watch
+	* @param {Function} listener main event handler
+	* @param {Function} errHandler emits info about errors
+	* @param {Function} emitRaw emits raw event data
+	* @returns {fs.FSWatcher} new fsevents instance
+	*/
+	function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+		const handleEvent = (rawEvent, evPath) => {
+			listener(path);
+			emitRaw(rawEvent, evPath, { watchedPath: path });
+			if (evPath && path !== evPath) fsWatchBroadcast(sysPath$2.resolve(path, evPath), KEY_LISTENERS, sysPath$2.join(path, evPath));
+		};
+		try {
+			return fs$9.watch(path, options, handleEvent);
+		} catch (error) {
+			errHandler(error);
+		}
+	}
+	/**
+	* Helper for passing fs_watch event data to a collection of listeners
+	* @param {Path} fullPath absolute path bound to fs_watch instance
+	* @param {String} type listener type
+	* @param {*=} val1 arguments to be passed to listeners
+	* @param {*=} val2
+	* @param {*=} val3
+	*/
+	const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
+		const cont = FsWatchInstances.get(fullPath);
+		if (!cont) return;
+		foreach(cont[type], (listener) => {
+			listener(val1, val2, val3);
+		});
+	};
+	/**
+	* Instantiates the fs_watch interface or binds listeners
+	* to an existing one covering the same file system entry
+	* @param {String} path
+	* @param {String} fullPath absolute path
+	* @param {Object} options to be passed to fs_watch
+	* @param {Object} handlers container for event listener functions
+	*/
+	const setFsWatchListener = (path, fullPath, options, handlers) => {
+		const { listener, errHandler, rawEmitter } = handlers;
+		let cont = FsWatchInstances.get(fullPath);
+		/** @type {fs.FSWatcher=} */
+		let watcher;
+		if (!options.persistent) {
+			watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+			return watcher.close.bind(watcher);
+		}
+		if (cont) {
+			addAndConvert(cont, KEY_LISTENERS, listener);
+			addAndConvert(cont, KEY_ERR, errHandler);
+			addAndConvert(cont, KEY_RAW, rawEmitter);
+		} else {
+			watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+			if (!watcher) return;
+			watcher.on(EV_ERROR, async (error) => {
+				const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+				cont.watcherUnusable = true;
+				if (isWindows && error.code === "EPERM") try {
+					await close(await open(path, "r"));
+					broadcastErr(error);
+				} catch (err) {}
+				else broadcastErr(error);
+			});
+			cont = {
+				listeners: listener,
+				errHandlers: errHandler,
+				rawEmitters: rawEmitter,
+				watcher
+			};
+			FsWatchInstances.set(fullPath, cont);
+		}
+		return () => {
+			delFromSet(cont, KEY_LISTENERS, listener);
+			delFromSet(cont, KEY_ERR, errHandler);
+			delFromSet(cont, KEY_RAW, rawEmitter);
+			if (isEmptySet(cont.listeners)) {
+				cont.watcher.close();
+				FsWatchInstances.delete(fullPath);
+				HANDLER_KEYS.forEach(clearItem(cont));
+				cont.watcher = void 0;
+				Object.freeze(cont);
+			}
+		};
+	};
+	const FsWatchFileInstances = /* @__PURE__ */ new Map();
+	/**
+	* Instantiates the fs_watchFile interface or binds listeners
+	* to an existing one covering the same file system entry
+	* @param {String} path to be watched
+	* @param {String} fullPath absolute path
+	* @param {Object} options options to be passed to fs_watchFile
+	* @param {Object} handlers container for event listener functions
+	* @returns {Function} closer
+	*/
+	const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+		const { listener, rawEmitter } = handlers;
+		let cont = FsWatchFileInstances.get(fullPath);
+		const copts = cont && cont.options;
+		if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+			fs$9.unwatchFile(fullPath);
+			cont = void 0;
+		}
+		if (cont) {
+			addAndConvert(cont, KEY_LISTENERS, listener);
+			addAndConvert(cont, KEY_RAW, rawEmitter);
+		} else {
+			cont = {
+				listeners: listener,
+				rawEmitters: rawEmitter,
+				options,
+				watcher: fs$9.watchFile(fullPath, options, (curr, prev) => {
+					foreach(cont.rawEmitters, (rawEmitter) => {
+						rawEmitter(EV_CHANGE, fullPath, {
+							curr,
+							prev
+						});
+					});
+					const currmtime = curr.mtimeMs;
+					if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener) => listener(path, curr));
+				})
+			};
+			FsWatchFileInstances.set(fullPath, cont);
+		}
+		return () => {
+			delFromSet(cont, KEY_LISTENERS, listener);
+			delFromSet(cont, KEY_RAW, rawEmitter);
+			if (isEmptySet(cont.listeners)) {
+				FsWatchFileInstances.delete(fullPath);
+				fs$9.unwatchFile(fullPath);
+				cont.options = cont.watcher = void 0;
+				Object.freeze(cont);
+			}
+		};
+	};
+	/**
+	* @mixin
+	*/
+	var NodeFsHandler = class {
+		/**
+		* @param {import("../index").FSWatcher} fsW
+		*/
+		constructor(fsW) {
+			this.fsw = fsW;
+			this._boundHandleError = (error) => fsW._handleError(error);
+		}
+		/**
+		* Watch file for changes with fs_watchFile or fs_watch.
+		* @param {String} path to file or dir
+		* @param {Function} listener on fs change
+		* @returns {Function} closer for the watcher instance
+		*/
+		_watchWithNodeFs(path, listener) {
+			const opts = this.fsw.options;
+			const directory = sysPath$2.dirname(path);
+			const basename = sysPath$2.basename(path);
+			this.fsw._getWatchedDir(directory).add(basename);
+			const absolutePath = sysPath$2.resolve(path);
+			const options = { persistent: opts.persistent };
+			if (!listener) listener = EMPTY_FN;
+			let closer;
+			if (opts.usePolling) {
+				options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+				closer = setFsWatchFileListener(path, absolutePath, options, {
+					listener,
+					rawEmitter: this.fsw._emitRaw
+				});
+			} else closer = setFsWatchListener(path, absolutePath, options, {
+				listener,
+				errHandler: this._boundHandleError,
+				rawEmitter: this.fsw._emitRaw
+			});
+			return closer;
+		}
+		/**
+		* Watch a file and emit add event if warranted.
+		* @param {Path} file Path
+		* @param {fs.Stats} stats result of fs_stat
+		* @param {Boolean} initialAdd was the file added at watch instantiation?
+		* @returns {Function} closer for the watcher instance
+		*/
+		_handleFile(file, stats, initialAdd) {
+			if (this.fsw.closed) return;
+			const dirname = sysPath$2.dirname(file);
+			const basename = sysPath$2.basename(file);
+			const parent = this.fsw._getWatchedDir(dirname);
+			let prevStats = stats;
+			if (parent.has(basename)) return;
+			const listener = async (path, newStats) => {
+				if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+				if (!newStats || newStats.mtimeMs === 0) try {
+					const newStats = await stat(file);
+					if (this.fsw.closed) return;
+					const at = newStats.atimeMs;
+					const mt = newStats.mtimeMs;
+					if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV_CHANGE, file, newStats);
+					if (isLinux && prevStats.ino !== newStats.ino) {
+						this.fsw._closeFile(path);
+						prevStats = newStats;
+						this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
+					} else prevStats = newStats;
+				} catch (error) {
+					this.fsw._remove(dirname, basename);
+				}
+				else if (parent.has(basename)) {
+					const at = newStats.atimeMs;
+					const mt = newStats.mtimeMs;
+					if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV_CHANGE, file, newStats);
+					prevStats = newStats;
+				}
+			};
+			const closer = this._watchWithNodeFs(file, listener);
+			if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+				if (!this.fsw._throttle(EV_ADD, file, 0)) return;
+				this.fsw._emit(EV_ADD, file, stats);
+			}
+			return closer;
+		}
+		/**
+		* Handle symlinks encountered while reading a dir.
+		* @param {Object} entry returned by readdirp
+		* @param {String} directory path of dir being read
+		* @param {String} path of this item
+		* @param {String} item basename of this item
+		* @returns {Promise<Boolean>} true if no more processing is needed for this entry.
+		*/
+		async _handleSymlink(entry, directory, path, item) {
+			if (this.fsw.closed) return;
+			const full = entry.fullPath;
+			const dir = this.fsw._getWatchedDir(directory);
+			if (!this.fsw.options.followSymlinks) {
+				this.fsw._incrReadyCount();
+				let linkPath;
+				try {
+					linkPath = await fsrealpath(path);
+				} catch (e) {
+					this.fsw._emitReady();
+					return true;
+				}
+				if (this.fsw.closed) return;
+				if (dir.has(item)) {
+					if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+						this.fsw._symlinkPaths.set(full, linkPath);
+						this.fsw._emit(EV_CHANGE, path, entry.stats);
+					}
+				} else {
+					dir.add(item);
+					this.fsw._symlinkPaths.set(full, linkPath);
+					this.fsw._emit(EV_ADD, path, entry.stats);
+				}
+				this.fsw._emitReady();
+				return true;
+			}
+			if (this.fsw._symlinkPaths.has(full)) return true;
+			this.fsw._symlinkPaths.set(full, true);
+		}
+		_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+			directory = sysPath$2.join(directory, EMPTY_STR);
+			if (!wh.hasGlob) {
+				throttler = this.fsw._throttle("readdir", directory, 1e3);
+				if (!throttler) return;
+			}
+			const previous = this.fsw._getWatchedDir(wh.path);
+			const current = /* @__PURE__ */ new Set();
+			let stream = this.fsw._readdirp(directory, {
+				fileFilter: (entry) => wh.filterPath(entry),
+				directoryFilter: (entry) => wh.filterDir(entry),
+				depth: 0
+			}).on(STR_DATA, async (entry) => {
+				if (this.fsw.closed) {
+					stream = void 0;
+					return;
+				}
+				const item = entry.path;
+				let path = sysPath$2.join(directory, item);
+				current.add(item);
+				if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) return;
+				if (this.fsw.closed) {
+					stream = void 0;
+					return;
+				}
+				if (item === target || !target && !previous.has(item)) {
+					this.fsw._incrReadyCount();
+					path = sysPath$2.join(dir, sysPath$2.relative(dir, path));
+					this._addToNodeFs(path, initialAdd, wh, depth + 1);
+				}
+			}).on(EV_ERROR, this._boundHandleError);
+			return new Promise((resolve) => stream.once(STR_END, () => {
+				if (this.fsw.closed) {
+					stream = void 0;
+					return;
+				}
+				const wasThrottled = throttler ? throttler.clear() : false;
+				resolve();
+				previous.getChildren().filter((item) => {
+					return item !== directory && !current.has(item) && (!wh.hasGlob || wh.filterPath({ fullPath: sysPath$2.resolve(directory, item) }));
+				}).forEach((item) => {
+					this.fsw._remove(directory, item);
+				});
+				stream = void 0;
+				if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+			}));
+		}
+		/**
+		* Read directory to add / remove files from `@watched` list and re-read it on change.
+		* @param {String} dir fs path
+		* @param {fs.Stats} stats
+		* @param {Boolean} initialAdd
+		* @param {Number} depth relative to user-supplied path
+		* @param {String} target child path targeted for watch
+		* @param {Object} wh Common watch helpers for this path
+		* @param {String} realpath
+		* @returns {Promise<Function>} closer for the watcher instance.
+		*/
+		async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+			const parentDir = this.fsw._getWatchedDir(sysPath$2.dirname(dir));
+			const tracked = parentDir.has(sysPath$2.basename(dir));
+			if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+				if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
+			}
+			parentDir.add(sysPath$2.basename(dir));
+			this.fsw._getWatchedDir(dir);
+			let throttler;
+			let closer;
+			const oDepth = this.fsw.options.depth;
+			if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+				if (!target) {
+					await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+					if (this.fsw.closed) return;
+				}
+				closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+					if (stats && stats.mtimeMs === 0) return;
+					this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+				});
+			}
+			return closer;
+		}
+		/**
+		* Handle added file, directory, or glob pattern.
+		* Delegates call to _handleFile / _handleDir after checks.
+		* @param {String} path to file or ir
+		* @param {Boolean} initialAdd was the file added at watch instantiation?
+		* @param {Object} priorWh depth relative to user-supplied path
+		* @param {Number} depth Child path actually targeted for watch
+		* @param {String=} target Child path actually targeted for watch
+		* @returns {Promise}
+		*/
+		async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+			const ready = this.fsw._emitReady;
+			if (this.fsw._isIgnored(path) || this.fsw.closed) {
+				ready();
+				return false;
+			}
+			const wh = this.fsw._getWatchHelpers(path, depth);
+			if (!wh.hasGlob && priorWh) {
+				wh.hasGlob = priorWh.hasGlob;
+				wh.globFilter = priorWh.globFilter;
+				wh.filterPath = (entry) => priorWh.filterPath(entry);
+				wh.filterDir = (entry) => priorWh.filterDir(entry);
+			}
+			try {
+				const stats = await statMethods[wh.statMethod](wh.watchPath);
+				if (this.fsw.closed) return;
+				if (this.fsw._isIgnored(wh.watchPath, stats)) {
+					ready();
+					return false;
+				}
+				const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START);
+				let closer;
+				if (stats.isDirectory()) {
+					const absPath = sysPath$2.resolve(path);
+					const targetPath = follow ? await fsrealpath(path) : path;
+					if (this.fsw.closed) return;
+					closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+					if (this.fsw.closed) return;
+					if (absPath !== targetPath && targetPath !== void 0) this.fsw._symlinkPaths.set(absPath, targetPath);
+				} else if (stats.isSymbolicLink()) {
+					const targetPath = follow ? await fsrealpath(path) : path;
+					if (this.fsw.closed) return;
+					const parent = sysPath$2.dirname(wh.watchPath);
+					this.fsw._getWatchedDir(parent).add(wh.watchPath);
+					this.fsw._emit(EV_ADD, wh.watchPath, stats);
+					closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+					if (this.fsw.closed) return;
+					if (targetPath !== void 0) this.fsw._symlinkPaths.set(sysPath$2.resolve(path), targetPath);
+				} else closer = this._handleFile(wh.watchPath, stats, initialAdd);
+				ready();
+				this.fsw._addPathCloser(path, closer);
+				return false;
+			} catch (error) {
+				if (this.fsw._handleError(error)) {
+					ready();
+					return path;
+				}
+			}
+		}
+	};
+	module.exports = NodeFsHandler;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/chokidar@3.6.0_patch_hash=8a4f9e2b397e6034b91a0508faae3cecb97f222313faa129d7cb0eb71e9d0e84/node_modules/chokidar/lib/fsevents-handler.js
+var require_fsevents_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$8 = __require("fs");
+	const sysPath$1 = __require("path");
+	const { promisify: promisify$2 } = __require("util");
+	let fsevents;
+	try {
+		fsevents = __require("fsevents");
+	} catch (error) {
+		if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
+	}
+	if (fsevents) {
+		const mtch = process.version.match(/v(\d+)\.(\d+)/);
+		if (mtch && mtch[1] && mtch[2]) {
+			if (Number.parseInt(mtch[1], 10) === 8 && Number.parseInt(mtch[2], 10) < 16) fsevents = void 0;
+		}
+	}
+	const { EV_ADD, EV_CHANGE, EV_ADD_DIR, EV_UNLINK, EV_ERROR, STR_DATA, STR_END, FSEVENT_CREATED, FSEVENT_MODIFIED, FSEVENT_DELETED, FSEVENT_MOVED, FSEVENT_UNKNOWN, FSEVENT_FLAG_MUST_SCAN_SUBDIRS, FSEVENT_TYPE_FILE, FSEVENT_TYPE_DIRECTORY, FSEVENT_TYPE_SYMLINK, ROOT_GLOBSTAR, DIR_SUFFIX, DOT_SLASH, FUNCTION_TYPE, EMPTY_FN, IDENTITY_FN } = require_constants$1();
+	const Depth = (value) => isNaN(value) ? {} : { depth: value };
+	const stat = promisify$2(fs$8.stat);
+	const lstat = promisify$2(fs$8.lstat);
+	const realpath = promisify$2(fs$8.realpath);
+	const statMethods = {
+		stat,
+		lstat
+	};
+	/**
+	* @typedef {String} Path
+	*/
+	/**
+	* @typedef {Object} FsEventsWatchContainer
+	* @property {Set<Function>} listeners
+	* @property {Function} rawEmitter
+	* @property {{stop: Function}} watcher
+	*/
+	/**
+	* Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
+	* @type {Map<Path,FsEventsWatchContainer>}
+	*/
+	const FSEventsWatchers = /* @__PURE__ */ new Map();
+	const consolidateThreshhold = 10;
+	const wrongEventFlags = new Set([
+		69888,
+		70400,
+		71424,
+		72704,
+		73472,
+		131328,
+		131840,
+		262912
+	]);
+	/**
+	* Instantiates the fsevents interface
+	* @param {Path} path path to be watched
+	* @param {Function} callback called when fsevents is bound and ready
+	* @returns {{stop: Function}} new fsevents instance
+	*/
+	const createFSEventsInstance = (path, callback) => {
+		return { stop: fsevents.watch(path, callback) };
+	};
+	/**
+	* Instantiates the fsevents interface or binds listeners to an existing one covering
+	* the same file tree.
+	* @param {Path} path           - to be watched
+	* @param {Path} realPath       - real path for symlinks
+	* @param {Function} listener   - called when fsevents emits events
+	* @param {Function} rawEmitter - passes data to listeners of the 'raw' event
+	* @returns {Function} closer
+	*/
+	function setFSEventsListener(path, realPath, listener, rawEmitter) {
+		let watchPath = sysPath$1.extname(realPath) ? sysPath$1.dirname(realPath) : realPath;
+		const parentPath = sysPath$1.dirname(watchPath);
+		let cont = FSEventsWatchers.get(watchPath);
+		if (couldConsolidate(parentPath)) watchPath = parentPath;
+		const resolvedPath = sysPath$1.resolve(path);
+		const hasSymlink = resolvedPath !== realPath;
+		const filteredListener = (fullPath, flags, info) => {
+			if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
+			if (fullPath === resolvedPath || !fullPath.indexOf(resolvedPath + sysPath$1.sep)) listener(fullPath, flags, info);
+		};
+		let watchedParent = false;
+		for (const watchedPath of FSEventsWatchers.keys()) if (realPath.indexOf(sysPath$1.resolve(watchedPath) + sysPath$1.sep) === 0) {
+			watchPath = watchedPath;
+			cont = FSEventsWatchers.get(watchPath);
+			watchedParent = true;
+			break;
+		}
+		if (cont || watchedParent) cont.listeners.add(filteredListener);
+		else {
+			cont = {
+				listeners: new Set([filteredListener]),
+				rawEmitter,
+				watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
+					if (!cont.listeners.size) return;
+					if (flags & FSEVENT_FLAG_MUST_SCAN_SUBDIRS) return;
+					const info = fsevents.getInfo(fullPath, flags);
+					cont.listeners.forEach((list) => {
+						list(fullPath, flags, info);
+					});
+					cont.rawEmitter(info.event, fullPath, info);
+				})
+			};
+			FSEventsWatchers.set(watchPath, cont);
+		}
+		return () => {
+			const lst = cont.listeners;
+			lst.delete(filteredListener);
+			if (!lst.size) {
+				FSEventsWatchers.delete(watchPath);
+				if (cont.watcher) return cont.watcher.stop().then(() => {
+					cont.rawEmitter = cont.watcher = void 0;
+					Object.freeze(cont);
+				});
+			}
+		};
+	}
+	const couldConsolidate = (path) => {
+		let count = 0;
+		for (const watchPath of FSEventsWatchers.keys()) if (watchPath.indexOf(path) === 0) {
+			count++;
+			if (count >= consolidateThreshhold) return true;
+		}
+		return false;
+	};
+	const canUse = () => fsevents && FSEventsWatchers.size < 128;
+	const calcDepth = (path, root) => {
+		let i = 0;
+		while (!path.indexOf(root) && (path = sysPath$1.dirname(path)) !== root) i++;
+		return i;
+	};
+	const sameTypes = (info, stats) => info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() || info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() || info.type === FSEVENT_TYPE_FILE && stats.isFile();
+	/**
+	* @mixin
+	*/
+	var FsEventsHandler = class {
+		/**
+		* @param {import('../index').FSWatcher} fsw
+		*/
+		constructor(fsw) {
+			this.fsw = fsw;
+		}
+		checkIgnored(path, stats) {
+			const ipaths = this.fsw._ignoredPaths;
+			if (this.fsw._isIgnored(path, stats)) {
+				ipaths.add(path);
+				if (stats && stats.isDirectory()) ipaths.add(path + ROOT_GLOBSTAR);
+				return true;
+			}
+			ipaths.delete(path);
+			ipaths.delete(path + ROOT_GLOBSTAR);
+		}
+		addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+			const event = watchedDir.has(item) ? EV_CHANGE : EV_ADD;
+			this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+		}
+		async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+			try {
+				const stats = await stat(path);
+				if (this.fsw.closed) return;
+				if (sameTypes(info, stats)) this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+				else this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+			} catch (error) {
+				if (error.code === "EACCES") this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+				else this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+			}
+		}
+		handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+			if (this.fsw.closed || this.checkIgnored(path)) return;
+			if (event === EV_UNLINK) {
+				const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
+				if (isDirectory || watchedDir.has(item)) this.fsw._remove(parent, item, isDirectory);
+			} else {
+				if (event === EV_ADD) {
+					if (info.type === FSEVENT_TYPE_DIRECTORY) this.fsw._getWatchedDir(path);
+					if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
+						const curDepth = opts.depth === void 0 ? void 0 : calcDepth(fullPath, realPath) + 1;
+						return this._addToFsEvents(path, false, true, curDepth);
+					}
+					this.fsw._getWatchedDir(parent).add(item);
+				}
+				/**
+				* @type {'add'|'addDir'|'unlink'|'unlinkDir'}
+				*/
+				const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
+				this.fsw._emit(eventName, path);
+				if (eventName === EV_ADD_DIR) this._addToFsEvents(path, false, true);
+			}
+		}
+		/**
+		* Handle symlinks encountered during directory scan
+		* @param {String} watchPath  - file/dir path to be watched with fsevents
+		* @param {String} realPath   - real path (in case of symlinks)
+		* @param {Function} transform  - path transformer
+		* @param {Function} globFilter - path filter in case a glob pattern was provided
+		* @returns {Function} closer for the watcher instance
+		*/
+		_watchWithFsEvents(watchPath, realPath, transform, globFilter) {
+			if (this.fsw.closed || this.fsw._isIgnored(watchPath)) return;
+			const opts = this.fsw.options;
+			const watchCallback = async (fullPath, flags, info) => {
+				if (this.fsw.closed || this.fsw._isIgnored(fullPath)) return;
+				if (opts.depth !== void 0 && calcDepth(fullPath, realPath) > opts.depth) return;
+				const path = transform(sysPath$1.join(watchPath, sysPath$1.relative(watchPath, fullPath)));
+				if (globFilter && !globFilter(path)) return;
+				const parent = sysPath$1.dirname(path);
+				const item = sysPath$1.basename(path);
+				const watchedDir = this.fsw._getWatchedDir(info.type === FSEVENT_TYPE_DIRECTORY ? path : parent);
+				if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) if (typeof opts.ignored === FUNCTION_TYPE) {
+					let stats;
+					try {
+						stats = await stat(path);
+					} catch (error) {}
+					if (this.fsw.closed) return;
+					if (this.checkIgnored(path, stats)) return;
+					if (sameTypes(info, stats)) this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+					else this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+				} else this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+				else switch (info.event) {
+					case FSEVENT_CREATED:
+					case FSEVENT_MODIFIED: return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+					case FSEVENT_DELETED:
+					case FSEVENT_MOVED: return this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+				}
+			};
+			const closer = setFSEventsListener(watchPath, realPath, watchCallback, this.fsw._emitRaw);
+			this.fsw._emitReady();
+			return closer;
+		}
+		/**
+		* Handle symlinks encountered during directory scan
+		* @param {String} linkPath path to symlink
+		* @param {String} fullPath absolute path to the symlink
+		* @param {Function} transform pre-existing path transformer
+		* @param {Number} curDepth level of subdirectories traversed to where symlink is
+		* @returns {Promise<void>}
+		*/
+		async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
+			if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath)) return;
+			this.fsw._symlinkPaths.set(fullPath, true);
+			this.fsw._incrReadyCount();
+			try {
+				const linkTarget = await realpath(linkPath);
+				if (this.fsw.closed) return;
+				if (this.fsw._isIgnored(linkTarget)) return this.fsw._emitReady();
+				this.fsw._incrReadyCount();
+				this._addToFsEvents(linkTarget || linkPath, (path) => {
+					let aliasedPath = linkPath;
+					if (linkTarget && linkTarget !== DOT_SLASH) aliasedPath = path.replace(linkTarget, linkPath);
+					else if (path !== DOT_SLASH) aliasedPath = sysPath$1.join(linkPath, path);
+					return transform(aliasedPath);
+				}, false, curDepth);
+			} catch (error) {
+				if (this.fsw._handleError(error)) return this.fsw._emitReady();
+			}
+		}
+		/**
+		*
+		* @param {Path} newPath
+		* @param {fs.Stats} stats
+		*/
+		emitAdd(newPath, stats, processPath, opts, forceAdd) {
+			const pp = processPath(newPath);
+			const isDir = stats.isDirectory();
+			const dirObj = this.fsw._getWatchedDir(sysPath$1.dirname(pp));
+			const base = sysPath$1.basename(pp);
+			if (isDir) this.fsw._getWatchedDir(pp);
+			if (dirObj.has(base)) return;
+			dirObj.add(base);
+			if (!opts.ignoreInitial || forceAdd === true) this.fsw._emit(isDir ? EV_ADD_DIR : EV_ADD, pp, stats);
+		}
+		initWatch(realPath, path, wh, processPath) {
+			if (this.fsw.closed) return;
+			const closer = this._watchWithFsEvents(wh.watchPath, sysPath$1.resolve(realPath || wh.watchPath), processPath, wh.globFilter);
+			this.fsw._addPathCloser(path, closer);
+		}
+		/**
+		* Handle added path with fsevents
+		* @param {String} path file/dir path or glob pattern
+		* @param {Function|Boolean=} transform converts working path to what the user expects
+		* @param {Boolean=} forceAdd ensure add is emitted
+		* @param {Number=} priorDepth Level of subdirectories already traversed.
+		* @returns {Promise<void>}
+		*/
+		async _addToFsEvents(path, transform, forceAdd, priorDepth) {
+			if (this.fsw.closed) return;
+			const opts = this.fsw.options;
+			const processPath = typeof transform === FUNCTION_TYPE ? transform : IDENTITY_FN;
+			const wh = this.fsw._getWatchHelpers(path);
+			try {
+				const stats = await statMethods[wh.statMethod](wh.watchPath);
+				if (this.fsw.closed) return;
+				if (this.fsw._isIgnored(wh.watchPath, stats)) throw null;
+				if (stats.isDirectory()) {
+					if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);
+					if (priorDepth && priorDepth > opts.depth) return;
+					this.fsw._readdirp(wh.watchPath, {
+						fileFilter: (entry) => wh.filterPath(entry),
+						directoryFilter: (entry) => wh.filterDir(entry),
+						...Depth(opts.depth - (priorDepth || 0))
+					}).on(STR_DATA, (entry) => {
+						if (this.fsw.closed) return;
+						if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
+						const joinedPath = sysPath$1.join(wh.watchPath, entry.path);
+						const { fullPath } = entry;
+						if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
+							const curDepth = opts.depth === void 0 ? void 0 : calcDepth(joinedPath, sysPath$1.resolve(wh.watchPath)) + 1;
+							this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
+						} else this.emitAdd(joinedPath, entry.stats, processPath, opts, forceAdd);
+					}).on(EV_ERROR, EMPTY_FN).on(STR_END, () => {
+						this.fsw._emitReady();
+					});
+				} else {
+					this.emitAdd(wh.watchPath, stats, processPath, opts, forceAdd);
+					this.fsw._emitReady();
+				}
+			} catch (error) {
+				if (!error || this.fsw._handleError(error)) {
+					this.fsw._emitReady();
+					this.fsw._emitReady();
+				}
+			}
+			if (opts.persistent && forceAdd !== true) if (typeof transform === FUNCTION_TYPE) this.initWatch(void 0, path, wh, processPath);
+			else {
+				let realPath;
+				try {
+					realPath = await realpath(wh.watchPath);
+				} catch (e) {}
+				this.initWatch(realPath, path, wh, processPath);
+			}
+		}
+	};
+	module.exports = FsEventsHandler;
+	module.exports.canUse = canUse;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/chokidar@3.6.0_patch_hash=8a4f9e2b397e6034b91a0508faae3cecb97f222313faa129d7cb0eb71e9d0e84/node_modules/chokidar/index.js
+var require_chokidar = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const { EventEmitter: EventEmitter$3 } = __require("events");
+	const fs$7 = __require("fs");
+	const sysPath = __require("path");
+	const { promisify: promisify$1 } = __require("util");
+	const readdirp = require_readdirp();
+	const anymatch = require_anymatch().default;
+	const globParent = require_glob_parent();
+	const isGlob = require_is_glob();
+	const braces = require_braces();
+	const normalizePath = require_normalize_path();
+	const NodeFsHandler = require_nodefs_handler();
+	const FsEventsHandler = require_fsevents_handler();
+	const { EV_ALL, EV_READY, EV_ADD, EV_CHANGE, EV_UNLINK, EV_ADD_DIR, EV_UNLINK_DIR, EV_RAW, EV_ERROR, STR_CLOSE, STR_END, BACK_SLASH_RE, DOUBLE_SLASH_RE, SLASH_OR_BACK_SLASH_RE, DOT_RE, REPLACER_RE, SLASH, SLASH_SLASH, BRACE_START, BANG, ONE_DOT, TWO_DOTS, GLOBSTAR, SLASH_GLOBSTAR, ANYMATCH_OPTS, STRING_TYPE, FUNCTION_TYPE, EMPTY_STR, EMPTY_FN, isWindows, isMacos, isIBMi } = require_constants$1();
+	const stat = promisify$1(fs$7.stat);
+	const readdir = promisify$1(fs$7.readdir);
+	/**
+	* @typedef {String} Path
+	* @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
+	* @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
+	*/
+	/**
+	*
+	* @typedef {Object} WatchHelpers
+	* @property {Boolean} followSymlinks
+	* @property {'stat'|'lstat'} statMethod
+	* @property {Path} path
+	* @property {Path} watchPath
+	* @property {Function} entryPath
+	* @property {Boolean} hasGlob
+	* @property {Object} globFilter
+	* @property {Function} filterPath
+	* @property {Function} filterDir
+	*/
+	const arrify = (value = []) => Array.isArray(value) ? value : [value];
+	const flatten = (list, result = []) => {
+		list.forEach((item) => {
+			if (Array.isArray(item)) flatten(item, result);
+			else result.push(item);
+		});
+		return result;
+	};
+	const unifyPaths = (paths_) => {
+		/**
+		* @type {Array<String>}
+		*/
+		const paths = flatten(arrify(paths_));
+		if (!paths.every((p) => typeof p === STRING_TYPE)) throw new TypeError(`Non-string provided as watch path: ${paths}`);
+		return paths.map(normalizePathToUnix);
+	};
+	const toUnix = (string) => {
+		let str = string.replace(BACK_SLASH_RE, SLASH);
+		let prepend = false;
+		if (str.startsWith(SLASH_SLASH)) prepend = true;
+		while (str.match(DOUBLE_SLASH_RE)) str = str.replace(DOUBLE_SLASH_RE, SLASH);
+		if (prepend) str = SLASH + str;
+		return str;
+	};
+	const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+	const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
+		if (typeof path !== STRING_TYPE) return path;
+		return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+	};
+	const getAbsolutePath = (path, cwd) => {
+		if (sysPath.isAbsolute(path)) return path;
+		if (path.startsWith(BANG)) return BANG + sysPath.join(cwd, path.slice(1));
+		return sysPath.join(cwd, path);
+	};
+	const undef = (opts, key) => opts[key] === void 0;
+	/**
+	* Directory entry.
+	* @property {Path} path
+	* @property {Set<Path>} items
+	*/
+	var DirEntry = class {
+		/**
+		* @param {Path} dir
+		* @param {Function} removeWatcher
+		*/
+		constructor(dir, removeWatcher) {
+			this.path = dir;
+			this._removeWatcher = removeWatcher;
+			/** @type {Set<Path>} */
+			this.items = /* @__PURE__ */ new Set();
+		}
+		add(item) {
+			const { items } = this;
+			if (!items) return;
+			if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+		}
+		async remove(item) {
+			const { items } = this;
+			if (!items) return;
+			items.delete(item);
+			if (items.size > 0) return;
+			const dir = this.path;
+			try {
+				await readdir(dir);
+			} catch (err) {
+				if (this._removeWatcher) this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+			}
+		}
+		has(item) {
+			const { items } = this;
+			if (!items) return;
+			return items.has(item);
+		}
+		/**
+		* @returns {Array<String>}
+		*/
+		getChildren() {
+			const { items } = this;
+			if (!items) return;
+			return [...items.values()];
+		}
+		dispose() {
+			this.items.clear();
+			delete this.path;
+			delete this._removeWatcher;
+			delete this.items;
+			Object.freeze(this);
+		}
+	};
+	const STAT_METHOD_F = "stat";
+	const STAT_METHOD_L = "lstat";
+	var WatchHelper = class {
+		constructor(path, watchPath, follow, fsw) {
+			this.fsw = fsw;
+			this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
+			this.watchPath = watchPath;
+			this.fullWatchPath = sysPath.resolve(watchPath);
+			this.hasGlob = watchPath !== path;
+			/** @type {object|boolean} */
+			if (path === EMPTY_STR) this.hasGlob = false;
+			this.globSymlink = this.hasGlob && follow ? void 0 : false;
+			this.globFilter = this.hasGlob ? anymatch(path, void 0, ANYMATCH_OPTS) : false;
+			this.dirParts = this.getDirParts(path);
+			this.dirParts.forEach((parts) => {
+				if (parts.length > 1) parts.pop();
+			});
+			this.followSymlinks = follow;
+			this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+		}
+		checkGlobSymlink(entry) {
+			if (this.globSymlink === void 0) this.globSymlink = entry.fullParentDir === this.fullWatchPath ? false : {
+				realPath: entry.fullParentDir,
+				linkPath: this.fullWatchPath
+			};
+			if (this.globSymlink) return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
+			return entry.fullPath;
+		}
+		entryPath(entry) {
+			return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, this.checkGlobSymlink(entry)));
+		}
+		filterPath(entry) {
+			const { stats } = entry;
+			if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+			const resolvedPath = this.entryPath(entry);
+			return (this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ? this.globFilter(resolvedPath) : true) && this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+		}
+		getDirParts(path) {
+			if (!this.hasGlob) return [];
+			const parts = [];
+			(path.includes(BRACE_START) ? braces.expand(path) : [path]).forEach((path) => {
+				parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
+			});
+			return parts;
+		}
+		filterDir(entry) {
+			if (this.hasGlob) {
+				const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
+				let globstar = false;
+				this.unmatchedGlob = !this.dirParts.some((parts) => {
+					return parts.every((part, i) => {
+						if (part === GLOBSTAR) globstar = true;
+						return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
+					});
+				});
+			}
+			return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+		}
+	};
+	/**
+	* Watches files & directories for changes. Emitted events:
+	* `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+	*
+	*     new FSWatcher()
+	*       .add(directories)
+	*       .on('add', path => log('File', path, 'was added'))
+	*/
+	var FSWatcher = class extends EventEmitter$3 {
+		constructor(_opts) {
+			super();
+			const opts = {};
+			if (_opts) Object.assign(opts, _opts);
+			/** @type {Map<String, DirEntry>} */
+			this._watched = /* @__PURE__ */ new Map();
+			/** @type {Map<String, Array>} */
+			this._closers = /* @__PURE__ */ new Map();
+			/** @type {Set<String>} */
+			this._ignoredPaths = /* @__PURE__ */ new Set();
+			/** @type {Map<ThrottleType, Map>} */
+			this._throttled = /* @__PURE__ */ new Map();
+			/** @type {Map<Path, String|Boolean>} */
+			this._symlinkPaths = /* @__PURE__ */ new Map();
+			this._streams = /* @__PURE__ */ new Set();
+			this.closed = false;
+			if (undef(opts, "persistent")) opts.persistent = true;
+			if (undef(opts, "ignoreInitial")) opts.ignoreInitial = false;
+			if (undef(opts, "ignorePermissionErrors")) opts.ignorePermissionErrors = false;
+			if (undef(opts, "interval")) opts.interval = 100;
+			if (undef(opts, "binaryInterval")) opts.binaryInterval = 300;
+			if (undef(opts, "disableGlobbing")) opts.disableGlobbing = false;
+			opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
+			if (undef(opts, "useFsEvents")) opts.useFsEvents = !opts.usePolling;
+			if (!FsEventsHandler.canUse()) opts.useFsEvents = false;
+			if (undef(opts, "usePolling") && !opts.useFsEvents) opts.usePolling = isMacos;
+			if (isIBMi) opts.usePolling = true;
+			const envPoll = process.env.CHOKIDAR_USEPOLLING;
+			if (envPoll !== void 0) {
+				const envLower = envPoll.toLowerCase();
+				if (envLower === "false" || envLower === "0") opts.usePolling = false;
+				else if (envLower === "true" || envLower === "1") opts.usePolling = true;
+				else opts.usePolling = !!envLower;
+			}
+			const envInterval = process.env.CHOKIDAR_INTERVAL;
+			if (envInterval) opts.interval = Number.parseInt(envInterval, 10);
+			if (undef(opts, "atomic")) opts.atomic = !opts.usePolling && !opts.useFsEvents;
+			if (opts.atomic) this._pendingUnlinks = /* @__PURE__ */ new Map();
+			if (undef(opts, "followSymlinks")) opts.followSymlinks = true;
+			if (undef(opts, "awaitWriteFinish")) opts.awaitWriteFinish = false;
+			if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
+			const awf = opts.awaitWriteFinish;
+			if (awf) {
+				if (!awf.stabilityThreshold) awf.stabilityThreshold = 2e3;
+				if (!awf.pollInterval) awf.pollInterval = 100;
+				this._pendingWrites = /* @__PURE__ */ new Map();
+			}
+			if (opts.ignored) opts.ignored = arrify(opts.ignored);
+			let readyCalls = 0;
+			this._emitReady = () => {
+				readyCalls++;
+				if (readyCalls >= this._readyCount) {
+					this._emitReady = EMPTY_FN;
+					this._readyEmitted = true;
+					process.nextTick(() => this.emit(EV_READY));
+				}
+			};
+			this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
+			this._readyEmitted = false;
+			this.options = opts;
+			if (opts.useFsEvents) this._fsEventsHandler = new FsEventsHandler(this);
+			else this._nodeFsHandler = new NodeFsHandler(this);
+			Object.freeze(opts);
+		}
+		/**
+		* Adds paths to be watched on an existing FSWatcher instance
+		* @param {Path|Array<Path>} paths_
+		* @param {String=} _origAdd private; for handling non-existent paths to be watched
+		* @param {Boolean=} _internal private; indicates a non-user add
+		* @returns {FSWatcher} for chaining
+		*/
+		add(paths_, _origAdd, _internal) {
+			const { cwd, disableGlobbing } = this.options;
+			this.closed = false;
+			let paths = unifyPaths(paths_);
+			if (cwd) paths = paths.map((path) => {
+				const absPath = getAbsolutePath(path, cwd);
+				if (disableGlobbing || !isGlob(path)) return absPath;
+				return normalizePath(absPath);
+			});
+			paths = paths.filter((path) => {
+				if (path.startsWith(BANG)) {
+					this._ignoredPaths.add(path.slice(1));
+					return false;
+				}
+				this._ignoredPaths.delete(path);
+				this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
+				this._userIgnored = void 0;
+				return true;
+			});
+			if (this.options.useFsEvents && this._fsEventsHandler) {
+				if (!this._readyCount) this._readyCount = paths.length;
+				if (this.options.persistent) this._readyCount += paths.length;
+				paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
+			} else {
+				if (!this._readyCount) this._readyCount = 0;
+				this._readyCount += paths.length;
+				Promise.all(paths.map(async (path) => {
+					const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
+					if (res) this._emitReady();
+					return res;
+				})).then((results) => {
+					if (this.closed) return;
+					results.filter((item) => item).forEach((item) => {
+						this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+					});
+				});
+			}
+			return this;
+		}
+		/**
+		* Close watchers or start ignoring events from specified paths.
+		* @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
+		* @returns {FSWatcher} for chaining
+		*/
+		unwatch(paths_) {
+			if (this.closed) return this;
+			const paths = unifyPaths(paths_);
+			const { cwd } = this.options;
+			paths.forEach((path) => {
+				if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+					if (cwd) path = sysPath.join(cwd, path);
+					path = sysPath.resolve(path);
+				}
+				this._closePath(path);
+				this._ignoredPaths.add(path);
+				if (this._watched.has(path)) this._ignoredPaths.add(path + SLASH_GLOBSTAR);
+				this._userIgnored = void 0;
+			});
+			return this;
+		}
+		/**
+		* Close watchers and remove all listeners from watched paths.
+		* @returns {Promise<void>}.
+		*/
+		close() {
+			if (this.closed) return this._closePromise;
+			this.closed = true;
+			this.removeAllListeners();
+			const closers = [];
+			this._closers.forEach((closerList) => closerList.forEach((closer) => {
+				const promise = closer();
+				if (promise instanceof Promise) closers.push(promise);
+			}));
+			this._streams.forEach((stream) => stream.destroy());
+			this._userIgnored = void 0;
+			this._readyCount = 0;
+			this._readyEmitted = false;
+			this._watched.forEach((dirent) => dirent.dispose());
+			[
+				"closers",
+				"watched",
+				"streams",
+				"symlinkPaths",
+				"throttled"
+			].forEach((key) => {
+				this[`_${key}`].clear();
+			});
+			this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+			return this._closePromise;
+		}
+		/**
+		* Expose list of watched paths
+		* @returns {Object} for chaining
+		*/
+		getWatched() {
+			const watchList = {};
+			this._watched.forEach((entry, dir) => {
+				const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+				watchList[key || ONE_DOT] = entry.getChildren().sort();
+			});
+			return watchList;
+		}
+		emitWithAll(event, args) {
+			this.emit(...args);
+			if (event !== EV_ERROR) this.emit(EV_ALL, ...args);
+		}
+		/**
+		* Normalize and emit events.
+		* Calling _emit DOES NOT MEAN emit() would be called!
+		* @param {EventName} event Type of event
+		* @param {Path} path File or directory path
+		* @param {*=} val1 arguments to be passed with event
+		* @param {*=} val2
+		* @param {*=} val3
+		* @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+		*/
+		async _emit(event, path, val1, val2, val3) {
+			if (this.closed) return;
+			const opts = this.options;
+			if (isWindows) path = sysPath.normalize(path);
+			if (opts.cwd) path = sysPath.relative(opts.cwd, path);
+			/** @type Array<any> */
+			const args = [event, path];
+			if (val3 !== void 0) args.push(val1, val2, val3);
+			else if (val2 !== void 0) args.push(val1, val2);
+			else if (val1 !== void 0) args.push(val1);
+			const awf = opts.awaitWriteFinish;
+			let pw;
+			if (awf && (pw = this._pendingWrites.get(path))) {
+				pw.lastChange = /* @__PURE__ */ new Date();
+				return this;
+			}
+			if (opts.atomic) {
+				if (event === EV_UNLINK) {
+					this._pendingUnlinks.set(path, args);
+					setTimeout(() => {
+						this._pendingUnlinks.forEach((entry, path) => {
+							this.emit(...entry);
+							this.emit(EV_ALL, ...entry);
+							this._pendingUnlinks.delete(path);
+						});
+					}, typeof opts.atomic === "number" ? opts.atomic : 100);
+					return this;
+				}
+				if (event === EV_ADD && this._pendingUnlinks.has(path)) {
+					event = args[0] = EV_CHANGE;
+					this._pendingUnlinks.delete(path);
+				}
+			}
+			if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
+				const awfEmit = (err, stats) => {
+					if (err) {
+						event = args[0] = EV_ERROR;
+						args[1] = err;
+						this.emitWithAll(event, args);
+					} else if (stats) {
+						if (args.length > 2) args[2] = stats;
+						else args.push(stats);
+						this.emitWithAll(event, args);
+					}
+				};
+				this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+				return this;
+			}
+			if (event === EV_CHANGE) {
+				if (!this._throttle(EV_CHANGE, path, 50)) return this;
+			}
+			if (opts.alwaysStat && val1 === void 0 && (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)) {
+				const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+				let stats;
+				try {
+					stats = await stat(fullPath);
+				} catch (err) {}
+				if (!stats || this.closed) return;
+				args.push(stats);
+			}
+			this.emitWithAll(event, args);
+			return this;
+		}
+		/**
+		* Common handler for errors
+		* @param {Error} error
+		* @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+		*/
+		_handleError(error) {
+			const code = error && error.code;
+			if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) this.emit(EV_ERROR, error);
+			return error || this.closed;
+		}
+		/**
+		* Helper utility for throttling
+		* @param {ThrottleType} actionType type being throttled
+		* @param {Path} path being acted upon
+		* @param {Number} timeout duration of time to suppress duplicate actions
+		* @returns {Object|false} tracking object or false if action should be suppressed
+		*/
+		_throttle(actionType, path, timeout) {
+			if (!this._throttled.has(actionType)) this._throttled.set(actionType, /* @__PURE__ */ new Map());
+			/** @type {Map<Path, Object>} */
+			const action = this._throttled.get(actionType);
+			/** @type {Object} */
+			const actionPath = action.get(path);
+			if (actionPath) {
+				actionPath.count++;
+				return false;
+			}
+			let timeoutObject;
+			const clear = () => {
+				const item = action.get(path);
+				const count = item ? item.count : 0;
+				action.delete(path);
+				clearTimeout(timeoutObject);
+				if (item) clearTimeout(item.timeoutObject);
+				return count;
+			};
+			timeoutObject = setTimeout(clear, timeout);
+			const thr = {
+				timeoutObject,
+				clear,
+				count: 0
+			};
+			action.set(path, thr);
+			return thr;
+		}
+		_incrReadyCount() {
+			return this._readyCount++;
+		}
+		/**
+		* Awaits write operation to finish.
+		* Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+		* @param {Path} path being acted upon
+		* @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+		* @param {EventName} event
+		* @param {Function} awfEmit Callback to be called when ready for event to be emitted.
+		*/
+		_awaitWriteFinish(path, threshold, event, awfEmit) {
+			let timeoutHandler;
+			let fullPath = path;
+			if (this.options.cwd && !sysPath.isAbsolute(path)) fullPath = sysPath.join(this.options.cwd, path);
+			const now = /* @__PURE__ */ new Date();
+			const awaitWriteFinish = (prevStat) => {
+				fs$7.stat(fullPath, (err, curStat) => {
+					if (err || !this._pendingWrites.has(path)) {
+						if (err && err.code !== "ENOENT") awfEmit(err);
+						return;
+					}
+					const now = Number(/* @__PURE__ */ new Date());
+					if (prevStat && curStat.size !== prevStat.size) this._pendingWrites.get(path).lastChange = now;
+					if (now - this._pendingWrites.get(path).lastChange >= threshold) {
+						this._pendingWrites.delete(path);
+						awfEmit(void 0, curStat);
+					} else timeoutHandler = setTimeout(awaitWriteFinish, this.options.awaitWriteFinish.pollInterval, curStat);
+				});
+			};
+			if (!this._pendingWrites.has(path)) {
+				this._pendingWrites.set(path, {
+					lastChange: now,
+					cancelWait: () => {
+						this._pendingWrites.delete(path);
+						clearTimeout(timeoutHandler);
+						return event;
+					}
+				});
+				timeoutHandler = setTimeout(awaitWriteFinish, this.options.awaitWriteFinish.pollInterval);
+			}
+		}
+		_getGlobIgnored() {
+			return [...this._ignoredPaths.values()];
+		}
+		/**
+		* Determines whether user has asked to ignore this path.
+		* @param {Path} path filepath or dir
+		* @param {fs.Stats=} stats result of fs.stat
+		* @returns {Boolean}
+		*/
+		_isIgnored(path, stats) {
+			if (this.options.atomic && DOT_RE.test(path)) return true;
+			if (!this._userIgnored) {
+				const { cwd } = this.options;
+				const ign = this.options.ignored;
+				const ignored = ign && ign.map(normalizeIgnored(cwd));
+				const paths = arrify(ignored).filter((path) => typeof path === STRING_TYPE && !isGlob(path)).map((path) => path + SLASH_GLOBSTAR);
+				const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
+				this._userIgnored = anymatch(list, void 0, ANYMATCH_OPTS);
+			}
+			return this._userIgnored([path, stats]);
+		}
+		_isntIgnored(path, stat) {
+			return !this._isIgnored(path, stat);
+		}
+		/**
+		* Provides a set of common helpers and properties relating to symlink and glob handling.
+		* @param {Path} path file, directory, or glob pattern being watched
+		* @param {Number=} depth at any depth > 0, this isn't a glob
+		* @returns {WatchHelper} object containing helpers for this path
+		*/
+		_getWatchHelpers(path, depth) {
+			const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
+			const follow = this.options.followSymlinks;
+			return new WatchHelper(path, watchPath, follow, this);
+		}
+		/**
+		* Provides directory tracking objects
+		* @param {String} directory path of the directory
+		* @returns {DirEntry} the directory's tracking object
+		*/
+		_getWatchedDir(directory) {
+			if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
+			const dir = sysPath.resolve(directory);
+			if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+			return this._watched.get(dir);
+		}
+		/**
+		* Check for read permissions.
+		* Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
+		* @param {fs.Stats} stats - object, result of fs_stat
+		* @returns {Boolean} indicates whether the file can be read
+		*/
+		_hasReadPermissions(stats) {
+			if (this.options.ignorePermissionErrors) return true;
+			const st = (stats && Number.parseInt(stats.mode, 10)) & 511;
+			const it = Number.parseInt(st.toString(8)[0], 10);
+			return Boolean(4 & it);
+		}
+		/**
+		* Handles emitting unlink events for
+		* files and directories, and via recursion, for
+		* files and directories within directories that are unlinked
+		* @param {String} directory within which the following item is located
+		* @param {String} item      base path of item/directory
+		* @returns {void}
+		*/
+		_remove(directory, item, isDirectory) {
+			const path = sysPath.join(directory, item);
+			const fullPath = sysPath.resolve(path);
+			isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+			if (!this._throttle("remove", path, 100)) return;
+			if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) this.add(directory, item, true);
+			this._getWatchedDir(path).getChildren().forEach((nested) => this._remove(path, nested));
+			const parent = this._getWatchedDir(directory);
+			const wasTracked = parent.has(item);
+			parent.remove(item);
+			if (this._symlinkPaths.has(fullPath)) this._symlinkPaths.delete(fullPath);
+			let relPath = path;
+			if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
+			if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+				if (this._pendingWrites.get(relPath).cancelWait() === EV_ADD) return;
+			}
+			this._watched.delete(path);
+			this._watched.delete(fullPath);
+			const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
+			if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+			if (!this.options.useFsEvents) this._closePath(path);
+		}
+		/**
+		* Closes all watchers for a path
+		* @param {Path} path
+		*/
+		_closePath(path) {
+			this._closeFile(path);
+			const dir = sysPath.dirname(path);
+			this._getWatchedDir(dir).remove(sysPath.basename(path));
+		}
+		/**
+		* Closes only file-specific watchers
+		* @param {Path} path
+		*/
+		_closeFile(path) {
+			const closers = this._closers.get(path);
+			if (!closers) return;
+			closers.forEach((closer) => closer());
+			this._closers.delete(path);
+		}
+		/**
+		*
+		* @param {Path} path
+		* @param {Function} closer
+		*/
+		_addPathCloser(path, closer) {
+			if (!closer) return;
+			let list = this._closers.get(path);
+			if (!list) {
+				list = [];
+				this._closers.set(path, list);
+			}
+			list.push(closer);
+		}
+		_readdirp(root, opts) {
+			if (this.closed) return;
+			let stream = readdirp(root, {
+				type: EV_ALL,
+				alwaysStat: true,
+				lstat: true,
+				...opts
+			});
+			this._streams.add(stream);
+			stream.once(STR_CLOSE, () => {
+				stream = void 0;
+			});
+			stream.once(STR_END, () => {
+				if (stream) {
+					this._streams.delete(stream);
+					stream = void 0;
+				}
+			});
+			return stream;
+		}
+	};
+	/**
+	* Instantiates watcher with paths to be tracked.
+	* @param {String|Array<String>} paths file/directory paths and/or globs
+	* @param {Object=} options chokidar opts
+	* @returns an instance of FSWatcher for chaining.
+	*/
+	const watch = (paths, options) => {
+		const watcher = new FSWatcher(options);
+		watcher.add(paths);
+		return watcher;
+	};
+	exports.watch = watch;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/quote.js
+var require_quote = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function quote(xs) {
+		return xs.map(function(s) {
+			if (s === "") return "''";
+			if (s && typeof s === "object") return s.op.replace(/(.)/g, "\\$1");
+			if (/["\s\\]/.test(s) && !/'/.test(s)) return "'" + s.replace(/(['])/g, "\\$1") + "'";
+			if (/["'\s]/.test(s)) return "\"" + s.replace(/(["\\$`!])/g, "\\$1") + "\"";
+			return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
+		}).join(" ");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/parse.js
+var require_parse$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var CONTROL = "(?:" + [
+		"\\|\\|",
+		"\\&\\&",
+		";;",
+		"\\|\\&",
+		"\\<\\(",
+		"\\<\\<\\<",
+		">>",
+		">\\&",
+		"<\\&",
+		"[&;()|<>]"
+	].join("|") + ")";
+	var controlRE = new RegExp("^" + CONTROL + "$");
+	var META = "|&;()<> \\t";
+	var SINGLE_QUOTE = "\"((\\\\\"|[^\"])*?)\"";
+	var DOUBLE_QUOTE = "'((\\\\'|[^'])*?)'";
+	var hash = /^#$/;
+	var SQ = "'";
+	var DQ = "\"";
+	var DS = "$";
+	var TOKEN = "";
+	var mult = 4294967296;
+	for (var i = 0; i < 4; i++) TOKEN += (mult * Math.random()).toString(16);
+	var startsWithToken = new RegExp("^" + TOKEN);
+	function matchAll(s, r) {
+		var origIndex = r.lastIndex;
+		var matches = [];
+		var matchObj;
+		while (matchObj = r.exec(s)) {
+			matches.push(matchObj);
+			if (r.lastIndex === matchObj.index) r.lastIndex += 1;
+		}
+		r.lastIndex = origIndex;
+		return matches;
+	}
+	function getVar(env, pre, key) {
+		var r = typeof env === "function" ? env(key) : env[key];
+		if (typeof r === "undefined" && key != "") r = "";
+		else if (typeof r === "undefined") r = "$";
+		if (typeof r === "object") return pre + TOKEN + JSON.stringify(r) + TOKEN;
+		return pre + r;
+	}
+	function parseInternal(string, env, opts) {
+		if (!opts) opts = {};
+		var BS = opts.escape || "\\";
+		var BAREWORD = "(\\" + BS + "['\"" + META + "]|[^\\s'\"" + META + "])+";
+		var matches = matchAll(string, new RegExp(["(" + CONTROL + ")", "(" + BAREWORD + "|" + SINGLE_QUOTE + "|" + DOUBLE_QUOTE + ")+"].join("|"), "g"));
+		if (matches.length === 0) return [];
+		if (!env) env = {};
+		var commented = false;
+		return matches.map(function(match) {
+			var s = match[0];
+			if (!s || commented) return;
+			if (controlRE.test(s)) return { op: s };
+			var quote = false;
+			var esc = false;
+			var out = "";
+			var isGlob = false;
+			var i;
+			function parseEnvVar() {
+				i += 1;
+				var varend;
+				var varname;
+				var char = s.charAt(i);
+				if (char === "{") {
+					i += 1;
+					if (s.charAt(i) === "}") throw new Error("Bad substitution: " + s.slice(i - 2, i + 1));
+					varend = s.indexOf("}", i);
+					if (varend < 0) throw new Error("Bad substitution: " + s.slice(i));
+					varname = s.slice(i, varend);
+					i = varend;
+				} else if (/[*@#?$!_-]/.test(char)) {
+					varname = char;
+					i += 1;
+				} else {
+					var slicedFromI = s.slice(i);
+					varend = slicedFromI.match(/[^\w\d_]/);
+					if (!varend) {
+						varname = slicedFromI;
+						i = s.length;
+					} else {
+						varname = slicedFromI.slice(0, varend.index);
+						i += varend.index - 1;
+					}
+				}
+				return getVar(env, "", varname);
+			}
+			for (i = 0; i < s.length; i++) {
+				var c = s.charAt(i);
+				isGlob = isGlob || !quote && (c === "*" || c === "?");
+				if (esc) {
+					out += c;
+					esc = false;
+				} else if (quote) if (c === quote) quote = false;
+				else if (quote == SQ) out += c;
+				else if (c === BS) {
+					i += 1;
+					c = s.charAt(i);
+					if (c === DQ || c === BS || c === DS) out += c;
+					else out += BS + c;
+				} else if (c === DS) out += parseEnvVar();
+				else out += c;
+				else if (c === DQ || c === SQ) quote = c;
+				else if (controlRE.test(c)) return { op: s };
+				else if (hash.test(c)) {
+					commented = true;
+					var commentObj = { comment: string.slice(match.index + i + 1) };
+					if (out.length) return [out, commentObj];
+					return [commentObj];
+				} else if (c === BS) esc = true;
+				else if (c === DS) out += parseEnvVar();
+				else out += c;
+			}
+			if (isGlob) return {
+				op: "glob",
+				pattern: out
+			};
+			return out;
+		}).reduce(function(prev, arg) {
+			return typeof arg === "undefined" ? prev : prev.concat(arg);
+		}, []);
+	}
+	module.exports = function parse(s, env, opts) {
+		var mapped = parseInternal(s, env, opts);
+		if (typeof env !== "function") return mapped;
+		return mapped.reduce(function(acc, s) {
+			if (typeof s === "object") return acc.concat(s);
+			var xs = s.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
+			if (xs.length === 1) return acc.concat(xs[0]);
+			return acc.concat(xs.filter(Boolean).map(function(x) {
+				if (startsWithToken.test(x)) return JSON.parse(x.split(TOKEN)[1]);
+				return x;
+			}));
+		}, []);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/index.js
+var require_shell_quote = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.quote = require_quote();
+	exports.parse = require_parse$1();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/launch-editor@2.13.2/node_modules/launch-editor/editor-info/macos.js
+var require_macos = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"/Applications/Atom.app/Contents/MacOS/Atom": "atom",
+		"/Applications/Atom Beta.app/Contents/MacOS/Atom Beta": "/Applications/Atom Beta.app/Contents/MacOS/Atom Beta",
+		"/Applications/Brackets.app/Contents/MacOS/Brackets": "brackets",
+		"/Applications/Sublime Text.app/Contents/MacOS/Sublime Text": "/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl",
+		"/Applications/Sublime Text.app/Contents/MacOS/sublime_text": "/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl",
+		"/Applications/Sublime Text 2.app/Contents/MacOS/Sublime Text 2": "/Applications/Sublime Text 2.app/Contents/SharedSupport/bin/subl",
+		"/Applications/Sublime Text Dev.app/Contents/MacOS/Sublime Text": "/Applications/Sublime Text Dev.app/Contents/SharedSupport/bin/subl",
+		"/Applications/Visual Studio Code.app/Contents/MacOS/Code": "code",
+		"/Applications/Visual Studio Code.app/Contents/MacOS/Electron": "code",
+		"/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Code - Insiders": "code-insiders",
+		"/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Electron": "code-insiders",
+		"/Applications/VSCodium.app/Contents/MacOS/Electron": "codium",
+		"/Applications/Cursor.app/Contents/MacOS/Cursor": "cursor",
+		"/Applications/Trae.app/Contents/MacOS/Electron": "trae",
+		"/Applications/Antigravity.app/Contents/MacOS/Electron": "antigravity",
+		"/Applications/AppCode.app/Contents/MacOS/appcode": "/Applications/AppCode.app/Contents/MacOS/appcode",
+		"/Applications/CLion.app/Contents/MacOS/clion": "/Applications/CLion.app/Contents/MacOS/clion",
+		"/Applications/IntelliJ IDEA.app/Contents/MacOS/idea": "/Applications/IntelliJ IDEA.app/Contents/MacOS/idea",
+		"/Applications/IntelliJ IDEA Ultimate.app/Contents/MacOS/idea": "/Applications/IntelliJ IDEA Ultimate.app/Contents/MacOS/idea",
+		"/Applications/IntelliJ IDEA Community Edition.app/Contents/MacOS/idea": "/Applications/IntelliJ IDEA Community Edition.app/Contents/MacOS/idea",
+		"/Applications/PhpStorm.app/Contents/MacOS/phpstorm": "/Applications/PhpStorm.app/Contents/MacOS/phpstorm",
+		"/Applications/PyCharm.app/Contents/MacOS/pycharm": "/Applications/PyCharm.app/Contents/MacOS/pycharm",
+		"/Applications/PyCharm CE.app/Contents/MacOS/pycharm": "/Applications/PyCharm CE.app/Contents/MacOS/pycharm",
+		"/Applications/RubyMine.app/Contents/MacOS/rubymine": "/Applications/RubyMine.app/Contents/MacOS/rubymine",
+		"/Applications/WebStorm.app/Contents/MacOS/webstorm": "/Applications/WebStorm.app/Contents/MacOS/webstorm",
+		"/Applications/MacVim.app/Contents/MacOS/MacVim": "mvim",
+		"/Applications/GoLand.app/Contents/MacOS/goland": "/Applications/GoLand.app/Contents/MacOS/goland",
+		"/Applications/Rider.app/Contents/MacOS/rider": "/Applications/Rider.app/Contents/MacOS/rider",
+		"/Applications/Zed.app/Contents/MacOS/zed": "zed"
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/launch-editor@2.13.2/node_modules/launch-editor/editor-info/linux.js
+var require_linux = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		atom: "atom",
+		Brackets: "brackets",
+		"code-insiders": "code-insiders",
+		code: "code",
+		vscodium: "vscodium",
+		codium: "codium",
+		cursor: "cursor",
+		trae: "trae",
+		antigravity: "antigravity",
+		emacs: "emacs",
+		gvim: "gvim",
+		idea: "idea",
+		"idea.sh": "idea",
+		phpstorm: "phpstorm",
+		"phpstorm.sh": "phpstorm",
+		pycharm: "pycharm",
+		"pycharm.sh": "pycharm",
+		rubymine: "rubymine",
+		"rubymine.sh": "rubymine",
+		sublime_text: "subl",
+		vim: "vim",
+		webstorm: "webstorm",
+		"webstorm.sh": "webstorm",
+		goland: "goland",
+		"goland.sh": "goland",
+		rider: "rider",
+		"rider.sh": "rider",
+		zed: "zed"
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/launch-editor@2.13.2/node_modules/launch-editor/editor-info/windows.js
+var require_windows$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = [
+		"Brackets.exe",
+		"Code.exe",
+		"Code - Insiders.exe",
+		"VSCodium.exe",
+		"Cursor.exe",
+		"atom.exe",
+		"sublime_text.exe",
+		"notepad++.exe",
+		"clion.exe",
+		"clion64.exe",
+		"idea.exe",
+		"idea64.exe",
+		"phpstorm.exe",
+		"phpstorm64.exe",
+		"pycharm.exe",
+		"pycharm64.exe",
+		"rubymine.exe",
+		"rubymine64.exe",
+		"webstorm.exe",
+		"webstorm64.exe",
+		"goland.exe",
+		"goland64.exe",
+		"rider.exe",
+		"rider64.exe",
+		"Trae.exe",
+		"zed.exe",
+		"Antigravity.exe"
+	];
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/launch-editor@2.13.2/node_modules/launch-editor/guess.js
+var require_guess = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$9 = __require("path");
+	const shellQuote = require_shell_quote();
+	const childProcess$2 = __require("child_process");
+	const COMMON_EDITORS_MACOS = require_macos();
+	const COMMON_EDITORS_LINUX = require_linux();
+	const COMMON_EDITORS_WIN = require_windows$1();
+	module.exports = function guessEditor(specifiedEditor) {
+		if (specifiedEditor) return shellQuote.parse(specifiedEditor);
+		if (process.env.LAUNCH_EDITOR) return [process.env.LAUNCH_EDITOR];
+		if (process.versions.webcontainer) return [process.env.EDITOR || "code"];
+		try {
+			if (process.platform === "darwin") {
+				const output = childProcess$2.execSync("ps x -o comm=", { stdio: [
+					"pipe",
+					"pipe",
+					"ignore"
+				] }).toString();
+				const processNames = Object.keys(COMMON_EDITORS_MACOS);
+				const processList = output.split("\n");
+				for (let i = 0; i < processNames.length; i++) {
+					const processName = processNames[i];
+					if (processList.includes(processName)) return [COMMON_EDITORS_MACOS[processName]];
+					const processNameWithoutApplications = processName.replace("/Applications", "");
+					if (output.indexOf(processNameWithoutApplications) !== -1) {
+						if (processName !== COMMON_EDITORS_MACOS[processName]) return [COMMON_EDITORS_MACOS[processName]];
+						const runningProcess = processList.find((procName) => procName.endsWith(processNameWithoutApplications));
+						if (runningProcess !== void 0) return [runningProcess];
+					}
+				}
+			} else if (process.platform === "win32") {
+				const runningProcesses = childProcess$2.execSync("powershell -NoProfile -Command \"[Console]::OutputEncoding=[Text.Encoding]::UTF8;Get-CimInstance -Query \\\"select executablepath from win32_process where executablepath is not null\\\" | % { $_.ExecutablePath }\"", { stdio: [
+					"pipe",
+					"pipe",
+					"ignore"
+				] }).toString().split("\r\n");
+				for (let i = 0; i < runningProcesses.length; i++) {
+					const fullProcessPath = runningProcesses[i].trim();
+					const shortProcessName = path$9.basename(fullProcessPath);
+					if (COMMON_EDITORS_WIN.indexOf(shortProcessName) !== -1) return [fullProcessPath];
+				}
+			} else if (process.platform === "linux") {
+				const output = childProcess$2.execSync("ps x --no-heading -o comm --sort=comm", { stdio: [
+					"pipe",
+					"pipe",
+					"ignore"
+				] }).toString();
+				const processNames = Object.keys(COMMON_EDITORS_LINUX);
+				for (let i = 0; i < processNames.length; i++) {
+					const processName = processNames[i];
+					if (output.indexOf(processName) !== -1) return [COMMON_EDITORS_LINUX[processName]];
+				}
+			}
+		} catch (ignoreError) {}
+		if (process.env.VISUAL) return [process.env.VISUAL];
+		else if (process.env.EDITOR) return [process.env.EDITOR];
+		return [null];
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/launch-editor@2.13.2/node_modules/launch-editor/get-args.js
+var require_get_args = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$8 = __require("path");
+	module.exports = function getArgumentsForPosition(editor, fileName, lineNumber, columnNumber = 1) {
+		switch (path$8.basename(editor).replace(/\.(exe|cmd|bat)$/i, "")) {
+			case "atom":
+			case "Atom":
+			case "Atom Beta":
+			case "subl":
+			case "sublime":
+			case "sublime_text":
+			case "wstorm":
+			case "charm":
+			case "zed": return [`${fileName}:${lineNumber}:${columnNumber}`];
+			case "notepad++": return [
+				"-n" + lineNumber,
+				"-c" + columnNumber,
+				fileName
+			];
+			case "vim":
+			case "mvim": return [`+call cursor(${lineNumber}, ${columnNumber})`, fileName];
+			case "joe":
+			case "gvim": return [`+${lineNumber}`, fileName];
+			case "emacs":
+			case "emacsclient": return [`+${lineNumber}:${columnNumber}`, fileName];
+			case "rmate":
+			case "mate":
+			case "mine": return [
+				"--line",
+				lineNumber,
+				fileName
+			];
+			case "code":
+			case "Code":
+			case "code-insiders":
+			case "Code - Insiders":
+			case "codium":
+			case "trae":
+			case "antigravity":
+			case "cursor":
+			case "vscodium":
+			case "VSCodium": return [
+				"-r",
+				"-g",
+				`${fileName}:${lineNumber}:${columnNumber}`
+			];
+			case "appcode":
+			case "clion":
+			case "clion64":
+			case "idea":
+			case "idea64":
+			case "phpstorm":
+			case "phpstorm64":
+			case "pycharm":
+			case "pycharm64":
+			case "rubymine":
+			case "rubymine64":
+			case "webstorm":
+			case "webstorm64":
+			case "goland":
+			case "goland64":
+			case "rider":
+			case "rider64": return [
+				"--line",
+				lineNumber,
+				"--column",
+				columnNumber,
+				fileName
+			];
+		}
+		if (process.env.LAUNCH_EDITOR) return [
+			fileName,
+			lineNumber,
+			columnNumber
+		];
+		return [fileName];
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/launch-editor@2.13.2/node_modules/launch-editor/index.js
+var require_launch_editor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Copyright (c) 2015-present, Facebook, Inc.
+	*
+	* This source code is licensed under the MIT license found in the
+	* LICENSE file at
+	* https://github.com/facebookincubator/create-react-app/blob/master/LICENSE
+	*
+	* Modified by Yuxi Evan You
+	*/
+	const fs$6 = __require("fs");
+	const os$2 = __require("os");
+	const path$7 = __require("path");
+	const colors = require_picocolors();
+	const childProcess$1 = __require("child_process");
+	const guessEditor = require_guess();
+	const getArgumentsForPosition = require_get_args();
+	function wrapErrorCallback(cb) {
+		return (fileName, errorMessage) => {
+			console.log();
+			console.log(colors.red("Could not open " + path$7.basename(fileName) + " in the editor."));
+			if (errorMessage) {
+				if (errorMessage[errorMessage.length - 1] !== ".") errorMessage += ".";
+				console.log(colors.red("The editor process exited with an error: " + errorMessage));
+			}
+			console.log();
+			if (cb) cb(fileName, errorMessage);
+		};
+	}
+	function isTerminalEditor(editor) {
+		switch (editor) {
+			case "vim":
+			case "emacs":
+			case "nano": return true;
+		}
+		return false;
+	}
+	const positionRE = /:(\d+)(:(\d+))?$/;
+	function parseFile(file) {
+		if (file.startsWith("file://")) file = __require("url").fileURLToPath(file);
+		const fileName = file.replace(positionRE, "");
+		const match = file.match(positionRE);
+		return {
+			fileName,
+			lineNumber: match && match[1],
+			columnNumber: match && match[3]
+		};
+	}
+	let _childProcess = null;
+	function launchEditor(file, specifiedEditor, onErrorCallback) {
+		const parsed = parseFile(file);
+		let { fileName } = parsed;
+		const { lineNumber, columnNumber } = parsed;
+		if (!fs$6.existsSync(fileName)) return;
+		if (typeof specifiedEditor === "function") {
+			onErrorCallback = specifiedEditor;
+			specifiedEditor = void 0;
+		}
+		onErrorCallback = wrapErrorCallback(onErrorCallback);
+		const [editor, ...args] = guessEditor(specifiedEditor);
+		if (!editor) {
+			onErrorCallback(fileName, null);
+			return;
+		}
+		if (process.platform === "linux" && fileName.startsWith("/mnt/") && /Microsoft/i.test(os$2.release())) fileName = path$7.relative("", fileName);
+		if (lineNumber) {
+			const extraArgs = getArgumentsForPosition(editor, fileName, lineNumber, columnNumber);
+			args.push.apply(args, extraArgs);
+		} else args.push(fileName);
+		if (_childProcess && isTerminalEditor(editor)) _childProcess.kill("SIGKILL");
+		if (process.platform === "win32") {
+			function escapeCmdArgs(cmdArgs) {
+				return cmdArgs.replace(/([&|<>,;=^])/g, "^$1");
+			}
+			function doubleQuoteIfNeeded(str) {
+				if (str.includes("^")) return `^"${str}^"`;
+				else if (str.includes(" ")) return `"${str}"`;
+				return str;
+			}
+			const launchCommand = [editor, ...args.map(escapeCmdArgs)].map(doubleQuoteIfNeeded).join(" ");
+			_childProcess = childProcess$1.exec(launchCommand, {
+				stdio: "inherit",
+				shell: true
+			});
+		} else _childProcess = childProcess$1.spawn(editor, args, { stdio: "inherit" });
+		_childProcess.on("exit", function(errorCode) {
+			_childProcess = null;
+			if (errorCode) onErrorCallback(fileName, "(code " + errorCode + ")");
+		});
+		_childProcess.on("error", function(error) {
+			let { code, message } = error;
+			if ("ENOENT" === code) message = `${message} ('${editor}' command does not exist in 'PATH')`;
+			onErrorCallback(fileName, message);
+		});
+	}
+	module.exports = launchEditor;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/launch-editor-middleware@2.13.2/node_modules/launch-editor-middleware/index.js
+var require_launch_editor_middleware = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$6 = __require("path");
+	const launch = require_launch_editor();
+	module.exports = (specifiedEditor, srcRoot, onErrorCallback) => {
+		if (typeof specifiedEditor === "function") {
+			onErrorCallback = specifiedEditor;
+			specifiedEditor = void 0;
+		}
+		if (typeof srcRoot === "function") {
+			onErrorCallback = srcRoot;
+			srcRoot = void 0;
+		}
+		srcRoot = srcRoot || process.cwd();
+		return function launchEditorMiddleware(req, res) {
+			let url;
+			try {
+				const fullUrl = req.url.startsWith("http") ? req.url : `http://localhost${req.url}`;
+				url = new URL(fullUrl);
+			} catch (_err) {
+				res.statusCode = 500;
+				res.end(`launch-editor-middleware: invalid URL.`);
+				return;
+			}
+			const file = url.searchParams.get("file");
+			if (!file) {
+				res.statusCode = 500;
+				res.end(`launch-editor-middleware: required query param "file" is missing.`);
+			} else {
+				launch(file.startsWith("file://") ? file : path$6.resolve(srcRoot, file), specifiedEditor, onErrorCallback);
+				res.end();
+			}
+		};
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@vercel+detect-agent@1.2.3/node_modules/@vercel/detect-agent/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __export = (target, all) => {
+		for (var name in all) __defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	};
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: () => from[key],
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var src_exports = {};
+	__export(src_exports, {
+		KNOWN_AGENTS: () => KNOWN_AGENTS,
+		determineAgent: () => determineAgent
+	});
+	module.exports = __toCommonJS(src_exports);
+	var import_promises = __require("node:fs/promises");
+	var import_node_fs = __require("node:fs");
+	const DEVIN_LOCAL_PATH = "/opt/.devin";
+	const CURSOR = "cursor";
+	const CURSOR_CLI = "cursor-cli";
+	const CLAUDE = "claude";
+	const COWORK = "cowork";
+	const DEVIN = "devin";
+	const REPLIT = "replit";
+	const GEMINI = "gemini";
+	const CODEX = "codex";
+	const ANTIGRAVITY = "antigravity";
+	const AUGMENT_CLI = "augment-cli";
+	const OPENCODE = "opencode";
+	const GITHUB_COPILOT = "github-copilot";
+	const GITHUB_COPILOT_CLI = "github-copilot-cli";
+	const V0 = "v0";
+	const KNOWN_AGENTS = {
+		CURSOR,
+		CURSOR_CLI,
+		CLAUDE,
+		COWORK,
+		DEVIN,
+		REPLIT,
+		GEMINI,
+		CODEX,
+		ANTIGRAVITY,
+		AUGMENT_CLI,
+		OPENCODE,
+		GITHUB_COPILOT,
+		V0
+	};
+	async function determineAgent() {
+		if (process.env.AI_AGENT) {
+			const name = process.env.AI_AGENT.trim();
+			if (name) {
+				if (name === GITHUB_COPILOT || name === GITHUB_COPILOT_CLI) return {
+					isAgent: true,
+					agent: { name: GITHUB_COPILOT }
+				};
+				if (name === V0) return {
+					isAgent: true,
+					agent: { name: V0 }
+				};
+				return {
+					isAgent: true,
+					agent: { name }
+				};
+			}
+		}
+		if (process.env.CURSOR_TRACE_ID) return {
+			isAgent: true,
+			agent: { name: CURSOR }
+		};
+		if (process.env.CURSOR_AGENT || process.env.CURSOR_EXTENSION_HOST_ROLE === "agent-exec") return {
+			isAgent: true,
+			agent: { name: CURSOR_CLI }
+		};
+		if (process.env.GEMINI_CLI) return {
+			isAgent: true,
+			agent: { name: GEMINI }
+		};
+		if (process.env.CODEX_SANDBOX || process.env.CODEX_CI || process.env.CODEX_THREAD_ID) return {
+			isAgent: true,
+			agent: { name: CODEX }
+		};
+		if (process.env.ANTIGRAVITY_AGENT) return {
+			isAgent: true,
+			agent: { name: ANTIGRAVITY }
+		};
+		if (process.env.AUGMENT_AGENT) return {
+			isAgent: true,
+			agent: { name: AUGMENT_CLI }
+		};
+		if (process.env.OPENCODE_CLIENT) return {
+			isAgent: true,
+			agent: { name: OPENCODE }
+		};
+		if (process.env.CLAUDECODE || process.env.CLAUDE_CODE) {
+			if (process.env.CLAUDE_CODE_IS_COWORK) return {
+				isAgent: true,
+				agent: { name: COWORK }
+			};
+			return {
+				isAgent: true,
+				agent: { name: CLAUDE }
+			};
+		}
+		if (process.env.REPL_ID) return {
+			isAgent: true,
+			agent: { name: REPLIT }
+		};
+		if (process.env.COPILOT_MODEL || process.env.COPILOT_ALLOW_ALL || process.env.COPILOT_GITHUB_TOKEN) return {
+			isAgent: true,
+			agent: { name: GITHUB_COPILOT }
+		};
+		try {
+			await (0, import_promises.access)(DEVIN_LOCAL_PATH, import_node_fs.constants.F_OK);
+			return {
+				isAgent: true,
+				agent: { name: DEVIN }
+			};
+		} catch (_error) {}
+		return {
+			isAgent: false,
+			agent: void 0
+		};
+	}
+}));
+//#endregion
+//#region src/node/http.ts
+async function resolveHttpServer(app, httpsOptions) {
+	if (!httpsOptions) {
+		const { createServer } = await import("node:http");
+		return createServer(app);
+	}
+	const { createSecureServer } = await import("node:http2");
+	return createSecureServer({
+		maxSessionMemory: 1e3,
+		streamResetBurst: 1e5,
+		streamResetRate: 33,
+		...httpsOptions,
+		allowHTTP1: true
+	}, app);
+}
+async function resolveHttpsConfig(https) {
+	if (!https) return void 0;
+	const [ca, cert, key, pfx] = await Promise.all([
+		readFileIfExists(https.ca),
+		readFileIfExists(https.cert),
+		readFileIfExists(https.key),
+		readFileIfExists(https.pfx)
+	]);
+	return {
+		...https,
+		ca,
+		cert,
+		key,
+		pfx
+	};
+}
+async function readFileIfExists(value) {
+	if (typeof value === "string") return fsp.readFile(path.resolve(value)).catch(() => value);
+	return value;
+}
+async function isPortAvailable(port) {
+	for (const host of wildcardHosts) if (!await tryListen(port, host).catch(() => true)) return false;
+	return true;
+}
+function tryListen(port, host) {
+	return new Promise((resolve) => {
+		const server = net.createServer();
+		server.once("error", (e) => {
+			server.close(() => resolve(e.code !== "EADDRINUSE"));
+		});
+		server.once("listening", () => {
+			server.close(() => resolve(true));
+		});
+		server.listen(port, host);
+	});
+}
+async function tryBindServer(httpServer, port, host) {
+	return new Promise((resolve) => {
+		const onError = (e) => {
+			httpServer.off("error", onError);
+			httpServer.off("listening", onListening);
+			resolve({
+				success: false,
+				error: e
+			});
+		};
+		const onListening = () => {
+			httpServer.off("error", onError);
+			httpServer.off("listening", onListening);
+			resolve({ success: true });
+		};
+		httpServer.on("error", onError);
+		httpServer.on("listening", onListening);
+		httpServer.listen(port, host);
+	});
+}
+const MAX_PORT = 65535;
+async function httpServerStart(httpServer, serverOptions) {
+	const { port: startPort, strictPort, host, logger } = serverOptions;
+	for (let port = startPort; port <= MAX_PORT; port++) {
+		const portAvailableOnWildcard = await isPortAvailable(port);
+		if (strictPort) {
+			const result = await tryBindServer(httpServer, port, host);
+			if (result.success) {
+				if (!portAvailableOnWildcard) logger.warn(import_picocolors.default.yellow(`Port ${port} is in use on a wildcard address, but ${host ?? "localhost"}:${port} is available. There may be another server running on a wildcard IP on port ${port}.`));
+				return port;
+			}
+			if (result.error.code !== "EADDRINUSE") throw result.error;
+			throw new Error(`Port ${port} is already in use`);
+		}
+		if (portAvailableOnWildcard) {
+			const result = await tryBindServer(httpServer, port, host);
+			if (result.success) return port;
+			if (result.error.code !== "EADDRINUSE") throw result.error;
+		}
+		logger.info(`Port ${port} is in use, trying another one...`);
+	}
+	throw new Error(`No available ports found between ${startPort} and ${MAX_PORT}`);
+}
+function setClientErrorHandler(server, logger) {
+	server.on("clientError", (err, socket) => {
+		let msg = "400 Bad Request";
+		if (err.code === "HPE_HEADER_OVERFLOW") {
+			msg = "431 Request Header Fields Too Large";
+			logger.warn(import_picocolors.default.yellow("Server responded with status code 431. See https://vite.dev/guide/troubleshooting.html#_431-request-header-fields-too-large."));
+		}
+		if (err.code === "ECONNRESET" || !socket.writable) return;
+		socket.end(`HTTP/1.1 ${msg}\r\n\r\n`);
+	});
+}
+//#endregion
+//#region src/node/ssr/ssrStacktrace.ts
+let offset;
+function calculateOffsetOnce() {
+	if (offset !== void 0) return;
+	try {
+		new Function("throw new Error(1)")();
+	} catch (e) {
+		const match = /:(\d+):\d+\)$/.exec(e.stack.split("\n")[1]);
+		offset = match ? +match[1] - 1 : 0;
+	}
+}
+function ssrRewriteStacktrace(stack, moduleGraph) {
+	calculateOffsetOnce();
+	let alreadyRewritten = false;
+	return {
+		result: stack.split("\n").map((line) => {
+			return line.replace(/^ {4}at (?:(\S.*?)\s\()?(.+?):(\d+)(?::(\d+))?\)?/, (input, varName, id, originalLine, originalColumn) => {
+				if (!id) return input;
+				const rawSourceMap = moduleGraph.getModuleById(id)?.transformResult?.map;
+				if (!rawSourceMap) return input;
+				const traced = new TraceMap(rawSourceMap);
+				const line = Number(originalLine) - offset;
+				const column = Number(originalColumn) - 1;
+				if (line <= 0 || column < 0) {
+					alreadyRewritten = true;
+					return input;
+				}
+				const pos = originalPositionFor$2(traced, {
+					line,
+					column
+				});
+				if (!pos.source) return input;
+				const trimmedVarName = varName?.trim();
+				const source = `${path.resolve(path.dirname(id), pos.source)}:${pos.line}:${pos.column + 1}`;
+				if (!trimmedVarName || trimmedVarName === "eval") return `    at ${source}`;
+				else return `    at ${trimmedVarName} (${source})`;
+			});
+		}).join("\n"),
+		alreadyRewritten
+	};
+}
+function rebindErrorStacktrace(e, stacktrace) {
+	const { configurable, writable } = Object.getOwnPropertyDescriptor(e, "stack");
+	if (configurable) Object.defineProperty(e, "stack", {
+		value: stacktrace,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else if (writable) e.stack = stacktrace;
+}
+const rewroteStacktraces = /* @__PURE__ */ new WeakSet();
+function ssrFixStacktrace(e, moduleGraph) {
+	if (!e.stack) return;
+	if (rewroteStacktraces.has(e)) return;
+	const { result: stacktrace, alreadyRewritten } = ssrRewriteStacktrace(e.stack, moduleGraph);
+	rebindErrorStacktrace(e, stacktrace);
+	if (alreadyRewritten) e.message += " (The stacktrace appears to be already rewritten by something else, but was passed to vite.ssrFixStacktrace. This may cause incorrect stacktraces.)";
+	rewroteStacktraces.add(e);
+}
+//#endregion
+//#region src/node/ssr/runtime/serverModuleRunner.ts
+function createHMROptions(environment, options) {
+	if (environment.config.server.hmr === false || options.hmr === false) return false;
+	if (!("api" in environment.hot)) return false;
+	return { logger: options.hmr?.logger ?? {
+		debug: (...msg) => environment.logger.info(msg.join(" "), { timestamp: true }),
+		error: (err) => environment.logger.error(err instanceof Error ? err.message : String(err), { timestamp: true })
+	} };
+}
+const prepareStackTrace = { retrieveFile(id) {
+	if (existsSync(id)) return readFileSync(id, "utf-8");
+} };
+function resolveSourceMapOptions(options) {
+	if (options.sourcemapInterceptor != null) {
+		if (options.sourcemapInterceptor === "prepareStackTrace") return prepareStackTrace;
+		if (typeof options.sourcemapInterceptor === "object") return {
+			...prepareStackTrace,
+			...options.sourcemapInterceptor
+		};
+		return options.sourcemapInterceptor;
+	}
+	if (typeof process !== "undefined" && "setSourceMapsEnabled" in process) return "node";
+	return prepareStackTrace;
+}
+const createServerModuleRunnerTransport = (options) => {
+	const hmrClient = { send: (payload) => {
+		if (payload.type !== "custom") throw new Error("Cannot send non-custom events from the client to the server.");
+		options.channel.send(payload);
+	} };
+	let handler;
+	return {
+		connect({ onMessage }) {
+			options.channel.api.outsideEmitter.on("send", onMessage);
+			options.channel.api.innerEmitter.emit("vite:client:connect", void 0, hmrClient);
+			onMessage({ type: "connected" });
+			handler = onMessage;
+		},
+		disconnect() {
+			if (handler) options.channel.api.outsideEmitter.off("send", handler);
+			options.channel.api.innerEmitter.emit("vite:client:disconnect", void 0, hmrClient);
+		},
+		send(payload) {
+			if (payload.type !== "custom") throw new Error("Cannot send non-custom events from the server to the client.");
+			options.channel.api.innerEmitter.emit(payload.event, payload.data, hmrClient);
+		}
+	};
+};
+/**
+* Create an instance of the Vite SSR runtime that support HMR.
+* @experimental
+*/
+function createServerModuleRunner(environment, options = {}) {
+	const hmr = createHMROptions(environment, options);
+	return new ModuleRunner({
+		...options,
+		transport: createServerModuleRunnerTransport({ channel: environment.hot }),
+		hmr,
+		createImportMeta: createNodeImportMeta,
+		sourcemapInterceptor: resolveSourceMapOptions(options)
+	}, options.evaluator);
+}
+//#endregion
+//#region src/node/ssr/ssrModuleLoader.ts
+async function ssrLoadModule(url, server, fixStacktrace) {
+	const environment = server.environments.ssr;
+	if (!isRunnableDevEnvironment(environment)) throw new Error(`ssrLoadModule requires the 'ssr' environment to be a runnable environment.`);
+	server._ssrCompatModuleRunner ||= new SSRCompatModuleRunner(environment);
+	url = unwrapId(url);
+	return instantiateModule(url, server._ssrCompatModuleRunner, environment, fixStacktrace);
+}
+async function instantiateModule(url, runner, environment, fixStacktrace) {
+	const mod = await environment.moduleGraph.ensureEntryFromUrl(url);
+	if (mod.ssrError) throw mod.ssrError;
+	try {
+		return await runner.import(url);
+	} catch (e) {
+		if (e.stack && fixStacktrace) ssrFixStacktrace(e, environment.moduleGraph);
+		environment.logger.error(buildErrorMessage(e, [import_picocolors.default.red(`Error when evaluating SSR module ${url}: ${e.message}`)]), {
+			timestamp: true,
+			clear: environment.config.clearScreen,
+			error: e
+		});
+		throw e;
+	}
+}
+var SSRCompatModuleRunner = class extends ModuleRunner {
+	environment;
+	constructor(environment) {
+		super({
+			transport: createServerModuleRunnerTransport({ channel: environment.hot }),
+			createImportMeta: createNodeImportMeta,
+			sourcemapInterceptor: false,
+			hmr: false
+		}, new ESModulesEvaluator());
+		this.environment = environment;
+	}
+	async directRequest(url, mod, callstack) {
+		const id = mod.meta && "id" in mod.meta && mod.meta.id;
+		if (!id) return super.directRequest(url, mod, callstack);
+		const viteMod = this.environment.moduleGraph.getModuleById(id);
+		if (!viteMod) return super.directRequest(id, mod, callstack);
+		try {
+			const exports = await super.directRequest(id, mod, callstack);
+			viteMod.ssrModule = exports;
+			return exports;
+		} catch (err) {
+			viteMod.ssrError = err;
+			throw err;
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/periscopic@4.0.3/node_modules/periscopic/src/index.js
+/**
+* @param {import('estree').Node} param
+* @returns {string[]}
+*/
+function extract_names(param) {
+	return extract_identifiers(param).map((node) => node.name);
+}
+/**
+* @param {import('estree').Node} param
+* @param {import('estree').Identifier[]} nodes
+* @returns {import('estree').Identifier[]}
+*/
+function extract_identifiers(param, nodes = []) {
+	switch (param.type) {
+		case "Identifier":
+			nodes.push(param);
+			break;
+		case "MemberExpression":
+			let object = param;
+			while (object.type === "MemberExpression") object = object.object;
+			nodes.push(object);
+			break;
+		case "ObjectPattern":
+			for (const prop of param.properties) if (prop.type === "RestElement") extract_identifiers(prop.argument, nodes);
+			else extract_identifiers(prop.value, nodes);
+			break;
+		case "ArrayPattern":
+			for (const element of param.elements) if (element) extract_identifiers(element, nodes);
+			break;
+		case "RestElement":
+			extract_identifiers(param.argument, nodes);
+			break;
+		case "AssignmentPattern":
+			extract_identifiers(param.left, nodes);
+			break;
+	}
+	return nodes;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef {{
+*   skip: () => void;
+*   remove: () => void;
+*   replace: (node: Node) => void;
+* }} WalkerContext
+*/
+var WalkerBase = class {
+	constructor() {
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	* @param {Node} node
+	*/
+	replace(parent, prop, index, node) {
+		if (parent && prop) if (index != null)
+ /** @type {Array<Node>} */ parent[prop][index] = node;
+		else
+ /** @type {Node} */ parent[prop] = node;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	*/
+	remove(parent, prop, index) {
+		if (parent && prop) if (index !== null && index !== void 0)
+ /** @type {Array<Node>} */ parent[prop].splice(index, 1);
+		else delete parent[prop];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef { import('./walker.js').WalkerContext} WalkerContext
+* @typedef {(
+*    this: WalkerContext,
+*    node: Node,
+*    parent: Node | null,
+*    key: string | number | symbol | null | undefined,
+*    index: number | null | undefined
+* ) => void} SyncHandler
+*/
+var SyncWalker = class extends WalkerBase {
+	/**
+	*
+	* @param {SyncHandler} [enter]
+	* @param {SyncHandler} [leave]
+	*/
+	constructor(enter, leave) {
+		super();
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+		/** @type {SyncHandler | undefined} */
+		this.enter = enter;
+		/** @type {SyncHandler | undefined} */
+		this.leave = leave;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Node} node
+	* @param {Parent | null} parent
+	* @param {keyof Parent} [prop]
+	* @param {number | null} [index]
+	* @returns {Node | null}
+	*/
+	visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+				this.enter.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+				if (skipped) return node;
+				if (removed) return null;
+			}
+			/** @type {keyof Node} */
+			let key;
+			for (key in node) {
+				/** @type {unknown} */
+				const value = node[key];
+				if (value && typeof value === "object") {
+					if (Array.isArray(value)) {
+						const nodes = value;
+						for (let i = 0; i < nodes.length; i += 1) {
+							const item = nodes[i];
+							if (isNode(item)) {
+								if (!this.visit(item, node, key, i)) i--;
+							}
+						}
+					} else if (isNode(value)) this.visit(value, node, key, null);
+				}
+			}
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+				this.leave.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const removed = this.should_remove;
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+				if (removed) return null;
+			}
+		}
+		return node;
+	}
+};
+/**
+* Ducktype a node.
+*
+* @param {unknown} value
+* @returns {value is Node}
+*/
+function isNode(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js
+/**
+* @typedef {import('estree').Node} Node
+* @typedef {import('./sync.js').SyncHandler} SyncHandler
+* @typedef {import('./async.js').AsyncHandler} AsyncHandler
+*/
+/**
+* @param {Node} ast
+* @param {{
+*   enter?: SyncHandler
+*   leave?: SyncHandler
+* }} walker
+* @returns {Node | null}
+*/
+function walk$1(ast, { enter, leave }) {
+	return new SyncWalker(enter, leave).visit(ast, null);
+}
+//#endregion
+//#region src/node/plugins/json.ts
+const jsonLangRE = new RegExp(`\\.(?:json|json5)(?:$|\\?)`);
+const isJSONRequest = (request) => jsonLangRE.test(request);
+//#endregion
+//#region src/node/ssr/ssrTransform.ts
+const ssrModuleExportsKey = `__vite_ssr_exports__`;
+const ssrImportKey = `__vite_ssr_import__`;
+const ssrDynamicImportKey = `__vite_ssr_dynamic_import__`;
+const ssrExportAllKey = `__vite_ssr_exportAll__`;
+const ssrExportNameKey = `__vite_ssr_exportName__`;
+const ssrImportMetaKey = `__vite_ssr_import_meta__`;
+async function ssrTransform(code, inMap, url, originalCode, options) {
+	if (options?.json?.stringify && isJSONRequest(url)) return ssrTransformJSON(code, inMap);
+	return ssrTransformScript(code, inMap, url, originalCode);
+}
+function ssrTransformJSON(code, inMap) {
+	return {
+		code: code.replace("export default", `${ssrModuleExportsKey}.default =`),
+		map: inMap,
+		deps: [],
+		dynamicDeps: [],
+		ssr: true
+	};
+}
+async function ssrTransformScript(code, inMap, url, originalCode) {
+	const s = new MagicString(code);
+	let ast;
+	try {
+		ast = await parseAstAsync(code);
+	} catch (err) {
+		if (err.code === "PARSE_ERROR") {
+			err.message = `Parse failure: ${err.message}\n`;
+			err.id = url;
+			if (typeof err.pos === "number") {
+				err.loc = numberToPos(code, err.pos);
+				err.loc.file = url;
+				err.frame = generateCodeFrame(code, err.pos);
+				err.message += `At file: ${url}:${err.loc.line}:${err.loc.column}`;
+			} else err.message += `At file: ${url}`;
+		}
+		throw err;
+	}
+	let uid = 0;
+	const deps = /* @__PURE__ */ new Set();
+	const dynamicDeps = /* @__PURE__ */ new Set();
+	const idToImportMap = /* @__PURE__ */ new Map();
+	const declaredConst = /* @__PURE__ */ new Set();
+	const fileStartIndex = getFileStartIndex(code);
+	let hoistIndex = fileStartIndex;
+	function defineImport(index, importNode, metadata) {
+		const source = importNode.source.value;
+		deps.add(source);
+		const metadataArg = (metadata?.importedNames?.length ?? 0) > 0 ? `, ${JSON.stringify(metadata)}` : "";
+		const importId = `__vite_ssr_import_${uid++}__`;
+		const transformedImport = `const ${importId} = await ${ssrImportKey}(${JSON.stringify(source)}${metadataArg});\n`;
+		s.update(importNode.start, importNode.end, transformedImport);
+		if (importNode.start === index) hoistIndex = importNode.end;
+		else s.move(importNode.start, importNode.end, index);
+		return importId;
+	}
+	function defineExport(name, local = name) {
+		s.appendLeft(fileStartIndex, `${ssrExportNameKey}(${JSON.stringify(name)}, () => { try { return ${local} } catch {} });\n`);
+	}
+	const imports = [];
+	const exports = [];
+	const reExportImportIdMap = /* @__PURE__ */ new Map();
+	for (const node of ast.body) if (node.type === "ImportDeclaration") imports.push(node);
+	else if (node.type === "ExportDefaultDeclaration") exports.push(node);
+	else if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
+		imports.push(node);
+		exports.push(node);
+	}
+	for (const node of imports) {
+		if (node.type === "ExportNamedDeclaration") {
+			if (node.source) {
+				const importId = defineImport(hoistIndex, node, { importedNames: node.specifiers.map((s) => getIdentifierNameOrLiteralValue$1(s.local)) });
+				reExportImportIdMap.set(node, importId);
+			}
+			continue;
+		}
+		if (node.type === "ExportAllDeclaration") {
+			if (node.source) {
+				const importId = defineImport(hoistIndex, node);
+				reExportImportIdMap.set(node, importId);
+			}
+			continue;
+		}
+		const importId = defineImport(hoistIndex, node, { importedNames: node.specifiers.map((s) => {
+			if (s.type === "ImportSpecifier") return getIdentifierNameOrLiteralValue$1(s.imported);
+			else if (s.type === "ImportDefaultSpecifier") return "default";
+		}).filter(isDefined) });
+		for (const spec of node.specifiers) if (spec.type === "ImportSpecifier") if (spec.imported.type === "Identifier") idToImportMap.set(spec.local.name, `${importId}.${spec.imported.name}`);
+		else idToImportMap.set(spec.local.name, `${importId}[${JSON.stringify(spec.imported.value)}]`);
+		else if (spec.type === "ImportDefaultSpecifier") idToImportMap.set(spec.local.name, `${importId}.default`);
+		else idToImportMap.set(spec.local.name, importId);
+	}
+	for (const node of exports) {
+		if (node.type === "ExportNamedDeclaration") if (node.declaration) {
+			if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") defineExport(node.declaration.id.name);
+			else {
+				const declaration = node.declaration;
+				for (const decl of declaration.declarations) {
+					const names = extract_names(decl.id);
+					for (const name of names) defineExport(name);
+				}
+			}
+			s.remove(node.start, node.declaration.start);
+		} else if (node.source) {
+			const importId = reExportImportIdMap.get(node);
+			for (const spec of node.specifiers) {
+				const exportedAs = getIdentifierNameOrLiteralValue$1(spec.exported);
+				if (spec.local.type === "Identifier") defineExport(exportedAs, `${importId}.${spec.local.name}`);
+				else defineExport(exportedAs, `${importId}[${JSON.stringify(spec.local.value)}]`);
+			}
+		} else {
+			s.remove(node.start, node.end);
+			for (const spec of node.specifiers) {
+				const local = spec.local.name;
+				const binding = idToImportMap.get(local);
+				defineExport(getIdentifierNameOrLiteralValue$1(spec.exported), binding || local);
+			}
+		}
+		if (node.type === "ExportDefaultDeclaration") if ("id" in node.declaration && node.declaration.id && !["FunctionExpression", "ClassExpression"].includes(node.declaration.type)) {
+			const { name } = node.declaration.id;
+			s.remove(node.start, node.start + 15);
+			defineExport("default", name);
+		} else {
+			const name = `__vite_ssr_export_default__`;
+			s.update(node.start, node.start + 14, `const ${name} =`);
+			defineExport("default", name);
+		}
+		if (node.type === "ExportAllDeclaration") {
+			const importId = reExportImportIdMap.get(node);
+			if (node.exported) defineExport(getIdentifierNameOrLiteralValue$1(node.exported), `${importId}`);
+			else s.appendLeft(node.end, `${ssrExportAllKey}(${importId});\n`);
+		}
+	}
+	walk(ast, {
+		onStatements(statements) {
+			for (let i = 0; i < statements.length - 1; i++) {
+				const stmt = statements[i];
+				if (code[stmt.end - 1] !== ";" && stmt.type !== "FunctionDeclaration" && stmt.type !== "ClassDeclaration" && stmt.type !== "BlockStatement" && stmt.type !== "ImportDeclaration") s.appendLeft(stmt.end, ";");
+			}
+		},
+		onIdentifier(id, parent, parentStack) {
+			const binding = idToImportMap.get(id.name);
+			if (!binding) return;
+			if (isStaticProperty(parent) && parent.shorthand) {
+				if (!isNodeInPattern(parent) || isInDestructuringAssignment(parent, parentStack)) s.appendLeft(id.end, `: ${binding}`);
+			} else if (parent.type === "ClassDeclaration" && id === parent.superClass) {
+				if (!declaredConst.has(id.name)) {
+					declaredConst.add(id.name);
+					const topNode = parentStack[parentStack.length - 2];
+					s.prependRight(topNode.start, `const ${id.name} = ${binding};\n`);
+				}
+			} else if (parent.type === "CallExpression") {
+				s.update(id.start, id.end, binding);
+				s.prependRight(id.start, `(0,`);
+				s.appendLeft(id.end, `)`);
+			} else if (!(parent.type === "ClassExpression" && id === parent.id)) s.update(id.start, id.end, binding);
+		},
+		onImportMeta(node) {
+			s.update(node.start, node.end, ssrImportMetaKey);
+		},
+		onDynamicImport(node) {
+			s.update(node.start, node.start + 6, ssrDynamicImportKey);
+			if (node.type === "ImportExpression" && node.source.type === "Literal") dynamicDeps.add(node.source.value);
+		}
+	});
+	let map;
+	if (inMap?.mappings === "") map = inMap;
+	else {
+		map = s.generateMap({ hires: "boundary" });
+		map.sources = [path.basename(url)];
+		map.sourcesContent = [originalCode];
+		if (inMap && inMap.mappings && "sources" in inMap && inMap.sources.length > 0) map = combineSourcemaps(url, [map, inMap]);
+	}
+	return {
+		code: s.toString(),
+		map,
+		ssr: true,
+		deps: [...deps],
+		dynamicDeps: [...dynamicDeps]
+	};
+}
+function getIdentifierNameOrLiteralValue$1(node) {
+	return node.type === "Identifier" ? node.name : node.value;
+}
+const isNodeInPatternWeakSet = /* @__PURE__ */ new WeakSet();
+const setIsNodeInPattern = (node) => isNodeInPatternWeakSet.add(node);
+const isNodeInPattern = (node) => isNodeInPatternWeakSet.has(node);
+/**
+* Same logic from \@vue/compiler-core & \@vue/compiler-sfc
+* Except this is using acorn AST
+*/
+function walk(root, { onIdentifier, onImportMeta, onDynamicImport, onStatements }) {
+	const parentStack = [];
+	const varKindStack = [];
+	const scopeMap = /* @__PURE__ */ new WeakMap();
+	const identifiers = [];
+	const setScope = (node, name) => {
+		let scopeIds = scopeMap.get(node);
+		if (scopeIds && scopeIds.has(name)) return;
+		if (!scopeIds) {
+			scopeIds = /* @__PURE__ */ new Set();
+			scopeMap.set(node, scopeIds);
+		}
+		scopeIds.add(name);
+	};
+	function isInScope(name, parents) {
+		return parents.some((node) => scopeMap.get(node)?.has(name));
+	}
+	function handlePattern(p, parentScope) {
+		if (p.type === "Identifier") setScope(parentScope, p.name);
+		else if (p.type === "RestElement") handlePattern(p.argument, parentScope);
+		else if (p.type === "ObjectPattern") p.properties.forEach((property) => {
+			if (property.type === "RestElement") setScope(parentScope, property.argument.name);
+			else handlePattern(property.value, parentScope);
+		});
+		else if (p.type === "ArrayPattern") p.elements.forEach((element) => {
+			if (element) handlePattern(element, parentScope);
+		});
+		else if (p.type === "AssignmentPattern") handlePattern(p.left, parentScope);
+		else setScope(parentScope, p.name);
+	}
+	walk$1(root, {
+		enter(node, parent) {
+			if (node.type === "ImportDeclaration") return this.skip();
+			if (node.type === "Program" || node.type === "BlockStatement" || node.type === "StaticBlock") onStatements(node.body);
+			else if (node.type === "SwitchCase") onStatements(node.consequent);
+			if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) parentStack.unshift(parent);
+			if (node.type === "VariableDeclaration") varKindStack.unshift(node.kind);
+			if (node.type === "MetaProperty" && node.meta.name === "import") onImportMeta(node);
+			else if (node.type === "ImportExpression") onDynamicImport(node);
+			if (node.type === "Identifier") {
+				if (!isInScope(node.name, parentStack) && isRefIdentifier(node, parent, parentStack)) identifiers.push([node, parentStack.slice(0)]);
+			} else if (isFunction(node)) {
+				if (node.type === "FunctionDeclaration") {
+					const parentScope = findParentScope(parentStack);
+					if (parentScope) setScope(parentScope, node.id.name);
+				}
+				if (node.type === "FunctionExpression" && node.id) setScope(node, node.id.name);
+				node.params.forEach((p) => {
+					if (p.type === "ObjectPattern" || p.type === "ArrayPattern") {
+						handlePattern(p, node);
+						return;
+					}
+					walk$1(p.type === "AssignmentPattern" ? p.left : p, { enter(child, parent) {
+						if (parent?.type === "AssignmentPattern" && parent.right === child) return this.skip();
+						if (child.type !== "Identifier") return;
+						if (isStaticPropertyKey(child, parent)) return;
+						if (parent?.type === "TemplateLiteral" && parent.expressions.includes(child) || parent?.type === "CallExpression" && parent.callee === child) return;
+						setScope(node, child.name);
+					} });
+				});
+			} else if (node.type === "ClassDeclaration") {
+				const parentScope = findParentScope(parentStack);
+				if (parentScope) setScope(parentScope, node.id.name);
+			} else if (node.type === "ClassExpression" && node.id) setScope(node, node.id.name);
+			else if (node.type === "Property" && parent.type === "ObjectPattern") setIsNodeInPattern(node);
+			else if (node.type === "VariableDeclarator") {
+				const parentFunction = findParentScope(parentStack, varKindStack[0] === "var");
+				if (parentFunction) handlePattern(node.id, parentFunction);
+			} else if (node.type === "CatchClause" && node.param) handlePattern(node.param, node);
+		},
+		leave(node, parent) {
+			if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) parentStack.shift();
+			if (node.type === "VariableDeclaration") varKindStack.shift();
+		}
+	});
+	identifiers.forEach(([node, stack]) => {
+		if (!isInScope(node.name, stack)) onIdentifier(node, stack[0], stack);
+	});
+}
+function isRefIdentifier(id, parent, parentStack) {
+	if (parent.type === "CatchClause" || (parent.type === "VariableDeclarator" || parent.type === "ClassDeclaration") && parent.id === id) return false;
+	if (isFunction(parent)) {
+		if (parent.id === id) return false;
+		if (parent.params.includes(id)) return false;
+	}
+	if (parent.type === "MethodDefinition" && !parent.computed) return false;
+	if (parent.type === "PropertyDefinition" && !parent.computed) return parent.value === id;
+	if (isStaticPropertyKey(id, parent)) return false;
+	if (isNodeInPattern(parent) && parent.value === id) return false;
+	if (parent.type === "ArrayPattern" && !isInDestructuringAssignment(parent, parentStack)) return false;
+	if (parent.type === "MemberExpression" && parent.property === id && !parent.computed) return false;
+	if ((parent.type === "LabeledStatement" || parent.type === "BreakStatement" || parent.type === "ContinueStatement") && parent.label === id) return false;
+	if (parent.type === "MetaProperty") return false;
+	if (parent.type === "ExportSpecifier" || parent.type === "ExportAllDeclaration") return false;
+	if (id.name === "arguments") return false;
+	return true;
+}
+const isStaticProperty = (node) => node.type === "Property" && !node.computed;
+const isStaticPropertyKey = (node, parent) => parent && isStaticProperty(parent) && parent.key === node;
+const functionNodeTypeRE = /Function(?:Expression|Declaration)$|Method$/;
+function isFunction(node) {
+	return functionNodeTypeRE.test(node.type);
+}
+const blockNodeTypeRE = /^BlockStatement$|^For(?:In|Of)?Statement$/;
+function isBlock(node) {
+	return blockNodeTypeRE.test(node.type);
+}
+function findParentScope(parentStack, isVar = false) {
+	return parentStack.find(isVar ? isFunction : isBlock);
+}
+function isInDestructuringAssignment(parent, parentStack) {
+	if (parent.type === "Property" || parent.type === "ArrayPattern") return parentStack.some((i) => i.type === "AssignmentExpression");
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
+let isDockerCached;
+function hasDockerEnv() {
+	try {
+		fs.statSync("/.dockerenv");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function hasDockerCGroup() {
+	try {
+		return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+	} catch {
+		return false;
+	}
+}
+function isDocker() {
+	if (isDockerCached === void 0) isDockerCached = hasDockerEnv() || hasDockerCGroup();
+	return isDockerCached;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+let cachedResult;
+const hasContainerEnv = () => {
+	try {
+		fs.statSync("/run/.containerenv");
+		return true;
+	} catch {
+		return false;
+	}
+};
+function isInsideContainer() {
+	if (cachedResult === void 0) cachedResult = hasContainerEnv() || isDocker();
+	return cachedResult;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js
+const isWsl = () => {
+	if (process$1.platform !== "linux") return false;
+	if (os.release().toLowerCase().includes("microsoft")) {
+		if (isInsideContainer()) return false;
+		return true;
+	}
+	try {
+		return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+	} catch {
+		return false;
+	}
+};
+var is_wsl_default = process$1.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+//#endregion
+//#region ../../node_modules/.pnpm/wsl-utils@0.1.0/node_modules/wsl-utils/index.js
+const wslDrivesMountPoint = (() => {
+	const defaultMountPoint = "/mnt/";
+	let mountPoint;
+	return async function() {
+		if (mountPoint) return mountPoint;
+		const configFilePath = "/etc/wsl.conf";
+		let isConfigFileExists = false;
+		try {
+			await fsp.access(configFilePath, constants.F_OK);
+			isConfigFileExists = true;
+		} catch {}
+		if (!isConfigFileExists) return defaultMountPoint;
+		const configContent = await fsp.readFile(configFilePath, { encoding: "utf8" });
+		const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+		if (!configMountPoint) return defaultMountPoint;
+		mountPoint = configMountPoint.groups.mountPoint.trim();
+		mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+		return mountPoint;
+	};
+})();
+const powerShellPathFromWsl = async () => {
+	return `${await wslDrivesMountPoint()}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+const powerShellPath = async () => {
+	if (is_wsl_default) return powerShellPathFromWsl();
+	return `${process$1.env.SYSTEMROOT || process$1.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+	const define = (value) => Object.defineProperty(object, propertyName, {
+		value,
+		enumerable: true,
+		writable: true
+	});
+	Object.defineProperty(object, propertyName, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const result = valueGetter();
+			define(result);
+			return result;
+		},
+		set(value) {
+			define(value);
+		}
+	});
+	return object;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/default-browser-id@5.0.1/node_modules/default-browser-id/index.js
+const execFileAsync$3 = promisify(execFile);
+async function defaultBrowserId() {
+	if (process$1.platform !== "darwin") throw new Error("macOS only");
+	const { stdout } = await execFileAsync$3("defaults", [
+		"read",
+		"com.apple.LaunchServices/com.apple.launchservices.secure",
+		"LSHandlers"
+	]);
+	const browserId = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout)?.groups.id ?? "com.apple.Safari";
+	if (browserId === "com.apple.safari") return "com.apple.Safari";
+	return browserId;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js
+const execFileAsync$2 = promisify(execFile);
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+	if (process$1.platform !== "darwin") throw new Error("macOS only");
+	const outputArguments = humanReadableOutput ? [] : ["-ss"];
+	const execOptions = {};
+	if (signal) execOptions.signal = signal;
+	const { stdout } = await execFileAsync$2("osascript", [
+		"-e",
+		script,
+		outputArguments
+	], execOptions);
+	return stdout.trim();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bundle-name@4.1.0/node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+	return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/windows.js
+const execFileAsync$1 = promisify(execFile);
+const windowsBrowserProgIds = {
+	MSEdgeHTM: {
+		name: "Edge",
+		id: "com.microsoft.edge"
+	},
+	MSEdgeBHTML: {
+		name: "Edge Beta",
+		id: "com.microsoft.edge.beta"
+	},
+	MSEdgeDHTML: {
+		name: "Edge Dev",
+		id: "com.microsoft.edge.dev"
+	},
+	AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {
+		name: "Edge",
+		id: "com.microsoft.edge.old"
+	},
+	ChromeHTML: {
+		name: "Chrome",
+		id: "com.google.chrome"
+	},
+	ChromeBHTML: {
+		name: "Chrome Beta",
+		id: "com.google.chrome.beta"
+	},
+	ChromeDHTML: {
+		name: "Chrome Dev",
+		id: "com.google.chrome.dev"
+	},
+	ChromiumHTM: {
+		name: "Chromium",
+		id: "org.chromium.Chromium"
+	},
+	BraveHTML: {
+		name: "Brave",
+		id: "com.brave.Browser"
+	},
+	BraveBHTML: {
+		name: "Brave Beta",
+		id: "com.brave.Browser.beta"
+	},
+	BraveDHTML: {
+		name: "Brave Dev",
+		id: "com.brave.Browser.dev"
+	},
+	BraveSSHTM: {
+		name: "Brave Nightly",
+		id: "com.brave.Browser.nightly"
+	},
+	FirefoxURL: {
+		name: "Firefox",
+		id: "org.mozilla.firefox"
+	},
+	OperaStable: {
+		name: "Opera",
+		id: "com.operasoftware.Opera"
+	},
+	VivaldiHTM: {
+		name: "Vivaldi",
+		id: "com.vivaldi.Vivaldi"
+	},
+	"IE.HTTP": {
+		name: "Internet Explorer",
+		id: "com.microsoft.ie"
+	}
+};
+new Map(Object.entries(windowsBrowserProgIds));
+var UnknownBrowserError = class extends Error {};
+async function defaultBrowser$1(_execFileAsync = execFileAsync$1) {
+	const { stdout } = await _execFileAsync("reg", [
+		"QUERY",
+		" HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+		"/v",
+		"ProgId"
+	]);
+	const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+	if (!match) throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+	const { id } = match.groups;
+	const dotIndex = id.lastIndexOf(".");
+	const hyphenIndex = id.lastIndexOf("-");
+	const baseIdByDot = dotIndex === -1 ? void 0 : id.slice(0, dotIndex);
+	const baseIdByHyphen = hyphenIndex === -1 ? void 0 : id.slice(0, hyphenIndex);
+	return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? {
+		name: id,
+		id
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/index.js
+const execFileAsync = promisify(execFile);
+const titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+async function defaultBrowser() {
+	if (process$1.platform === "darwin") {
+		const id = await defaultBrowserId();
+		return {
+			name: await bundleName(id),
+			id
+		};
+	}
+	if (process$1.platform === "linux") {
+		const { stdout } = await execFileAsync("xdg-mime", [
+			"query",
+			"default",
+			"x-scheme-handler/http"
+		]);
+		const id = stdout.trim();
+		return {
+			name: titleize(id.replace(/.desktop$/, "").replace("-", " ")),
+			id
+		};
+	}
+	if (process$1.platform === "win32") return defaultBrowser$1();
+	throw new Error("Only macOS, Linux, and Windows are supported");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/open@10.2.0/node_modules/open/index.js
+const execFile$1 = promisify(childProcess.execFile);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const localXdgOpenPath = path.join(__dirname, "xdg-open");
+const { platform, arch } = process$1;
+/**
+Get the default browser name in Windows from WSL.
+
+@returns {Promise<string>} Browser name.
+*/
+async function getWindowsDefaultBrowserFromWsl() {
+	const powershellPath = await powerShellPath();
+	const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+	const { stdout } = await execFile$1(powershellPath, [
+		"-NoProfile",
+		"-NonInteractive",
+		"-ExecutionPolicy",
+		"Bypass",
+		"-EncodedCommand",
+		Buffer$1.from(rawCommand, "utf16le").toString("base64")
+	], { encoding: "utf8" });
+	const progId = stdout.trim();
+	const browserMap = {
+		ChromeHTML: "com.google.chrome",
+		BraveHTML: "com.brave.Browser",
+		MSEdgeHTM: "com.microsoft.edge",
+		FirefoxURL: "org.mozilla.firefox"
+	};
+	return browserMap[progId] ? { id: browserMap[progId] } : {};
+}
+const pTryEach = async (array, mapper) => {
+	let latestError;
+	for (const item of array) try {
+		return await mapper(item);
+	} catch (error) {
+		latestError = error;
+	}
+	throw latestError;
+};
+const baseOpen = async (options) => {
+	options = {
+		wait: false,
+		background: false,
+		newInstance: false,
+		allowNonzeroExitCode: false,
+		...options
+	};
+	if (Array.isArray(options.app)) return pTryEach(options.app, (singleApp) => baseOpen({
+		...options,
+		app: singleApp
+	}));
+	let { name: app, arguments: appArguments = [] } = options.app ?? {};
+	appArguments = [...appArguments];
+	if (Array.isArray(app)) return pTryEach(app, (appName) => baseOpen({
+		...options,
+		app: {
+			name: appName,
+			arguments: appArguments
+		}
+	}));
+	if (app === "browser" || app === "browserPrivate") {
+		const ids = {
+			"com.google.chrome": "chrome",
+			"google-chrome.desktop": "chrome",
+			"com.brave.Browser": "brave",
+			"org.mozilla.firefox": "firefox",
+			"firefox.desktop": "firefox",
+			"com.microsoft.msedge": "edge",
+			"com.microsoft.edge": "edge",
+			"com.microsoft.edgemac": "edge",
+			"microsoft-edge.desktop": "edge"
+		};
+		const flags = {
+			chrome: "--incognito",
+			brave: "--incognito",
+			firefox: "--private-window",
+			edge: "--inPrivate"
+		};
+		const browser = is_wsl_default ? await getWindowsDefaultBrowserFromWsl() : await defaultBrowser();
+		if (browser.id in ids) {
+			const browserName = ids[browser.id];
+			if (app === "browserPrivate") appArguments.push(flags[browserName]);
+			return baseOpen({
+				...options,
+				app: {
+					name: apps[browserName],
+					arguments: appArguments
+				}
+			});
+		}
+		throw new Error(`${browser.name} is not supported as a default browser`);
+	}
+	let command;
+	const cliArguments = [];
+	const childProcessOptions = {};
+	if (platform === "darwin") {
+		command = "open";
+		if (options.wait) cliArguments.push("--wait-apps");
+		if (options.background) cliArguments.push("--background");
+		if (options.newInstance) cliArguments.push("--new");
+		if (app) cliArguments.push("-a", app);
+	} else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
+		command = await powerShellPath();
+		cliArguments.push("-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand");
+		if (!is_wsl_default) childProcessOptions.windowsVerbatimArguments = true;
+		const encodedArguments = ["Start"];
+		if (options.wait) encodedArguments.push("-Wait");
+		if (app) {
+			encodedArguments.push(`"\`"${app}\`""`);
+			if (options.target) appArguments.push(options.target);
+		} else if (options.target) encodedArguments.push(`"${options.target}"`);
+		if (appArguments.length > 0) {
+			appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
+			encodedArguments.push("-ArgumentList", appArguments.join(","));
+		}
+		options.target = Buffer$1.from(encodedArguments.join(" "), "utf16le").toString("base64");
+	} else {
+		if (app) command = app;
+		else {
+			const isBundled = !__dirname || __dirname === "/";
+			let exeLocalXdgOpen = false;
+			try {
+				await fsp.access(localXdgOpenPath, constants.X_OK);
+				exeLocalXdgOpen = true;
+			} catch {}
+			command = process$1.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen) ? "xdg-open" : localXdgOpenPath;
+		}
+		if (appArguments.length > 0) cliArguments.push(...appArguments);
+		if (!options.wait) {
+			childProcessOptions.stdio = "ignore";
+			childProcessOptions.detached = true;
+		}
+	}
+	if (platform === "darwin" && appArguments.length > 0) cliArguments.push("--args", ...appArguments);
+	if (options.target) cliArguments.push(options.target);
+	const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+	if (options.wait) return new Promise((resolve, reject) => {
+		subprocess.once("error", reject);
+		subprocess.once("close", (exitCode) => {
+			if (!options.allowNonzeroExitCode && exitCode > 0) {
+				reject(/* @__PURE__ */ new Error(`Exited with code ${exitCode}`));
+				return;
+			}
+			resolve(subprocess);
+		});
+	});
+	subprocess.unref();
+	return subprocess;
+};
+const open = (target, options) => {
+	if (typeof target !== "string") throw new TypeError("Expected a `target`");
+	return baseOpen({
+		...options,
+		target
+	});
+};
+function detectArchBinary(binary) {
+	if (typeof binary === "string" || Array.isArray(binary)) return binary;
+	const { [arch]: archBinary } = binary;
+	if (!archBinary) throw new Error(`${arch} is not supported`);
+	return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+	if (wsl && is_wsl_default) return detectArchBinary(wsl);
+	if (!platformBinary) throw new Error(`${platform} is not supported`);
+	return detectArchBinary(platformBinary);
+}
+const apps = {};
+defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+	darwin: "google chrome",
+	win32: "chrome",
+	linux: [
+		"google-chrome",
+		"google-chrome-stable",
+		"chromium"
+	]
+}, { wsl: {
+	ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+	x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+} }));
+defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+	darwin: "brave browser",
+	win32: "brave",
+	linux: ["brave-browser", "brave"]
+}, { wsl: {
+	ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+	x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+} }));
+defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+	darwin: "firefox",
+	win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+	linux: "firefox"
+}, { wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe" }));
+defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+	darwin: "microsoft edge",
+	win32: "msedge",
+	linux: ["microsoft-edge", "microsoft-edge-dev"]
+}, { wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe" }));
+defineLazyProperty(apps, "browser", () => "browser");
+defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$5 = __require("fs");
+	function checkPathExt(path, options) {
+		var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+		if (!pathext) return true;
+		pathext = pathext.split(";");
+		if (pathext.indexOf("") !== -1) return true;
+		for (var i = 0; i < pathext.length; i++) {
+			var p = pathext[i].toLowerCase();
+			if (p && path.substr(-p.length).toLowerCase() === p) return true;
+		}
+		return false;
+	}
+	function checkStat(stat, path, options) {
+		if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+		return checkPathExt(path, options);
+	}
+	function isexe(path, options, cb) {
+		fs$5.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, path, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$5.statSync(path), path, options);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$4 = __require("fs");
+	function isexe(path, options, cb) {
+		fs$4.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$4.statSync(path), options);
+	}
+	function checkStat(stat, options) {
+		return stat.isFile() && checkMode(stat, options);
+	}
+	function checkMode(stat, options) {
+		var mod = stat.mode;
+		var uid = stat.uid;
+		var gid = stat.gid;
+		var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+		var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+		var u = parseInt("100", 8);
+		var g = parseInt("010", 8);
+		var o = parseInt("001", 8);
+		var ug = u | g;
+		return mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	__require("fs");
+	var core;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) core = require_windows();
+	else core = require_mode();
+	module.exports = isexe;
+	isexe.sync = sync;
+	function isexe(path, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		if (!cb) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(resolve, reject) {
+				isexe(path, options || {}, function(er, is) {
+					if (er) reject(er);
+					else resolve(is);
+				});
+			});
+		}
+		core(path, options || {}, function(er, is) {
+			if (er) {
+				if (er.code === "EACCES" || options && options.ignoreErrors) {
+					er = null;
+					is = false;
+				}
+			}
+			cb(er, is);
+		});
+	}
+	function sync(path, options) {
+		try {
+			return core.sync(path, options || {});
+		} catch (er) {
+			if (options && options.ignoreErrors || er.code === "EACCES") return false;
+			else throw er;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const path$5 = __require("path");
+	const COLON = isWindows ? ";" : ":";
+	const isexe = require_isexe();
+	const getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
+	const getPathInfo = (cmd, opt) => {
+		const colon = opt.colon || COLON;
+		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || "").split(colon)];
+		const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+		if (isWindows) {
+			if (cmd.indexOf(".") !== -1 && pathExt[0] !== "") pathExt.unshift("");
+		}
+		return {
+			pathEnv,
+			pathExt,
+			pathExtExe
+		};
+	};
+	const which = (cmd, opt, cb) => {
+		if (typeof opt === "function") {
+			cb = opt;
+			opt = {};
+		}
+		if (!opt) opt = {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		const step = (i) => new Promise((resolve, reject) => {
+			if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$5.join(pathPart, cmd);
+			resolve(subStep(!pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd, i, 0));
+		});
+		const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+			if (ii === pathExt.length) return resolve(step(i + 1));
+			const ext = pathExt[ii];
+			isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+				if (!er && is) if (opt.all) found.push(p + ext);
+				else return resolve(p + ext);
+				return resolve(subStep(p, i, ii + 1));
+			});
+		});
+		return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+	};
+	const whichSync = (cmd, opt) => {
+		opt = opt || {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		for (let i = 0; i < pathEnv.length; i++) {
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$5.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			for (let j = 0; j < pathExt.length; j++) {
+				const cur = p + pathExt[j];
+				try {
+					if (isexe.sync(cur, { pathExt: pathExtExe })) if (opt.all) found.push(cur);
+					else return cur;
+				} catch (ex) {}
+			}
+		}
+		if (opt.all && found.length) return found;
+		if (opt.nothrow) return null;
+		throw getNotFoundError(cmd);
+	};
+	module.exports = which;
+	which.sync = whichSync;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pathKey = (options = {}) => {
+		const environment = options.env || process.env;
+		if ((options.platform || process.platform) !== "win32") return "PATH";
+		return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+	};
+	module.exports = pathKey;
+	module.exports.default = pathKey;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$4 = __require("path");
+	const which = require_which();
+	const getPathKey = require_path_key();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+		const env = parsed.options.env || process.env;
+		const cwd = process.cwd();
+		const hasCustomCwd = parsed.options.cwd != null;
+		const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+		if (shouldSwitchCwd) try {
+			process.chdir(parsed.options.cwd);
+		} catch (err) {}
+		let resolved;
+		try {
+			resolved = which.sync(parsed.command, {
+				path: env[getPathKey({ env })],
+				pathExt: withoutPathExt ? path$4.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (shouldSwitchCwd) process.chdir(cwd);
+		}
+		if (resolved) resolved = path$4.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+		return resolved;
+	}
+	function resolveCommand(parsed) {
+		return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	module.exports = resolveCommand;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+		arg = `${arg}`;
+		arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+		arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+		arg = `"${arg}"`;
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	module.exports.command = escapeCommand;
+	module.exports.argument = escapeArgument;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = /^#!(.*)/;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const shebangRegex = require_shebang_regex();
+	module.exports = (string = "") => {
+		const match = string.match(shebangRegex);
+		if (!match) return null;
+		const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+		const binary = path.split("/").pop();
+		if (binary === "env") return argument;
+		return argument ? `${binary} ${argument}` : binary;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$3 = __require("fs");
+	const shebangCommand = require_shebang_command();
+	function readShebang(command) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd;
+		try {
+			fd = fs$3.openSync(command, "r");
+			fs$3.readSync(fd, buffer, 0, size, 0);
+			fs$3.closeSync(fd);
+		} catch (e) {}
+		return shebangCommand(buffer.toString());
+	}
+	module.exports = readShebang;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$3 = __require("path");
+	const resolveCommand = require_resolveCommand();
+	const escape = require_escape();
+	const readShebang = require_readShebang();
+	const isWin = process.platform === "win32";
+	const isExecutableRegExp = /\.(?:com|exe)$/i;
+	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+		parsed.file = resolveCommand(parsed);
+		const shebang = parsed.file && readShebang(parsed.file);
+		if (shebang) {
+			parsed.args.unshift(parsed.file);
+			parsed.command = shebang;
+			return resolveCommand(parsed);
+		}
+		return parsed.file;
+	}
+	function parseNonShell(parsed) {
+		if (!isWin) return parsed;
+		const commandFile = detectShebang(parsed);
+		const needsShell = !isExecutableRegExp.test(commandFile);
+		if (parsed.options.forceShell || needsShell) {
+			const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+			parsed.command = path$3.normalize(parsed.command);
+			parsed.command = escape.command(parsed.command);
+			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+			parsed.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
+			];
+			parsed.command = process.env.comspec || "cmd.exe";
+			parsed.options.windowsVerbatimArguments = true;
+		}
+		return parsed;
+	}
+	function parse(command, args, options) {
+		if (args && !Array.isArray(args)) {
+			options = args;
+			args = null;
+		}
+		args = args ? args.slice(0) : [];
+		options = Object.assign({}, options);
+		const parsed = {
+			command,
+			args,
+			options,
+			file: void 0,
+			original: {
+				command,
+				args
+			}
+		};
+		return options.shell ? parsed : parseNonShell(parsed);
+	}
+	module.exports = parse;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWin = process.platform === "win32";
+	function notFoundError(original, syscall) {
+		return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${syscall} ${original.command}`,
+			path: original.command,
+			spawnargs: original.args
+		});
+	}
+	function hookChildProcess(cp, parsed) {
+		if (!isWin) return;
+		const originalEmit = cp.emit;
+		cp.emit = function(name, arg1) {
+			if (name === "exit") {
+				const err = verifyENOENT(arg1, parsed);
+				if (err) return originalEmit.call(cp, "error", err);
+			}
+			return originalEmit.apply(cp, arguments);
+		};
+	}
+	function verifyENOENT(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+		return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+		return null;
+	}
+	module.exports = {
+		hookChildProcess,
+		verifyENOENT,
+		verifyENOENTSync,
+		notFoundError
+	};
+}));
+//#endregion
+//#region src/node/server/openBrowser.ts
+/**
+* The following is modified based on source found in
+* https://github.com/facebook/create-react-app
+*
+* MIT Licensed
+* Copyright (c) 2015-present, Facebook, Inc.
+* https://github.com/facebook/create-react-app/blob/main/LICENSE
+*
+*/
+var import_cross_spawn = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const cp = __require("child_process");
+	const parse = require_parse();
+	const enoent = require_enoent();
+	function spawn(command, args, options) {
+		const parsed = parse(command, args, options);
+		const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+		enoent.hookChildProcess(spawned, parsed);
+		return spawned;
+	}
+	function spawnSync(command, args, options) {
+		const parsed = parse(command, args, options);
+		const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+		result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+		return result;
+	}
+	module.exports = spawn;
+	module.exports.spawn = spawn;
+	module.exports.sync = spawnSync;
+	module.exports._parse = parse;
+	module.exports._enoent = enoent;
+})))(), 1);
+/**
+* Reads the BROWSER environment variable and decides what to do with it.
+*/
+function openBrowser(url, opt, logger) {
+	const browser = typeof opt === "string" ? opt : process.env.BROWSER || "";
+	if (browser.toLowerCase().endsWith(".js")) executeNodeScript(browser, url, logger);
+	else if (browser.toLowerCase() !== "none") startBrowserProcess(browser, process.env.BROWSER_ARGS ? process.env.BROWSER_ARGS.split(" ") : [], url, logger);
+}
+function executeNodeScript(scriptPath, url, logger) {
+	const extraArgs = process.argv.slice(2);
+	(0, import_cross_spawn.default)(process.execPath, [
+		scriptPath,
+		...extraArgs,
+		url
+	], { stdio: "inherit" }).on("close", (code) => {
+		if (code !== 0) logger.error(import_picocolors.default.red(`\nThe script specified as BROWSER environment variable failed.\n\n${import_picocolors.default.cyan(scriptPath)} exited with code ${code}.`), { error: null });
+	});
+}
+const supportedChromiumBrowsers = [
+	"Google Chrome Canary",
+	"Google Chrome Dev",
+	"Google Chrome Beta",
+	"Google Chrome",
+	"Microsoft Edge",
+	"Brave Browser",
+	"Vivaldi",
+	"Chromium"
+];
+async function startBrowserProcess(browser, browserArgs, url, logger) {
+	const preferredOSXBrowser = browser === "google chrome" ? "Google Chrome" : browser;
+	if (process.platform === "darwin" && (!preferredOSXBrowser || supportedChromiumBrowsers.includes(preferredOSXBrowser))) try {
+		const ps = await execAsync("ps cax");
+		const openedBrowser = preferredOSXBrowser && ps.includes(preferredOSXBrowser) ? preferredOSXBrowser : supportedChromiumBrowsers.find((b) => ps.includes(b));
+		if (openedBrowser) {
+			await execAsync(`osascript openChrome.js "${url}" "${openedBrowser}"`, { cwd: join(VITE_PACKAGE_DIR, "bin") });
+			return true;
+		}
+	} catch {}
+	if (process.platform === "darwin" && browser === "open") browser = void 0;
+	try {
+		const options = browser ? { app: {
+			name: browser,
+			arguments: browserArgs
+		} } : {};
+		new Promise((_, reject) => {
+			open(url, options).then((subprocess) => {
+				subprocess.on("error", reject);
+			}).catch(reject);
+		}).catch((err) => {
+			logger.error(err.stack || err.message);
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function execAsync(command, options) {
+	return new Promise((resolve, reject) => {
+		exec(command, options, (error, stdout) => {
+			if (error) reject(error);
+			else resolve(stdout.toString());
+		});
+	});
+}
+//#endregion
+//#region src/node/shortcuts.ts
+function bindCLIShortcuts(server, opts, enabled = process.stdin.isTTY && !process.env.CI) {
+	if (!server.httpServer || !enabled) return;
+	const isDev = isDevServer(server);
+	const previousShortcuts = server._shortcutsState?.options.customShortcuts ?? [];
+	const newShortcuts = opts?.customShortcuts ?? [];
+	const previousKeys = new Set(previousShortcuts.map((s) => s.key));
+	const customShortcuts = [...newShortcuts.filter((s) => !previousKeys.has(s.key)), ...previousShortcuts.map((s) => newShortcuts.find((n) => n.key === s.key) ?? s)];
+	const newOptions = {
+		...opts,
+		customShortcuts
+	};
+	if (opts?.print) server.config.logger.info(import_picocolors.default.dim(import_picocolors.default.green("  ➜")) + import_picocolors.default.dim("  press ") + import_picocolors.default.bold("h + enter") + import_picocolors.default.dim(" to show help"));
+	const shortcuts = customShortcuts.concat(isDev ? BASE_DEV_SHORTCUTS : BASE_PREVIEW_SHORTCUTS);
+	let actionRunning = false;
+	const onInput = async (input) => {
+		if (actionRunning) return;
+		input = input.trim().toLocaleLowerCase();
+		if (input === "h") {
+			const loggedKeys = /* @__PURE__ */ new Set();
+			server.config.logger.info("\n  Shortcuts");
+			for (const shortcut of shortcuts) {
+				if (loggedKeys.has(shortcut.key)) continue;
+				loggedKeys.add(shortcut.key);
+				if (shortcut.action == null) continue;
+				server.config.logger.info(import_picocolors.default.dim("  press ") + import_picocolors.default.bold(`${shortcut.key} + enter`) + import_picocolors.default.dim(` to ${shortcut.description}`));
+			}
+			return;
+		}
+		const shortcut = shortcuts.find((shortcut) => shortcut.key === input);
+		if (!shortcut || shortcut.action == null) return;
+		actionRunning = true;
+		await shortcut.action(server);
+		actionRunning = false;
+	};
+	if (!server._shortcutsState) {
+		server._shortcutsState = {
+			rl: readline.createInterface({ input: process.stdin }),
+			options: newOptions
+		};
+		server.httpServer.on("close", () => {
+			if (server._shortcutsState) server._shortcutsState.rl.close();
+		});
+	} else {
+		server._shortcutsState.rl.removeAllListeners("line");
+		server._shortcutsState.options = newOptions;
+	}
+	server._shortcutsState.rl.on("line", onInput);
+}
+const BASE_DEV_SHORTCUTS = [
+	{
+		key: "r",
+		description: "restart the server",
+		async action(server) {
+			await restartServerWithUrls(server);
+		}
+	},
+	{
+		key: "u",
+		description: "show server url",
+		action(server) {
+			server.config.logger.info("");
+			server.printUrls();
+		}
+	},
+	{
+		key: "o",
+		description: "open in browser",
+		action(server) {
+			server.openBrowser();
+		}
+	},
+	{
+		key: "c",
+		description: "clear console",
+		action(server) {
+			server.config.logger.clearScreen("error");
+		}
+	},
+	{
+		key: "q",
+		description: "quit",
+		async action(server) {
+			try {
+				await server.close();
+			} finally {
+				process.exit();
+			}
+		}
+	}
+];
+const BASE_PREVIEW_SHORTCUTS = [{
+	key: "o",
+	description: "open in browser",
+	action(server) {
+		const url = server.resolvedUrls?.local[0] ?? server.resolvedUrls?.network[0];
+		if (url) openBrowser(url, true, server.config.logger);
+		else server.config.logger.warn("No URL available to open in browser");
+	}
+}, {
+	key: "q",
+	description: "quit",
+	async action(server) {
+		try {
+			await server.close();
+		} finally {
+			process.exit();
+		}
+	}
+}];
+//#endregion
+//#region src/node/watch.ts
+function getResolvedOutDirs(root, outDir, outputOptions) {
+	const resolvedOutDir = path.resolve(root, outDir);
+	if (!outputOptions) return new Set([resolvedOutDir]);
+	return new Set(arraify(outputOptions).map(({ dir }) => dir ? path.resolve(root, dir) : resolvedOutDir));
+}
+function resolveEmptyOutDir(emptyOutDir, root, outDirs, logger) {
+	if (emptyOutDir != null) return emptyOutDir;
+	for (const outDir of outDirs) if (!normalizePath(outDir).startsWith(withTrailingSlash(root))) {
+		logger?.warn(import_picocolors.default.yellow(`\n${import_picocolors.default.bold(`(!)`)} outDir ${import_picocolors.default.white(import_picocolors.default.dim(outDir))} is not inside project root and will not be emptied.\nUse --emptyOutDir to override.\n`));
+		return false;
+	}
+	return true;
+}
+function resolveChokidarOptions(options, resolvedOutDirs, emptyOutDir, cacheDir) {
+	const { ignored: ignoredList, ...otherOptions } = options ?? {};
+	const ignored = [
+		"**/.git/**",
+		"**/node_modules/**",
+		"**/test-results/**",
+		escapePath(cacheDir) + "/**",
+		...arraify(ignoredList || [])
+	];
+	if (emptyOutDir) ignored.push(...[...resolvedOutDirs].map((outDir) => escapePath(outDir) + "/**"));
+	return {
+		ignored,
+		ignoreInitial: true,
+		ignorePermissionErrors: true,
+		...otherOptions
+	};
+}
+function convertToWatcherOptions(options) {
+	if (!options) return;
+	return {
+		usePolling: options.usePolling,
+		pollInterval: options.interval
+	};
+}
+var NoopWatcher = class extends EventEmitter {
+	options;
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+	add() {
+		return this;
+	}
+	unwatch() {
+		return this;
+	}
+	getWatched() {
+		return {};
+	}
+	ref() {
+		return this;
+	}
+	unref() {
+		return this;
+	}
+	async close() {}
+};
+function createNoopWatcher(options) {
+	return new NoopWatcher(options);
+}
+//#endregion
+//#region src/node/publicDir.ts
+const publicFilesMap = /* @__PURE__ */ new WeakMap();
+async function initPublicFiles(config) {
+	let fileNames;
+	try {
+		fileNames = await recursiveReaddir(config.publicDir);
+	} catch (e) {
+		if (e.code === "ERR_SYMLINK_IN_RECURSIVE_READDIR") return;
+		throw e;
+	}
+	const publicFiles = new Set(fileNames.map((fileName) => fileName.slice(config.publicDir.length)));
+	publicFilesMap.set(config, publicFiles);
+	return publicFiles;
+}
+function getPublicFiles(config) {
+	return publicFilesMap.get(config);
+}
+function checkPublicFile(url, config) {
+	const { publicDir } = config;
+	if (!publicDir || url[0] !== "/") return;
+	const fileName = cleanUrl(url);
+	const publicFiles = getPublicFiles(config);
+	if (publicFiles) return publicFiles.has(fileName) ? normalizePath(path.join(publicDir, fileName)) : void 0;
+	const publicFile = normalizePath(path.join(publicDir, fileName));
+	if (!publicFile.startsWith(withTrailingSlash(publicDir))) return;
+	return tryStatSync(publicFile)?.isFile() ? publicFile : void 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const BINARY_TYPES = [
+		"nodebuffer",
+		"arraybuffer",
+		"fragments"
+	];
+	const hasBlob = typeof Blob !== "undefined";
+	if (hasBlob) BINARY_TYPES.push("blob");
+	module.exports = {
+		BINARY_TYPES,
+		CLOSE_TIMEOUT: 3e4,
+		EMPTY_BUFFER: Buffer.alloc(0),
+		GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+		hasBlob,
+		kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
+		kListener: Symbol("kListener"),
+		kStatusCode: Symbol("status-code"),
+		kWebSocket: Symbol("websocket"),
+		NOOP: () => {}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/buffer-util.js
+var require_buffer_util = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { EMPTY_BUFFER } = require_constants();
+	const FastBuffer = Buffer[Symbol.species];
+	/**
+	* Merges an array of buffers into a new buffer.
+	*
+	* @param {Buffer[]} list The array of buffers to concat
+	* @param {Number} totalLength The total length of buffers in the list
+	* @return {Buffer} The resulting buffer
+	* @public
+	*/
+	function concat(list, totalLength) {
+		if (list.length === 0) return EMPTY_BUFFER;
+		if (list.length === 1) return list[0];
+		const target = Buffer.allocUnsafe(totalLength);
+		let offset = 0;
+		for (let i = 0; i < list.length; i++) {
+			const buf = list[i];
+			target.set(buf, offset);
+			offset += buf.length;
+		}
+		if (offset < totalLength) return new FastBuffer(target.buffer, target.byteOffset, offset);
+		return target;
+	}
+	/**
+	* Masks a buffer using the given mask.
+	*
+	* @param {Buffer} source The buffer to mask
+	* @param {Buffer} mask The mask to use
+	* @param {Buffer} output The buffer where to store the result
+	* @param {Number} offset The offset at which to start writing
+	* @param {Number} length The number of bytes to mask.
+	* @public
+	*/
+	function _mask(source, mask, output, offset, length) {
+		for (let i = 0; i < length; i++) output[offset + i] = source[i] ^ mask[i & 3];
+	}
+	/**
+	* Unmasks a buffer using the given mask.
+	*
+	* @param {Buffer} buffer The buffer to unmask
+	* @param {Buffer} mask The mask to use
+	* @public
+	*/
+	function _unmask(buffer, mask) {
+		for (let i = 0; i < buffer.length; i++) buffer[i] ^= mask[i & 3];
+	}
+	/**
+	* Converts a buffer to an `ArrayBuffer`.
+	*
+	* @param {Buffer} buf The buffer to convert
+	* @return {ArrayBuffer} Converted buffer
+	* @public
+	*/
+	function toArrayBuffer(buf) {
+		if (buf.length === buf.buffer.byteLength) return buf.buffer;
+		return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+	}
+	/**
+	* Converts `data` to a `Buffer`.
+	*
+	* @param {*} data The data to convert
+	* @return {Buffer} The buffer
+	* @throws {TypeError}
+	* @public
+	*/
+	function toBuffer(data) {
+		toBuffer.readOnly = true;
+		if (Buffer.isBuffer(data)) return data;
+		let buf;
+		if (data instanceof ArrayBuffer) buf = new FastBuffer(data);
+		else if (ArrayBuffer.isView(data)) buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
+		else {
+			buf = Buffer.from(data);
+			toBuffer.readOnly = false;
+		}
+		return buf;
+	}
+	module.exports = {
+		concat,
+		mask: _mask,
+		toArrayBuffer,
+		toBuffer,
+		unmask: _unmask
+	};
+	/* istanbul ignore else  */
+	if (!process.env.WS_NO_BUFFER_UTIL) try {
+		const bufferUtil = __require("bufferutil");
+		module.exports.mask = function(source, mask, output, offset, length) {
+			if (length < 48) _mask(source, mask, output, offset, length);
+			else bufferUtil.mask(source, mask, output, offset, length);
+		};
+		module.exports.unmask = function(buffer, mask) {
+			if (buffer.length < 32) _unmask(buffer, mask);
+			else bufferUtil.unmask(buffer, mask);
+		};
+	} catch (e) {}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/limiter.js
+var require_limiter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const kDone = Symbol("kDone");
+	const kRun = Symbol("kRun");
+	/**
+	* A very simple job queue with adjustable concurrency. Adapted from
+	* https://github.com/STRML/async-limiter
+	*/
+	var Limiter = class {
+		/**
+		* Creates a new `Limiter`.
+		*
+		* @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+		*     to run concurrently
+		*/
+		constructor(concurrency) {
+			this[kDone] = () => {
+				this.pending--;
+				this[kRun]();
+			};
+			this.concurrency = concurrency || Infinity;
+			this.jobs = [];
+			this.pending = 0;
+		}
+		/**
+		* Adds a job to the queue.
+		*
+		* @param {Function} job The job to run
+		* @public
+		*/
+		add(job) {
+			this.jobs.push(job);
+			this[kRun]();
+		}
+		/**
+		* Removes a job from the queue and runs it if possible.
+		*
+		* @private
+		*/
+		[kRun]() {
+			if (this.pending === this.concurrency) return;
+			if (this.jobs.length) {
+				const job = this.jobs.shift();
+				this.pending++;
+				job(this[kDone]);
+			}
+		}
+	};
+	module.exports = Limiter;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/permessage-deflate.js
+var require_permessage_deflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const zlib$1 = __require("zlib");
+	const bufferUtil = require_buffer_util();
+	const Limiter = require_limiter();
+	const { kStatusCode } = require_constants();
+	const FastBuffer = Buffer[Symbol.species];
+	const TRAILER = Buffer.from([
+		0,
+		0,
+		255,
+		255
+	]);
+	const kPerMessageDeflate = Symbol("permessage-deflate");
+	const kTotalLength = Symbol("total-length");
+	const kCallback = Symbol("callback");
+	const kBuffers = Symbol("buffers");
+	const kError = Symbol("error");
+	let zlibLimiter;
+	/**
+	* permessage-deflate implementation.
+	*/
+	var PerMessageDeflate = class {
+		/**
+		* Creates a PerMessageDeflate instance.
+		*
+		* @param {Object} [options] Configuration options
+		* @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+		*     for, or request, a custom client window size
+		* @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+		*     acknowledge disabling of client context takeover
+		* @param {Number} [options.concurrencyLimit=10] The number of concurrent
+		*     calls to zlib
+		* @param {Boolean} [options.isServer=false] Create the instance in either
+		*     server or client mode
+		* @param {Number} [options.maxPayload=0] The maximum allowed message length
+		* @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+		*     use of a custom server window size
+		* @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+		*     disabling of server context takeover
+		* @param {Number} [options.threshold=1024] Size (in bytes) below which
+		*     messages should not be compressed if context takeover is disabled
+		* @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+		*     deflate
+		* @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+		*     inflate
+		*/
+		constructor(options) {
+			this._options = options || {};
+			this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
+			this._maxPayload = this._options.maxPayload | 0;
+			this._isServer = !!this._options.isServer;
+			this._deflate = null;
+			this._inflate = null;
+			this.params = null;
+			if (!zlibLimiter) zlibLimiter = new Limiter(this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10);
+		}
+		/**
+		* @type {String}
+		*/
+		static get extensionName() {
+			return "permessage-deflate";
+		}
+		/**
+		* Create an extension negotiation offer.
+		*
+		* @return {Object} Extension parameters
+		* @public
+		*/
+		offer() {
+			const params = {};
+			if (this._options.serverNoContextTakeover) params.server_no_context_takeover = true;
+			if (this._options.clientNoContextTakeover) params.client_no_context_takeover = true;
+			if (this._options.serverMaxWindowBits) params.server_max_window_bits = this._options.serverMaxWindowBits;
+			if (this._options.clientMaxWindowBits) params.client_max_window_bits = this._options.clientMaxWindowBits;
+			else if (this._options.clientMaxWindowBits == null) params.client_max_window_bits = true;
+			return params;
+		}
+		/**
+		* Accept an extension negotiation offer/response.
+		*
+		* @param {Array} configurations The extension negotiation offers/reponse
+		* @return {Object} Accepted configuration
+		* @public
+		*/
+		accept(configurations) {
+			configurations = this.normalizeParams(configurations);
+			this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
+			return this.params;
+		}
+		/**
+		* Releases all resources used by the extension.
+		*
+		* @public
+		*/
+		cleanup() {
+			if (this._inflate) {
+				this._inflate.close();
+				this._inflate = null;
+			}
+			if (this._deflate) {
+				const callback = this._deflate[kCallback];
+				this._deflate.close();
+				this._deflate = null;
+				if (callback) callback(/* @__PURE__ */ new Error("The deflate stream was closed while data was being processed"));
+			}
+		}
+		/**
+		*  Accept an extension negotiation offer.
+		*
+		* @param {Array} offers The extension negotiation offers
+		* @return {Object} Accepted configuration
+		* @private
+		*/
+		acceptAsServer(offers) {
+			const opts = this._options;
+			const accepted = offers.find((params) => {
+				if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) return false;
+				return true;
+			});
+			if (!accepted) throw new Error("None of the extension offers can be accepted");
+			if (opts.serverNoContextTakeover) accepted.server_no_context_takeover = true;
+			if (opts.clientNoContextTakeover) accepted.client_no_context_takeover = true;
+			if (typeof opts.serverMaxWindowBits === "number") accepted.server_max_window_bits = opts.serverMaxWindowBits;
+			if (typeof opts.clientMaxWindowBits === "number") accepted.client_max_window_bits = opts.clientMaxWindowBits;
+			else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) delete accepted.client_max_window_bits;
+			return accepted;
+		}
+		/**
+		* Accept the extension negotiation response.
+		*
+		* @param {Array} response The extension negotiation response
+		* @return {Object} Accepted configuration
+		* @private
+		*/
+		acceptAsClient(response) {
+			const params = response[0];
+			if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) throw new Error("Unexpected parameter \"client_no_context_takeover\"");
+			if (!params.client_max_window_bits) {
+				if (typeof this._options.clientMaxWindowBits === "number") params.client_max_window_bits = this._options.clientMaxWindowBits;
+			} else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) throw new Error("Unexpected or invalid parameter \"client_max_window_bits\"");
+			return params;
+		}
+		/**
+		* Normalize parameters.
+		*
+		* @param {Array} configurations The extension negotiation offers/reponse
+		* @return {Array} The offers/response with normalized parameters
+		* @private
+		*/
+		normalizeParams(configurations) {
+			configurations.forEach((params) => {
+				Object.keys(params).forEach((key) => {
+					let value = params[key];
+					if (value.length > 1) throw new Error(`Parameter "${key}" must have only a single value`);
+					value = value[0];
+					if (key === "client_max_window_bits") {
+						if (value !== true) {
+							const num = +value;
+							if (!Number.isInteger(num) || num < 8 || num > 15) throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+							value = num;
+						} else if (!this._isServer) throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+					} else if (key === "server_max_window_bits") {
+						const num = +value;
+						if (!Number.isInteger(num) || num < 8 || num > 15) throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+						value = num;
+					} else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
+						if (value !== true) throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+					} else throw new Error(`Unknown parameter "${key}"`);
+					params[key] = value;
+				});
+			});
+			return configurations;
+		}
+		/**
+		* Decompress data. Concurrency limited.
+		*
+		* @param {Buffer} data Compressed data
+		* @param {Boolean} fin Specifies whether or not this is the last fragment
+		* @param {Function} callback Callback
+		* @public
+		*/
+		decompress(data, fin, callback) {
+			zlibLimiter.add((done) => {
+				this._decompress(data, fin, (err, result) => {
+					done();
+					callback(err, result);
+				});
+			});
+		}
+		/**
+		* Compress data. Concurrency limited.
+		*
+		* @param {(Buffer|String)} data Data to compress
+		* @param {Boolean} fin Specifies whether or not this is the last fragment
+		* @param {Function} callback Callback
+		* @public
+		*/
+		compress(data, fin, callback) {
+			zlibLimiter.add((done) => {
+				this._compress(data, fin, (err, result) => {
+					done();
+					callback(err, result);
+				});
+			});
+		}
+		/**
+		* Decompress data.
+		*
+		* @param {Buffer} data Compressed data
+		* @param {Boolean} fin Specifies whether or not this is the last fragment
+		* @param {Function} callback Callback
+		* @private
+		*/
+		_decompress(data, fin, callback) {
+			const endpoint = this._isServer ? "client" : "server";
+			if (!this._inflate) {
+				const key = `${endpoint}_max_window_bits`;
+				const windowBits = typeof this.params[key] !== "number" ? zlib$1.Z_DEFAULT_WINDOWBITS : this.params[key];
+				this._inflate = zlib$1.createInflateRaw({
+					...this._options.zlibInflateOptions,
+					windowBits
+				});
+				this._inflate[kPerMessageDeflate] = this;
+				this._inflate[kTotalLength] = 0;
+				this._inflate[kBuffers] = [];
+				this._inflate.on("error", inflateOnError);
+				this._inflate.on("data", inflateOnData);
+			}
+			this._inflate[kCallback] = callback;
+			this._inflate.write(data);
+			if (fin) this._inflate.write(TRAILER);
+			this._inflate.flush(() => {
+				const err = this._inflate[kError];
+				if (err) {
+					this._inflate.close();
+					this._inflate = null;
+					callback(err);
+					return;
+				}
+				const data = bufferUtil.concat(this._inflate[kBuffers], this._inflate[kTotalLength]);
+				if (this._inflate._readableState.endEmitted) {
+					this._inflate.close();
+					this._inflate = null;
+				} else {
+					this._inflate[kTotalLength] = 0;
+					this._inflate[kBuffers] = [];
+					if (fin && this.params[`${endpoint}_no_context_takeover`]) this._inflate.reset();
+				}
+				callback(null, data);
+			});
+		}
+		/**
+		* Compress data.
+		*
+		* @param {(Buffer|String)} data Data to compress
+		* @param {Boolean} fin Specifies whether or not this is the last fragment
+		* @param {Function} callback Callback
+		* @private
+		*/
+		_compress(data, fin, callback) {
+			const endpoint = this._isServer ? "server" : "client";
+			if (!this._deflate) {
+				const key = `${endpoint}_max_window_bits`;
+				const windowBits = typeof this.params[key] !== "number" ? zlib$1.Z_DEFAULT_WINDOWBITS : this.params[key];
+				this._deflate = zlib$1.createDeflateRaw({
+					...this._options.zlibDeflateOptions,
+					windowBits
+				});
+				this._deflate[kTotalLength] = 0;
+				this._deflate[kBuffers] = [];
+				this._deflate.on("data", deflateOnData);
+			}
+			this._deflate[kCallback] = callback;
+			this._deflate.write(data);
+			this._deflate.flush(zlib$1.Z_SYNC_FLUSH, () => {
+				if (!this._deflate) return;
+				let data = bufferUtil.concat(this._deflate[kBuffers], this._deflate[kTotalLength]);
+				if (fin) data = new FastBuffer(data.buffer, data.byteOffset, data.length - 4);
+				this._deflate[kCallback] = null;
+				this._deflate[kTotalLength] = 0;
+				this._deflate[kBuffers] = [];
+				if (fin && this.params[`${endpoint}_no_context_takeover`]) this._deflate.reset();
+				callback(null, data);
+			});
+		}
+	};
+	module.exports = PerMessageDeflate;
+	/**
+	* The listener of the `zlib.DeflateRaw` stream `'data'` event.
+	*
+	* @param {Buffer} chunk A chunk of data
+	* @private
+	*/
+	function deflateOnData(chunk) {
+		this[kBuffers].push(chunk);
+		this[kTotalLength] += chunk.length;
+	}
+	/**
+	* The listener of the `zlib.InflateRaw` stream `'data'` event.
+	*
+	* @param {Buffer} chunk A chunk of data
+	* @private
+	*/
+	function inflateOnData(chunk) {
+		this[kTotalLength] += chunk.length;
+		if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
+			this[kBuffers].push(chunk);
+			return;
+		}
+		this[kError] = /* @__PURE__ */ new RangeError("Max payload size exceeded");
+		this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
+		this[kError][kStatusCode] = 1009;
+		this.removeListener("data", inflateOnData);
+		this.reset();
+	}
+	/**
+	* The listener of the `zlib.InflateRaw` stream `'error'` event.
+	*
+	* @param {Error} err The emitted error
+	* @private
+	*/
+	function inflateOnError(err) {
+		this[kPerMessageDeflate]._inflate = null;
+		if (this[kError]) {
+			this[kCallback](this[kError]);
+			return;
+		}
+		err[kStatusCode] = 1007;
+		this[kCallback](err);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/validation.js
+var require_validation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { isUtf8 } = __require("buffer");
+	const { hasBlob } = require_constants();
+	const tokenChars = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		1,
+		0,
+		1,
+		0
+	];
+	/**
+	* Checks if a status code is allowed in a close frame.
+	*
+	* @param {Number} code The status code
+	* @return {Boolean} `true` if the status code is valid, else `false`
+	* @public
+	*/
+	function isValidStatusCode(code) {
+		return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
+	}
+	/**
+	* Checks if a given buffer contains only correct UTF-8.
+	* Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
+	* Markus Kuhn.
+	*
+	* @param {Buffer} buf The buffer to check
+	* @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
+	* @public
+	*/
+	function _isValidUTF8(buf) {
+		const len = buf.length;
+		let i = 0;
+		while (i < len) if ((buf[i] & 128) === 0) i++;
+		else if ((buf[i] & 224) === 192) {
+			if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) return false;
+			i += 2;
+		} else if ((buf[i] & 240) === 224) {
+			if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || buf[i] === 237 && (buf[i + 1] & 224) === 160) return false;
+			i += 3;
+		} else if ((buf[i] & 248) === 240) {
+			if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) return false;
+			i += 4;
+		} else return false;
+		return true;
+	}
+	/**
+	* Determines whether a value is a `Blob`.
+	*
+	* @param {*} value The value to be tested
+	* @return {Boolean} `true` if `value` is a `Blob`, else `false`
+	* @private
+	*/
+	function isBlob(value) {
+		return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File");
+	}
+	module.exports = {
+		isBlob,
+		isValidStatusCode,
+		isValidUTF8: _isValidUTF8,
+		tokenChars
+	};
+	if (isUtf8) module.exports.isValidUTF8 = function(buf) {
+		return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
+	};
+	else if (!process.env.WS_NO_UTF_8_VALIDATE) try {
+		const isValidUTF8 = __require("utf-8-validate");
+		module.exports.isValidUTF8 = function(buf) {
+			return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
+		};
+	} catch (e) {}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/receiver.js
+var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { Writable: Writable$1 } = __require("stream");
+	const PerMessageDeflate = require_permessage_deflate();
+	const { BINARY_TYPES, EMPTY_BUFFER, kStatusCode, kWebSocket } = require_constants();
+	const { concat, toArrayBuffer, unmask } = require_buffer_util();
+	const { isValidStatusCode, isValidUTF8 } = require_validation();
+	const FastBuffer = Buffer[Symbol.species];
+	const GET_INFO = 0;
+	const GET_PAYLOAD_LENGTH_16 = 1;
+	const GET_PAYLOAD_LENGTH_64 = 2;
+	const GET_MASK = 3;
+	const GET_DATA = 4;
+	const INFLATING = 5;
+	const DEFER_EVENT = 6;
+	/**
+	* HyBi Receiver implementation.
+	*
+	* @extends Writable
+	*/
+	var Receiver = class extends Writable$1 {
+		/**
+		* Creates a Receiver instance.
+		*
+		* @param {Object} [options] Options object
+		* @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+		*     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+		*     multiple times in the same tick
+		* @param {String} [options.binaryType=nodebuffer] The type for binary data
+		* @param {Object} [options.extensions] An object containing the negotiated
+		*     extensions
+		* @param {Boolean} [options.isServer=false] Specifies whether to operate in
+		*     client or server mode
+		* @param {Number} [options.maxPayload=0] The maximum allowed message length
+		* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+		*     not to skip UTF-8 validation for text and close messages
+		*/
+		constructor(options = {}) {
+			super();
+			this._allowSynchronousEvents = options.allowSynchronousEvents !== void 0 ? options.allowSynchronousEvents : true;
+			this._binaryType = options.binaryType || BINARY_TYPES[0];
+			this._extensions = options.extensions || {};
+			this._isServer = !!options.isServer;
+			this._maxPayload = options.maxPayload | 0;
+			this._skipUTF8Validation = !!options.skipUTF8Validation;
+			this[kWebSocket] = void 0;
+			this._bufferedBytes = 0;
+			this._buffers = [];
+			this._compressed = false;
+			this._payloadLength = 0;
+			this._mask = void 0;
+			this._fragmented = 0;
+			this._masked = false;
+			this._fin = false;
+			this._opcode = 0;
+			this._totalPayloadLength = 0;
+			this._messageLength = 0;
+			this._fragments = [];
+			this._errored = false;
+			this._loop = false;
+			this._state = GET_INFO;
+		}
+		/**
+		* Implements `Writable.prototype._write()`.
+		*
+		* @param {Buffer} chunk The chunk of data to write
+		* @param {String} encoding The character encoding of `chunk`
+		* @param {Function} cb Callback
+		* @private
+		*/
+		_write(chunk, encoding, cb) {
+			if (this._opcode === 8 && this._state == GET_INFO) return cb();
+			this._bufferedBytes += chunk.length;
+			this._buffers.push(chunk);
+			this.startLoop(cb);
+		}
+		/**
+		* Consumes `n` bytes from the buffered data.
+		*
+		* @param {Number} n The number of bytes to consume
+		* @return {Buffer} The consumed bytes
+		* @private
+		*/
+		consume(n) {
+			this._bufferedBytes -= n;
+			if (n === this._buffers[0].length) return this._buffers.shift();
+			if (n < this._buffers[0].length) {
+				const buf = this._buffers[0];
+				this._buffers[0] = new FastBuffer(buf.buffer, buf.byteOffset + n, buf.length - n);
+				return new FastBuffer(buf.buffer, buf.byteOffset, n);
+			}
+			const dst = Buffer.allocUnsafe(n);
+			do {
+				const buf = this._buffers[0];
+				const offset = dst.length - n;
+				if (n >= buf.length) dst.set(this._buffers.shift(), offset);
+				else {
+					dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+					this._buffers[0] = new FastBuffer(buf.buffer, buf.byteOffset + n, buf.length - n);
+				}
+				n -= buf.length;
+			} while (n > 0);
+			return dst;
+		}
+		/**
+		* Starts the parsing loop.
+		*
+		* @param {Function} cb Callback
+		* @private
+		*/
+		startLoop(cb) {
+			this._loop = true;
+			do
+				switch (this._state) {
+					case GET_INFO:
+						this.getInfo(cb);
+						break;
+					case GET_PAYLOAD_LENGTH_16:
+						this.getPayloadLength16(cb);
+						break;
+					case GET_PAYLOAD_LENGTH_64:
+						this.getPayloadLength64(cb);
+						break;
+					case GET_MASK:
+						this.getMask();
+						break;
+					case GET_DATA:
+						this.getData(cb);
+						break;
+					case INFLATING:
+					case DEFER_EVENT:
+						this._loop = false;
+						return;
+				}
+			while (this._loop);
+			if (!this._errored) cb();
+		}
+		/**
+		* Reads the first two bytes of a frame.
+		*
+		* @param {Function} cb Callback
+		* @private
+		*/
+		getInfo(cb) {
+			if (this._bufferedBytes < 2) {
+				this._loop = false;
+				return;
+			}
+			const buf = this.consume(2);
+			if ((buf[0] & 48) !== 0) {
+				cb(this.createError(RangeError, "RSV2 and RSV3 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_2_3"));
+				return;
+			}
+			const compressed = (buf[0] & 64) === 64;
+			if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+				cb(this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1"));
+				return;
+			}
+			this._fin = (buf[0] & 128) === 128;
+			this._opcode = buf[0] & 15;
+			this._payloadLength = buf[1] & 127;
+			if (this._opcode === 0) {
+				if (compressed) {
+					cb(this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1"));
+					return;
+				}
+				if (!this._fragmented) {
+					cb(this.createError(RangeError, "invalid opcode 0", true, 1002, "WS_ERR_INVALID_OPCODE"));
+					return;
+				}
+				this._opcode = this._fragmented;
+			} else if (this._opcode === 1 || this._opcode === 2) {
+				if (this._fragmented) {
+					cb(this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE"));
+					return;
+				}
+				this._compressed = compressed;
+			} else if (this._opcode > 7 && this._opcode < 11) {
+				if (!this._fin) {
+					cb(this.createError(RangeError, "FIN must be set", true, 1002, "WS_ERR_EXPECTED_FIN"));
+					return;
+				}
+				if (compressed) {
+					cb(this.createError(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1"));
+					return;
+				}
+				if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
+					cb(this.createError(RangeError, `invalid payload length ${this._payloadLength}`, true, 1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"));
+					return;
+				}
+			} else {
+				cb(this.createError(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE"));
+				return;
+			}
+			if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
+			this._masked = (buf[1] & 128) === 128;
+			if (this._isServer) {
+				if (!this._masked) {
+					cb(this.createError(RangeError, "MASK must be set", true, 1002, "WS_ERR_EXPECTED_MASK"));
+					return;
+				}
+			} else if (this._masked) {
+				cb(this.createError(RangeError, "MASK must be clear", true, 1002, "WS_ERR_UNEXPECTED_MASK"));
+				return;
+			}
+			if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
+			else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
+			else this.haveLength(cb);
+		}
+		/**
+		* Gets extended payload length (7+16).
+		*
+		* @param {Function} cb Callback
+		* @private
+		*/
+		getPayloadLength16(cb) {
+			if (this._bufferedBytes < 2) {
+				this._loop = false;
+				return;
+			}
+			this._payloadLength = this.consume(2).readUInt16BE(0);
+			this.haveLength(cb);
+		}
+		/**
+		* Gets extended payload length (7+64).
+		*
+		* @param {Function} cb Callback
+		* @private
+		*/
+		getPayloadLength64(cb) {
+			if (this._bufferedBytes < 8) {
+				this._loop = false;
+				return;
+			}
+			const buf = this.consume(8);
+			const num = buf.readUInt32BE(0);
+			if (num > Math.pow(2, 21) - 1) {
+				cb(this.createError(RangeError, "Unsupported WebSocket frame: payload length > 2^53 - 1", false, 1009, "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"));
+				return;
+			}
+			this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+			this.haveLength(cb);
+		}
+		/**
+		* Payload length has been read.
+		*
+		* @param {Function} cb Callback
+		* @private
+		*/
+		haveLength(cb) {
+			if (this._payloadLength && this._opcode < 8) {
+				this._totalPayloadLength += this._payloadLength;
+				if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+					cb(this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"));
+					return;
+				}
+			}
+			if (this._masked) this._state = GET_MASK;
+			else this._state = GET_DATA;
+		}
+		/**
+		* Reads mask bytes.
+		*
+		* @private
+		*/
+		getMask() {
+			if (this._bufferedBytes < 4) {
+				this._loop = false;
+				return;
+			}
+			this._mask = this.consume(4);
+			this._state = GET_DATA;
+		}
+		/**
+		* Reads data bytes.
+		*
+		* @param {Function} cb Callback
+		* @private
+		*/
+		getData(cb) {
+			let data = EMPTY_BUFFER;
+			if (this._payloadLength) {
+				if (this._bufferedBytes < this._payloadLength) {
+					this._loop = false;
+					return;
+				}
+				data = this.consume(this._payloadLength);
+				if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) unmask(data, this._mask);
+			}
+			if (this._opcode > 7) {
+				this.controlMessage(data, cb);
+				return;
+			}
+			if (this._compressed) {
+				this._state = INFLATING;
+				this.decompress(data, cb);
+				return;
+			}
+			if (data.length) {
+				this._messageLength = this._totalPayloadLength;
+				this._fragments.push(data);
+			}
+			this.dataMessage(cb);
+		}
+		/**
+		* Decompresses data.
+		*
+		* @param {Buffer} data Compressed data
+		* @param {Function} cb Callback
+		* @private
+		*/
+		decompress(data, cb) {
+			this._extensions[PerMessageDeflate.extensionName].decompress(data, this._fin, (err, buf) => {
+				if (err) return cb(err);
+				if (buf.length) {
+					this._messageLength += buf.length;
+					if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+						cb(this.createError(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"));
+						return;
+					}
+					this._fragments.push(buf);
+				}
+				this.dataMessage(cb);
+				if (this._state === GET_INFO) this.startLoop(cb);
+			});
+		}
+		/**
+		* Handles a data message.
+		*
+		* @param {Function} cb Callback
+		* @private
+		*/
+		dataMessage(cb) {
+			if (!this._fin) {
+				this._state = GET_INFO;
+				return;
+			}
+			const messageLength = this._messageLength;
+			const fragments = this._fragments;
+			this._totalPayloadLength = 0;
+			this._messageLength = 0;
+			this._fragmented = 0;
+			this._fragments = [];
+			if (this._opcode === 2) {
+				let data;
+				if (this._binaryType === "nodebuffer") data = concat(fragments, messageLength);
+				else if (this._binaryType === "arraybuffer") data = toArrayBuffer(concat(fragments, messageLength));
+				else if (this._binaryType === "blob") data = new Blob(fragments);
+				else data = fragments;
+				if (this._allowSynchronousEvents) {
+					this.emit("message", data, true);
+					this._state = GET_INFO;
+				} else {
+					this._state = DEFER_EVENT;
+					setImmediate(() => {
+						this.emit("message", data, true);
+						this._state = GET_INFO;
+						this.startLoop(cb);
+					});
+				}
+			} else {
+				const buf = concat(fragments, messageLength);
+				if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+					cb(this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8"));
+					return;
+				}
+				if (this._state === INFLATING || this._allowSynchronousEvents) {
+					this.emit("message", buf, false);
+					this._state = GET_INFO;
+				} else {
+					this._state = DEFER_EVENT;
+					setImmediate(() => {
+						this.emit("message", buf, false);
+						this._state = GET_INFO;
+						this.startLoop(cb);
+					});
+				}
+			}
+		}
+		/**
+		* Handles a control message.
+		*
+		* @param {Buffer} data Data to handle
+		* @return {(Error|RangeError|undefined)} A possible error
+		* @private
+		*/
+		controlMessage(data, cb) {
+			if (this._opcode === 8) {
+				if (data.length === 0) {
+					this._loop = false;
+					this.emit("conclude", 1005, EMPTY_BUFFER);
+					this.end();
+				} else {
+					const code = data.readUInt16BE(0);
+					if (!isValidStatusCode(code)) {
+						cb(this.createError(RangeError, `invalid status code ${code}`, true, 1002, "WS_ERR_INVALID_CLOSE_CODE"));
+						return;
+					}
+					const buf = new FastBuffer(data.buffer, data.byteOffset + 2, data.length - 2);
+					if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+						cb(this.createError(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8"));
+						return;
+					}
+					this._loop = false;
+					this.emit("conclude", code, buf);
+					this.end();
+				}
+				this._state = GET_INFO;
+				return;
+			}
+			if (this._allowSynchronousEvents) {
+				this.emit(this._opcode === 9 ? "ping" : "pong", data);
+				this._state = GET_INFO;
+			} else {
+				this._state = DEFER_EVENT;
+				setImmediate(() => {
+					this.emit(this._opcode === 9 ? "ping" : "pong", data);
+					this._state = GET_INFO;
+					this.startLoop(cb);
+				});
+			}
+		}
+		/**
+		* Builds an error object.
+		*
+		* @param {function(new:Error|RangeError)} ErrorCtor The error constructor
+		* @param {String} message The error message
+		* @param {Boolean} prefix Specifies whether or not to add a default prefix to
+		*     `message`
+		* @param {Number} statusCode The status code
+		* @param {String} errorCode The exposed error code
+		* @return {(Error|RangeError)} The error
+		* @private
+		*/
+		createError(ErrorCtor, message, prefix, statusCode, errorCode) {
+			this._loop = false;
+			this._errored = true;
+			const err = new ErrorCtor(prefix ? `Invalid WebSocket frame: ${message}` : message);
+			Error.captureStackTrace(err, this.createError);
+			err.code = errorCode;
+			err[kStatusCode] = statusCode;
+			return err;
+		}
+	};
+	module.exports = Receiver;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/sender.js
+var require_sender = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { Duplex: Duplex$3 } = __require("stream");
+	const { randomFillSync } = __require("crypto");
+	const PerMessageDeflate = require_permessage_deflate();
+	const { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
+	const { isBlob, isValidStatusCode } = require_validation();
+	const { mask: applyMask, toBuffer } = require_buffer_util();
+	const kByteLength = Symbol("kByteLength");
+	const maskBuffer = Buffer.alloc(4);
+	const RANDOM_POOL_SIZE = 8 * 1024;
+	let randomPool;
+	let randomPoolPointer = RANDOM_POOL_SIZE;
+	const DEFAULT = 0;
+	const DEFLATING = 1;
+	const GET_BLOB_DATA = 2;
+	module.exports = class Sender {
+		/**
+		* Creates a Sender instance.
+		*
+		* @param {Duplex} socket The connection socket
+		* @param {Object} [extensions] An object containing the negotiated extensions
+		* @param {Function} [generateMask] The function used to generate the masking
+		*     key
+		*/
+		constructor(socket, extensions, generateMask) {
+			this._extensions = extensions || {};
+			if (generateMask) {
+				this._generateMask = generateMask;
+				this._maskBuffer = Buffer.alloc(4);
+			}
+			this._socket = socket;
+			this._firstFragment = true;
+			this._compress = false;
+			this._bufferedBytes = 0;
+			this._queue = [];
+			this._state = DEFAULT;
+			this.onerror = NOOP;
+			this[kWebSocket] = void 0;
+		}
+		/**
+		* Frames a piece of data according to the HyBi WebSocket protocol.
+		*
+		* @param {(Buffer|String)} data The data to frame
+		* @param {Object} options Options object
+		* @param {Boolean} [options.fin=false] Specifies whether or not to set the
+		*     FIN bit
+		* @param {Function} [options.generateMask] The function used to generate the
+		*     masking key
+		* @param {Boolean} [options.mask=false] Specifies whether or not to mask
+		*     `data`
+		* @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+		*     key
+		* @param {Number} options.opcode The opcode
+		* @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+		*     modified
+		* @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+		*     RSV1 bit
+		* @return {(Buffer|String)[]} The framed data
+		* @public
+		*/
+		static frame(data, options) {
+			let mask;
+			let merge = false;
+			let offset = 2;
+			let skipMasking = false;
+			if (options.mask) {
+				mask = options.maskBuffer || maskBuffer;
+				if (options.generateMask) options.generateMask(mask);
+				else {
+					if (randomPoolPointer === RANDOM_POOL_SIZE) {
+						/* istanbul ignore else  */
+						if (randomPool === void 0) randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
+						randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
+						randomPoolPointer = 0;
+					}
+					mask[0] = randomPool[randomPoolPointer++];
+					mask[1] = randomPool[randomPoolPointer++];
+					mask[2] = randomPool[randomPoolPointer++];
+					mask[3] = randomPool[randomPoolPointer++];
+				}
+				skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
+				offset = 6;
+			}
+			let dataLength;
+			if (typeof data === "string") if ((!options.mask || skipMasking) && options[kByteLength] !== void 0) dataLength = options[kByteLength];
+			else {
+				data = Buffer.from(data);
+				dataLength = data.length;
+			}
+			else {
+				dataLength = data.length;
+				merge = options.mask && options.readOnly && !skipMasking;
+			}
+			let payloadLength = dataLength;
+			if (dataLength >= 65536) {
+				offset += 8;
+				payloadLength = 127;
+			} else if (dataLength > 125) {
+				offset += 2;
+				payloadLength = 126;
+			}
+			const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
+			target[0] = options.fin ? options.opcode | 128 : options.opcode;
+			if (options.rsv1) target[0] |= 64;
+			target[1] = payloadLength;
+			if (payloadLength === 126) target.writeUInt16BE(dataLength, 2);
+			else if (payloadLength === 127) {
+				target[2] = target[3] = 0;
+				target.writeUIntBE(dataLength, 4, 6);
+			}
+			if (!options.mask) return [target, data];
+			target[1] |= 128;
+			target[offset - 4] = mask[0];
+			target[offset - 3] = mask[1];
+			target[offset - 2] = mask[2];
+			target[offset - 1] = mask[3];
+			if (skipMasking) return [target, data];
+			if (merge) {
+				applyMask(data, mask, target, offset, dataLength);
+				return [target];
+			}
+			applyMask(data, mask, data, 0, dataLength);
+			return [target, data];
+		}
+		/**
+		* Sends a close message to the other peer.
+		*
+		* @param {Number} [code] The status code component of the body
+		* @param {(String|Buffer)} [data] The message component of the body
+		* @param {Boolean} [mask=false] Specifies whether or not to mask the message
+		* @param {Function} [cb] Callback
+		* @public
+		*/
+		close(code, data, mask, cb) {
+			let buf;
+			if (code === void 0) buf = EMPTY_BUFFER;
+			else if (typeof code !== "number" || !isValidStatusCode(code)) throw new TypeError("First argument must be a valid error code number");
+			else if (data === void 0 || !data.length) {
+				buf = Buffer.allocUnsafe(2);
+				buf.writeUInt16BE(code, 0);
+			} else {
+				const length = Buffer.byteLength(data);
+				if (length > 123) throw new RangeError("The message must not be greater than 123 bytes");
+				buf = Buffer.allocUnsafe(2 + length);
+				buf.writeUInt16BE(code, 0);
+				if (typeof data === "string") buf.write(data, 2);
+				else buf.set(data, 2);
+			}
+			const options = {
+				[kByteLength]: buf.length,
+				fin: true,
+				generateMask: this._generateMask,
+				mask,
+				maskBuffer: this._maskBuffer,
+				opcode: 8,
+				readOnly: false,
+				rsv1: false
+			};
+			if (this._state !== DEFAULT) this.enqueue([
+				this.dispatch,
+				buf,
+				false,
+				options,
+				cb
+			]);
+			else this.sendFrame(Sender.frame(buf, options), cb);
+		}
+		/**
+		* Sends a ping message to the other peer.
+		*
+		* @param {*} data The message to send
+		* @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+		* @param {Function} [cb] Callback
+		* @public
+		*/
+		ping(data, mask, cb) {
+			let byteLength;
+			let readOnly;
+			if (typeof data === "string") {
+				byteLength = Buffer.byteLength(data);
+				readOnly = false;
+			} else if (isBlob(data)) {
+				byteLength = data.size;
+				readOnly = false;
+			} else {
+				data = toBuffer(data);
+				byteLength = data.length;
+				readOnly = toBuffer.readOnly;
+			}
+			if (byteLength > 125) throw new RangeError("The data size must not be greater than 125 bytes");
+			const options = {
+				[kByteLength]: byteLength,
+				fin: true,
+				generateMask: this._generateMask,
+				mask,
+				maskBuffer: this._maskBuffer,
+				opcode: 9,
+				readOnly,
+				rsv1: false
+			};
+			if (isBlob(data)) if (this._state !== DEFAULT) this.enqueue([
+				this.getBlobData,
+				data,
+				false,
+				options,
+				cb
+			]);
+			else this.getBlobData(data, false, options, cb);
+			else if (this._state !== DEFAULT) this.enqueue([
+				this.dispatch,
+				data,
+				false,
+				options,
+				cb
+			]);
+			else this.sendFrame(Sender.frame(data, options), cb);
+		}
+		/**
+		* Sends a pong message to the other peer.
+		*
+		* @param {*} data The message to send
+		* @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+		* @param {Function} [cb] Callback
+		* @public
+		*/
+		pong(data, mask, cb) {
+			let byteLength;
+			let readOnly;
+			if (typeof data === "string") {
+				byteLength = Buffer.byteLength(data);
+				readOnly = false;
+			} else if (isBlob(data)) {
+				byteLength = data.size;
+				readOnly = false;
+			} else {
+				data = toBuffer(data);
+				byteLength = data.length;
+				readOnly = toBuffer.readOnly;
+			}
+			if (byteLength > 125) throw new RangeError("The data size must not be greater than 125 bytes");
+			const options = {
+				[kByteLength]: byteLength,
+				fin: true,
+				generateMask: this._generateMask,
+				mask,
+				maskBuffer: this._maskBuffer,
+				opcode: 10,
+				readOnly,
+				rsv1: false
+			};
+			if (isBlob(data)) if (this._state !== DEFAULT) this.enqueue([
+				this.getBlobData,
+				data,
+				false,
+				options,
+				cb
+			]);
+			else this.getBlobData(data, false, options, cb);
+			else if (this._state !== DEFAULT) this.enqueue([
+				this.dispatch,
+				data,
+				false,
+				options,
+				cb
+			]);
+			else this.sendFrame(Sender.frame(data, options), cb);
+		}
+		/**
+		* Sends a data message to the other peer.
+		*
+		* @param {*} data The message to send
+		* @param {Object} options Options object
+		* @param {Boolean} [options.binary=false] Specifies whether `data` is binary
+		*     or text
+		* @param {Boolean} [options.compress=false] Specifies whether or not to
+		*     compress `data`
+		* @param {Boolean} [options.fin=false] Specifies whether the fragment is the
+		*     last one
+		* @param {Boolean} [options.mask=false] Specifies whether or not to mask
+		*     `data`
+		* @param {Function} [cb] Callback
+		* @public
+		*/
+		send(data, options, cb) {
+			const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+			let opcode = options.binary ? 2 : 1;
+			let rsv1 = options.compress;
+			let byteLength;
+			let readOnly;
+			if (typeof data === "string") {
+				byteLength = Buffer.byteLength(data);
+				readOnly = false;
+			} else if (isBlob(data)) {
+				byteLength = data.size;
+				readOnly = false;
+			} else {
+				data = toBuffer(data);
+				byteLength = data.length;
+				readOnly = toBuffer.readOnly;
+			}
+			if (this._firstFragment) {
+				this._firstFragment = false;
+				if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) rsv1 = byteLength >= perMessageDeflate._threshold;
+				this._compress = rsv1;
+			} else {
+				rsv1 = false;
+				opcode = 0;
+			}
+			if (options.fin) this._firstFragment = true;
+			const opts = {
+				[kByteLength]: byteLength,
+				fin: options.fin,
+				generateMask: this._generateMask,
+				mask: options.mask,
+				maskBuffer: this._maskBuffer,
+				opcode,
+				readOnly,
+				rsv1
+			};
+			if (isBlob(data)) if (this._state !== DEFAULT) this.enqueue([
+				this.getBlobData,
+				data,
+				this._compress,
+				opts,
+				cb
+			]);
+			else this.getBlobData(data, this._compress, opts, cb);
+			else if (this._state !== DEFAULT) this.enqueue([
+				this.dispatch,
+				data,
+				this._compress,
+				opts,
+				cb
+			]);
+			else this.dispatch(data, this._compress, opts, cb);
+		}
+		/**
+		* Gets the contents of a blob as binary data.
+		*
+		* @param {Blob} blob The blob
+		* @param {Boolean} [compress=false] Specifies whether or not to compress
+		*     the data
+		* @param {Object} options Options object
+		* @param {Boolean} [options.fin=false] Specifies whether or not to set the
+		*     FIN bit
+		* @param {Function} [options.generateMask] The function used to generate the
+		*     masking key
+		* @param {Boolean} [options.mask=false] Specifies whether or not to mask
+		*     `data`
+		* @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+		*     key
+		* @param {Number} options.opcode The opcode
+		* @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+		*     modified
+		* @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+		*     RSV1 bit
+		* @param {Function} [cb] Callback
+		* @private
+		*/
+		getBlobData(blob, compress, options, cb) {
+			this._bufferedBytes += options[kByteLength];
+			this._state = GET_BLOB_DATA;
+			blob.arrayBuffer().then((arrayBuffer) => {
+				if (this._socket.destroyed) {
+					const err = /* @__PURE__ */ new Error("The socket was closed while the blob was being read");
+					process.nextTick(callCallbacks, this, err, cb);
+					return;
+				}
+				this._bufferedBytes -= options[kByteLength];
+				const data = toBuffer(arrayBuffer);
+				if (!compress) {
+					this._state = DEFAULT;
+					this.sendFrame(Sender.frame(data, options), cb);
+					this.dequeue();
+				} else this.dispatch(data, compress, options, cb);
+			}).catch((err) => {
+				process.nextTick(onError, this, err, cb);
+			});
+		}
+		/**
+		* Dispatches a message.
+		*
+		* @param {(Buffer|String)} data The message to send
+		* @param {Boolean} [compress=false] Specifies whether or not to compress
+		*     `data`
+		* @param {Object} options Options object
+		* @param {Boolean} [options.fin=false] Specifies whether or not to set the
+		*     FIN bit
+		* @param {Function} [options.generateMask] The function used to generate the
+		*     masking key
+		* @param {Boolean} [options.mask=false] Specifies whether or not to mask
+		*     `data`
+		* @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+		*     key
+		* @param {Number} options.opcode The opcode
+		* @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+		*     modified
+		* @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+		*     RSV1 bit
+		* @param {Function} [cb] Callback
+		* @private
+		*/
+		dispatch(data, compress, options, cb) {
+			if (!compress) {
+				this.sendFrame(Sender.frame(data, options), cb);
+				return;
+			}
+			const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+			this._bufferedBytes += options[kByteLength];
+			this._state = DEFLATING;
+			perMessageDeflate.compress(data, options.fin, (_, buf) => {
+				if (this._socket.destroyed) {
+					const err = /* @__PURE__ */ new Error("The socket was closed while data was being compressed");
+					callCallbacks(this, err, cb);
+					return;
+				}
+				this._bufferedBytes -= options[kByteLength];
+				this._state = DEFAULT;
+				options.readOnly = false;
+				this.sendFrame(Sender.frame(buf, options), cb);
+				this.dequeue();
+			});
+		}
+		/**
+		* Executes queued send operations.
+		*
+		* @private
+		*/
+		dequeue() {
+			while (this._state === DEFAULT && this._queue.length) {
+				const params = this._queue.shift();
+				this._bufferedBytes -= params[3][kByteLength];
+				Reflect.apply(params[0], this, params.slice(1));
+			}
+		}
+		/**
+		* Enqueues a send operation.
+		*
+		* @param {Array} params Send operation parameters.
+		* @private
+		*/
+		enqueue(params) {
+			this._bufferedBytes += params[3][kByteLength];
+			this._queue.push(params);
+		}
+		/**
+		* Sends a frame.
+		*
+		* @param {(Buffer | String)[]} list The frame to send
+		* @param {Function} [cb] Callback
+		* @private
+		*/
+		sendFrame(list, cb) {
+			if (list.length === 2) {
+				this._socket.cork();
+				this._socket.write(list[0]);
+				this._socket.write(list[1], cb);
+				this._socket.uncork();
+			} else this._socket.write(list[0], cb);
+		}
+	};
+	/**
+	* Calls queued callbacks with an error.
+	*
+	* @param {Sender} sender The `Sender` instance
+	* @param {Error} err The error to call the callbacks with
+	* @param {Function} [cb] The first callback
+	* @private
+	*/
+	function callCallbacks(sender, err, cb) {
+		if (typeof cb === "function") cb(err);
+		for (let i = 0; i < sender._queue.length; i++) {
+			const params = sender._queue[i];
+			const callback = params[params.length - 1];
+			if (typeof callback === "function") callback(err);
+		}
+	}
+	/**
+	* Handles a `Sender` error.
+	*
+	* @param {Sender} sender The `Sender` instance
+	* @param {Error} err The error
+	* @param {Function} [cb] The first pending callback
+	* @private
+	*/
+	function onError(sender, err, cb) {
+		callCallbacks(sender, err, cb);
+		sender.onerror(err);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/event-target.js
+var require_event_target = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { kForOnEventAttribute, kListener } = require_constants();
+	const kCode = Symbol("kCode");
+	const kData = Symbol("kData");
+	const kError = Symbol("kError");
+	const kMessage = Symbol("kMessage");
+	const kReason = Symbol("kReason");
+	const kTarget = Symbol("kTarget");
+	const kType = Symbol("kType");
+	const kWasClean = Symbol("kWasClean");
+	/**
+	* Class representing an event.
+	*/
+	var Event = class {
+		/**
+		* Create a new `Event`.
+		*
+		* @param {String} type The name of the event
+		* @throws {TypeError} If the `type` argument is not specified
+		*/
+		constructor(type) {
+			this[kTarget] = null;
+			this[kType] = type;
+		}
+		/**
+		* @type {*}
+		*/
+		get target() {
+			return this[kTarget];
+		}
+		/**
+		* @type {String}
+		*/
+		get type() {
+			return this[kType];
+		}
+	};
+	Object.defineProperty(Event.prototype, "target", { enumerable: true });
+	Object.defineProperty(Event.prototype, "type", { enumerable: true });
+	/**
+	* Class representing a close event.
+	*
+	* @extends Event
+	*/
+	var CloseEvent = class extends Event {
+		/**
+		* Create a new `CloseEvent`.
+		*
+		* @param {String} type The name of the event
+		* @param {Object} [options] A dictionary object that allows for setting
+		*     attributes via object members of the same name
+		* @param {Number} [options.code=0] The status code explaining why the
+		*     connection was closed
+		* @param {String} [options.reason=''] A human-readable string explaining why
+		*     the connection was closed
+		* @param {Boolean} [options.wasClean=false] Indicates whether or not the
+		*     connection was cleanly closed
+		*/
+		constructor(type, options = {}) {
+			super(type);
+			this[kCode] = options.code === void 0 ? 0 : options.code;
+			this[kReason] = options.reason === void 0 ? "" : options.reason;
+			this[kWasClean] = options.wasClean === void 0 ? false : options.wasClean;
+		}
+		/**
+		* @type {Number}
+		*/
+		get code() {
+			return this[kCode];
+		}
+		/**
+		* @type {String}
+		*/
+		get reason() {
+			return this[kReason];
+		}
+		/**
+		* @type {Boolean}
+		*/
+		get wasClean() {
+			return this[kWasClean];
+		}
+	};
+	Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
+	Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
+	Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
+	/**
+	* Class representing an error event.
+	*
+	* @extends Event
+	*/
+	var ErrorEvent = class extends Event {
+		/**
+		* Create a new `ErrorEvent`.
+		*
+		* @param {String} type The name of the event
+		* @param {Object} [options] A dictionary object that allows for setting
+		*     attributes via object members of the same name
+		* @param {*} [options.error=null] The error that generated this event
+		* @param {String} [options.message=''] The error message
+		*/
+		constructor(type, options = {}) {
+			super(type);
+			this[kError] = options.error === void 0 ? null : options.error;
+			this[kMessage] = options.message === void 0 ? "" : options.message;
+		}
+		/**
+		* @type {*}
+		*/
+		get error() {
+			return this[kError];
+		}
+		/**
+		* @type {String}
+		*/
+		get message() {
+			return this[kMessage];
+		}
+	};
+	Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
+	Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
+	/**
+	* Class representing a message event.
+	*
+	* @extends Event
+	*/
+	var MessageEvent = class extends Event {
+		/**
+		* Create a new `MessageEvent`.
+		*
+		* @param {String} type The name of the event
+		* @param {Object} [options] A dictionary object that allows for setting
+		*     attributes via object members of the same name
+		* @param {*} [options.data=null] The message content
+		*/
+		constructor(type, options = {}) {
+			super(type);
+			this[kData] = options.data === void 0 ? null : options.data;
+		}
+		/**
+		* @type {*}
+		*/
+		get data() {
+			return this[kData];
+		}
+	};
+	Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
+	module.exports = {
+		CloseEvent,
+		ErrorEvent,
+		Event,
+		EventTarget: {
+			/**
+			* Register an event listener.
+			*
+			* @param {String} type A string representing the event type to listen for
+			* @param {(Function|Object)} handler The listener to add
+			* @param {Object} [options] An options object specifies characteristics about
+			*     the event listener
+			* @param {Boolean} [options.once=false] A `Boolean` indicating that the
+			*     listener should be invoked at most once after being added. If `true`,
+			*     the listener would be automatically removed when invoked.
+			* @public
+			*/
+			addEventListener(type, handler, options = {}) {
+				for (const listener of this.listeners(type)) if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) return;
+				let wrapper;
+				if (type === "message") wrapper = function onMessage(data, isBinary) {
+					const event = new MessageEvent("message", { data: isBinary ? data : data.toString() });
+					event[kTarget] = this;
+					callListener(handler, this, event);
+				};
+				else if (type === "close") wrapper = function onClose(code, message) {
+					const event = new CloseEvent("close", {
+						code,
+						reason: message.toString(),
+						wasClean: this._closeFrameReceived && this._closeFrameSent
+					});
+					event[kTarget] = this;
+					callListener(handler, this, event);
+				};
+				else if (type === "error") wrapper = function onError(error) {
+					const event = new ErrorEvent("error", {
+						error,
+						message: error.message
+					});
+					event[kTarget] = this;
+					callListener(handler, this, event);
+				};
+				else if (type === "open") wrapper = function onOpen() {
+					const event = new Event("open");
+					event[kTarget] = this;
+					callListener(handler, this, event);
+				};
+				else return;
+				wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
+				wrapper[kListener] = handler;
+				if (options.once) this.once(type, wrapper);
+				else this.on(type, wrapper);
+			},
+			/**
+			* Remove an event listener.
+			*
+			* @param {String} type A string representing the event type to remove
+			* @param {(Function|Object)} handler The listener to remove
+			* @public
+			*/
+			removeEventListener(type, handler) {
+				for (const listener of this.listeners(type)) if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+					this.removeListener(type, listener);
+					break;
+				}
+			}
+		},
+		MessageEvent
+	};
+	/**
+	* Call an event listener
+	*
+	* @param {(Function|Object)} listener The listener to call
+	* @param {*} thisArg The value to use as `this`` when calling the listener
+	* @param {Event} event The event to pass to the listener
+	* @private
+	*/
+	function callListener(listener, thisArg, event) {
+		if (typeof listener === "object" && listener.handleEvent) listener.handleEvent.call(listener, event);
+		else listener.call(thisArg, event);
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/extension.js
+var require_extension = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { tokenChars } = require_validation();
+	/**
+	* Adds an offer to the map of extension offers or a parameter to the map of
+	* parameters.
+	*
+	* @param {Object} dest The map of extension offers or parameters
+	* @param {String} name The extension or parameter name
+	* @param {(Object|Boolean|String)} elem The extension parameters or the
+	*     parameter value
+	* @private
+	*/
+	function push(dest, name, elem) {
+		if (dest[name] === void 0) dest[name] = [elem];
+		else dest[name].push(elem);
+	}
+	/**
+	* Parses the `Sec-WebSocket-Extensions` header into an object.
+	*
+	* @param {String} header The field value of the header
+	* @return {Object} The parsed object
+	* @public
+	*/
+	function parse(header) {
+		const offers = Object.create(null);
+		let params = Object.create(null);
+		let mustUnescape = false;
+		let isEscaping = false;
+		let inQuotes = false;
+		let extensionName;
+		let paramName;
+		let start = -1;
+		let code = -1;
+		let end = -1;
+		let i = 0;
+		for (; i < header.length; i++) {
+			code = header.charCodeAt(i);
+			if (extensionName === void 0) if (end === -1 && tokenChars[code] === 1) {
+				if (start === -1) start = i;
+			} else if (i !== 0 && (code === 32 || code === 9)) {
+				if (end === -1 && start !== -1) end = i;
+			} else if (code === 59 || code === 44) {
+				if (start === -1) throw new SyntaxError(`Unexpected character at index ${i}`);
+				if (end === -1) end = i;
+				const name = header.slice(start, end);
+				if (code === 44) {
+					push(offers, name, params);
+					params = Object.create(null);
+				} else extensionName = name;
+				start = end = -1;
+			} else throw new SyntaxError(`Unexpected character at index ${i}`);
+			else if (paramName === void 0) if (end === -1 && tokenChars[code] === 1) {
+				if (start === -1) start = i;
+			} else if (code === 32 || code === 9) {
+				if (end === -1 && start !== -1) end = i;
+			} else if (code === 59 || code === 44) {
+				if (start === -1) throw new SyntaxError(`Unexpected character at index ${i}`);
+				if (end === -1) end = i;
+				push(params, header.slice(start, end), true);
+				if (code === 44) {
+					push(offers, extensionName, params);
+					params = Object.create(null);
+					extensionName = void 0;
+				}
+				start = end = -1;
+			} else if (code === 61 && start !== -1 && end === -1) {
+				paramName = header.slice(start, i);
+				start = end = -1;
+			} else throw new SyntaxError(`Unexpected character at index ${i}`);
+			else if (isEscaping) {
+				if (tokenChars[code] !== 1) throw new SyntaxError(`Unexpected character at index ${i}`);
+				if (start === -1) start = i;
+				else if (!mustUnescape) mustUnescape = true;
+				isEscaping = false;
+			} else if (inQuotes) if (tokenChars[code] === 1) {
+				if (start === -1) start = i;
+			} else if (code === 34 && start !== -1) {
+				inQuotes = false;
+				end = i;
+			} else if (code === 92) isEscaping = true;
+			else throw new SyntaxError(`Unexpected character at index ${i}`);
+			else if (code === 34 && header.charCodeAt(i - 1) === 61) inQuotes = true;
+			else if (end === -1 && tokenChars[code] === 1) {
+				if (start === -1) start = i;
+			} else if (start !== -1 && (code === 32 || code === 9)) {
+				if (end === -1) end = i;
+			} else if (code === 59 || code === 44) {
+				if (start === -1) throw new SyntaxError(`Unexpected character at index ${i}`);
+				if (end === -1) end = i;
+				let value = header.slice(start, end);
+				if (mustUnescape) {
+					value = value.replace(/\\/g, "");
+					mustUnescape = false;
+				}
+				push(params, paramName, value);
+				if (code === 44) {
+					push(offers, extensionName, params);
+					params = Object.create(null);
+					extensionName = void 0;
+				}
+				paramName = void 0;
+				start = end = -1;
+			} else throw new SyntaxError(`Unexpected character at index ${i}`);
+		}
+		if (start === -1 || inQuotes || code === 32 || code === 9) throw new SyntaxError("Unexpected end of input");
+		if (end === -1) end = i;
+		const token = header.slice(start, end);
+		if (extensionName === void 0) push(offers, token, params);
+		else {
+			if (paramName === void 0) push(params, token, true);
+			else if (mustUnescape) push(params, paramName, token.replace(/\\/g, ""));
+			else push(params, paramName, token);
+			push(offers, extensionName, params);
+		}
+		return offers;
+	}
+	/**
+	* Builds the `Sec-WebSocket-Extensions` header field value.
+	*
+	* @param {Object} extensions The map of extensions and parameters to format
+	* @return {String} A string representing the given object
+	* @public
+	*/
+	function format(extensions) {
+		return Object.keys(extensions).map((extension) => {
+			let configurations = extensions[extension];
+			if (!Array.isArray(configurations)) configurations = [configurations];
+			return configurations.map((params) => {
+				return [extension].concat(Object.keys(params).map((k) => {
+					let values = params[k];
+					if (!Array.isArray(values)) values = [values];
+					return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
+				})).join("; ");
+			}).join(", ");
+		}).join(", ");
+	}
+	module.exports = {
+		format,
+		parse
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/websocket.js
+var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const EventEmitter$2 = __require("events");
+	const https$3 = __require("https");
+	const http$5 = __require("http");
+	const net$1 = __require("net");
+	const tls = __require("tls");
+	const { randomBytes, createHash: createHash$1 } = __require("crypto");
+	const { Duplex: Duplex$2, Readable } = __require("stream");
+	const { URL: URL$2 } = __require("url");
+	const PerMessageDeflate = require_permessage_deflate();
+	const Receiver = require_receiver();
+	const Sender = require_sender();
+	const { isBlob } = require_validation();
+	const { BINARY_TYPES, CLOSE_TIMEOUT, EMPTY_BUFFER, GUID, kForOnEventAttribute, kListener, kStatusCode, kWebSocket, NOOP } = require_constants();
+	const { EventTarget: { addEventListener, removeEventListener } } = require_event_target();
+	const { format, parse } = require_extension();
+	const { toBuffer } = require_buffer_util();
+	const kAborted = Symbol("kAborted");
+	const protocolVersions = [8, 13];
+	const readyStates = [
+		"CONNECTING",
+		"OPEN",
+		"CLOSING",
+		"CLOSED"
+	];
+	const subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+	/**
+	* Class representing a WebSocket.
+	*
+	* @extends EventEmitter
+	*/
+	var WebSocket = class WebSocket extends EventEmitter$2 {
+		/**
+		* Create a new `WebSocket`.
+		*
+		* @param {(String|URL)} address The URL to which to connect
+		* @param {(String|String[])} [protocols] The subprotocols
+		* @param {Object} [options] Connection options
+		*/
+		constructor(address, protocols, options) {
+			super();
+			this._binaryType = BINARY_TYPES[0];
+			this._closeCode = 1006;
+			this._closeFrameReceived = false;
+			this._closeFrameSent = false;
+			this._closeMessage = EMPTY_BUFFER;
+			this._closeTimer = null;
+			this._errorEmitted = false;
+			this._extensions = {};
+			this._paused = false;
+			this._protocol = "";
+			this._readyState = WebSocket.CONNECTING;
+			this._receiver = null;
+			this._sender = null;
+			this._socket = null;
+			if (address !== null) {
+				this._bufferedAmount = 0;
+				this._isServer = false;
+				this._redirects = 0;
+				if (protocols === void 0) protocols = [];
+				else if (!Array.isArray(protocols)) if (typeof protocols === "object" && protocols !== null) {
+					options = protocols;
+					protocols = [];
+				} else protocols = [protocols];
+				initAsClient(this, address, protocols, options);
+			} else {
+				this._autoPong = options.autoPong;
+				this._closeTimeout = options.closeTimeout;
+				this._isServer = true;
+			}
+		}
+		/**
+		* For historical reasons, the custom "nodebuffer" type is used by the default
+		* instead of "blob".
+		*
+		* @type {String}
+		*/
+		get binaryType() {
+			return this._binaryType;
+		}
+		set binaryType(type) {
+			if (!BINARY_TYPES.includes(type)) return;
+			this._binaryType = type;
+			if (this._receiver) this._receiver._binaryType = type;
+		}
+		/**
+		* @type {Number}
+		*/
+		get bufferedAmount() {
+			if (!this._socket) return this._bufferedAmount;
+			return this._socket._writableState.length + this._sender._bufferedBytes;
+		}
+		/**
+		* @type {String}
+		*/
+		get extensions() {
+			return Object.keys(this._extensions).join();
+		}
+		/**
+		* @type {Boolean}
+		*/
+		get isPaused() {
+			return this._paused;
+		}
+		/**
+		* @type {Function}
+		*/
+		/* istanbul ignore next */
+		get onclose() {
+			return null;
+		}
+		/**
+		* @type {Function}
+		*/
+		/* istanbul ignore next */
+		get onerror() {
+			return null;
+		}
+		/**
+		* @type {Function}
+		*/
+		/* istanbul ignore next */
+		get onopen() {
+			return null;
+		}
+		/**
+		* @type {Function}
+		*/
+		/* istanbul ignore next */
+		get onmessage() {
+			return null;
+		}
+		/**
+		* @type {String}
+		*/
+		get protocol() {
+			return this._protocol;
+		}
+		/**
+		* @type {Number}
+		*/
+		get readyState() {
+			return this._readyState;
+		}
+		/**
+		* @type {String}
+		*/
+		get url() {
+			return this._url;
+		}
+		/**
+		* Set up the socket and the internal resources.
+		*
+		* @param {Duplex} socket The network socket between the server and client
+		* @param {Buffer} head The first packet of the upgraded stream
+		* @param {Object} options Options object
+		* @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
+		*     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+		*     multiple times in the same tick
+		* @param {Function} [options.generateMask] The function used to generate the
+		*     masking key
+		* @param {Number} [options.maxPayload=0] The maximum allowed message size
+		* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+		*     not to skip UTF-8 validation for text and close messages
+		* @private
+		*/
+		setSocket(socket, head, options) {
+			const receiver = new Receiver({
+				allowSynchronousEvents: options.allowSynchronousEvents,
+				binaryType: this.binaryType,
+				extensions: this._extensions,
+				isServer: this._isServer,
+				maxPayload: options.maxPayload,
+				skipUTF8Validation: options.skipUTF8Validation
+			});
+			const sender = new Sender(socket, this._extensions, options.generateMask);
+			this._receiver = receiver;
+			this._sender = sender;
+			this._socket = socket;
+			receiver[kWebSocket] = this;
+			sender[kWebSocket] = this;
+			socket[kWebSocket] = this;
+			receiver.on("conclude", receiverOnConclude);
+			receiver.on("drain", receiverOnDrain);
+			receiver.on("error", receiverOnError);
+			receiver.on("message", receiverOnMessage);
+			receiver.on("ping", receiverOnPing);
+			receiver.on("pong", receiverOnPong);
+			sender.onerror = senderOnError;
+			if (socket.setTimeout) socket.setTimeout(0);
+			if (socket.setNoDelay) socket.setNoDelay();
+			if (head.length > 0) socket.unshift(head);
+			socket.on("close", socketOnClose);
+			socket.on("data", socketOnData);
+			socket.on("end", socketOnEnd);
+			socket.on("error", socketOnError);
+			this._readyState = WebSocket.OPEN;
+			this.emit("open");
+		}
+		/**
+		* Emit the `'close'` event.
+		*
+		* @private
+		*/
+		emitClose() {
+			if (!this._socket) {
+				this._readyState = WebSocket.CLOSED;
+				this.emit("close", this._closeCode, this._closeMessage);
+				return;
+			}
+			if (this._extensions[PerMessageDeflate.extensionName]) this._extensions[PerMessageDeflate.extensionName].cleanup();
+			this._receiver.removeAllListeners();
+			this._readyState = WebSocket.CLOSED;
+			this.emit("close", this._closeCode, this._closeMessage);
+		}
+		/**
+		* Start a closing handshake.
+		*
+		*          +----------+   +-----------+   +----------+
+		*     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
+		*    |     +----------+   +-----------+   +----------+     |
+		*          +----------+   +-----------+         |
+		* CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
+		*          +----------+   +-----------+   |
+		*    |           |                        |   +---+        |
+		*                +------------------------+-->|fin| - - - -
+		*    |         +---+                      |   +---+
+		*     - - - - -|fin|<---------------------+
+		*              +---+
+		*
+		* @param {Number} [code] Status code explaining why the connection is closing
+		* @param {(String|Buffer)} [data] The reason why the connection is
+		*     closing
+		* @public
+		*/
+		close(code, data) {
+			if (this.readyState === WebSocket.CLOSED) return;
+			if (this.readyState === WebSocket.CONNECTING) {
+				abortHandshake(this, this._req, "WebSocket was closed before the connection was established");
+				return;
+			}
+			if (this.readyState === WebSocket.CLOSING) {
+				if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) this._socket.end();
+				return;
+			}
+			this._readyState = WebSocket.CLOSING;
+			this._sender.close(code, data, !this._isServer, (err) => {
+				if (err) return;
+				this._closeFrameSent = true;
+				if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) this._socket.end();
+			});
+			setCloseTimer(this);
+		}
+		/**
+		* Pause the socket.
+		*
+		* @public
+		*/
+		pause() {
+			if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) return;
+			this._paused = true;
+			this._socket.pause();
+		}
+		/**
+		* Send a ping.
+		*
+		* @param {*} [data] The data to send
+		* @param {Boolean} [mask] Indicates whether or not to mask `data`
+		* @param {Function} [cb] Callback which is executed when the ping is sent
+		* @public
+		*/
+		ping(data, mask, cb) {
+			if (this.readyState === WebSocket.CONNECTING) throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+			if (typeof data === "function") {
+				cb = data;
+				data = mask = void 0;
+			} else if (typeof mask === "function") {
+				cb = mask;
+				mask = void 0;
+			}
+			if (typeof data === "number") data = data.toString();
+			if (this.readyState !== WebSocket.OPEN) {
+				sendAfterClose(this, data, cb);
+				return;
+			}
+			if (mask === void 0) mask = !this._isServer;
+			this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+		}
+		/**
+		* Send a pong.
+		*
+		* @param {*} [data] The data to send
+		* @param {Boolean} [mask] Indicates whether or not to mask `data`
+		* @param {Function} [cb] Callback which is executed when the pong is sent
+		* @public
+		*/
+		pong(data, mask, cb) {
+			if (this.readyState === WebSocket.CONNECTING) throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+			if (typeof data === "function") {
+				cb = data;
+				data = mask = void 0;
+			} else if (typeof mask === "function") {
+				cb = mask;
+				mask = void 0;
+			}
+			if (typeof data === "number") data = data.toString();
+			if (this.readyState !== WebSocket.OPEN) {
+				sendAfterClose(this, data, cb);
+				return;
+			}
+			if (mask === void 0) mask = !this._isServer;
+			this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+		}
+		/**
+		* Resume the socket.
+		*
+		* @public
+		*/
+		resume() {
+			if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) return;
+			this._paused = false;
+			if (!this._receiver._writableState.needDrain) this._socket.resume();
+		}
+		/**
+		* Send a data message.
+		*
+		* @param {*} data The message to send
+		* @param {Object} [options] Options object
+		* @param {Boolean} [options.binary] Specifies whether `data` is binary or
+		*     text
+		* @param {Boolean} [options.compress] Specifies whether or not to compress
+		*     `data`
+		* @param {Boolean} [options.fin=true] Specifies whether the fragment is the
+		*     last one
+		* @param {Boolean} [options.mask] Specifies whether or not to mask `data`
+		* @param {Function} [cb] Callback which is executed when data is written out
+		* @public
+		*/
+		send(data, options, cb) {
+			if (this.readyState === WebSocket.CONNECTING) throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+			if (typeof data === "number") data = data.toString();
+			if (this.readyState !== WebSocket.OPEN) {
+				sendAfterClose(this, data, cb);
+				return;
+			}
+			const opts = {
+				binary: typeof data !== "string",
+				mask: !this._isServer,
+				compress: true,
+				fin: true,
+				...options
+			};
+			if (!this._extensions[PerMessageDeflate.extensionName]) opts.compress = false;
+			this._sender.send(data || EMPTY_BUFFER, opts, cb);
+		}
+		/**
+		* Forcibly close the connection.
+		*
+		* @public
+		*/
+		terminate() {
+			if (this.readyState === WebSocket.CLOSED) return;
+			if (this.readyState === WebSocket.CONNECTING) {
+				abortHandshake(this, this._req, "WebSocket was closed before the connection was established");
+				return;
+			}
+			if (this._socket) {
+				this._readyState = WebSocket.CLOSING;
+				this._socket.destroy();
+			}
+		}
+	};
+	/**
+	* @constant {Number} CONNECTING
+	* @memberof WebSocket
+	*/
+	Object.defineProperty(WebSocket, "CONNECTING", {
+		enumerable: true,
+		value: readyStates.indexOf("CONNECTING")
+	});
+	/**
+	* @constant {Number} CONNECTING
+	* @memberof WebSocket.prototype
+	*/
+	Object.defineProperty(WebSocket.prototype, "CONNECTING", {
+		enumerable: true,
+		value: readyStates.indexOf("CONNECTING")
+	});
+	/**
+	* @constant {Number} OPEN
+	* @memberof WebSocket
+	*/
+	Object.defineProperty(WebSocket, "OPEN", {
+		enumerable: true,
+		value: readyStates.indexOf("OPEN")
+	});
+	/**
+	* @constant {Number} OPEN
+	* @memberof WebSocket.prototype
+	*/
+	Object.defineProperty(WebSocket.prototype, "OPEN", {
+		enumerable: true,
+		value: readyStates.indexOf("OPEN")
+	});
+	/**
+	* @constant {Number} CLOSING
+	* @memberof WebSocket
+	*/
+	Object.defineProperty(WebSocket, "CLOSING", {
+		enumerable: true,
+		value: readyStates.indexOf("CLOSING")
+	});
+	/**
+	* @constant {Number} CLOSING
+	* @memberof WebSocket.prototype
+	*/
+	Object.defineProperty(WebSocket.prototype, "CLOSING", {
+		enumerable: true,
+		value: readyStates.indexOf("CLOSING")
+	});
+	/**
+	* @constant {Number} CLOSED
+	* @memberof WebSocket
+	*/
+	Object.defineProperty(WebSocket, "CLOSED", {
+		enumerable: true,
+		value: readyStates.indexOf("CLOSED")
+	});
+	/**
+	* @constant {Number} CLOSED
+	* @memberof WebSocket.prototype
+	*/
+	Object.defineProperty(WebSocket.prototype, "CLOSED", {
+		enumerable: true,
+		value: readyStates.indexOf("CLOSED")
+	});
+	[
+		"binaryType",
+		"bufferedAmount",
+		"extensions",
+		"isPaused",
+		"protocol",
+		"readyState",
+		"url"
+	].forEach((property) => {
+		Object.defineProperty(WebSocket.prototype, property, { enumerable: true });
+	});
+	[
+		"open",
+		"error",
+		"close",
+		"message"
+	].forEach((method) => {
+		Object.defineProperty(WebSocket.prototype, `on${method}`, {
+			enumerable: true,
+			get() {
+				for (const listener of this.listeners(method)) if (listener[kForOnEventAttribute]) return listener[kListener];
+				return null;
+			},
+			set(handler) {
+				for (const listener of this.listeners(method)) if (listener[kForOnEventAttribute]) {
+					this.removeListener(method, listener);
+					break;
+				}
+				if (typeof handler !== "function") return;
+				this.addEventListener(method, handler, { [kForOnEventAttribute]: true });
+			}
+		});
+	});
+	WebSocket.prototype.addEventListener = addEventListener;
+	WebSocket.prototype.removeEventListener = removeEventListener;
+	module.exports = WebSocket;
+	/**
+	* Initialize a WebSocket client.
+	*
+	* @param {WebSocket} websocket The client to initialize
+	* @param {(String|URL)} address The URL to which to connect
+	* @param {Array} protocols The subprotocols
+	* @param {Object} [options] Connection options
+	* @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether any
+	*     of the `'message'`, `'ping'`, and `'pong'` events can be emitted multiple
+	*     times in the same tick
+	* @param {Boolean} [options.autoPong=true] Specifies whether or not to
+	*     automatically send a pong in response to a ping
+	* @param {Number} [options.closeTimeout=30000] Duration in milliseconds to wait
+	*     for the closing handshake to finish after `websocket.close()` is called
+	* @param {Function} [options.finishRequest] A function which can be used to
+	*     customize the headers of each http request before it is sent
+	* @param {Boolean} [options.followRedirects=false] Whether or not to follow
+	*     redirects
+	* @param {Function} [options.generateMask] The function used to generate the
+	*     masking key
+	* @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the
+	*     handshake request
+	* @param {Number} [options.maxPayload=104857600] The maximum allowed message
+	*     size
+	* @param {Number} [options.maxRedirects=10] The maximum number of redirects
+	*     allowed
+	* @param {String} [options.origin] Value of the `Origin` or
+	*     `Sec-WebSocket-Origin` header
+	* @param {(Boolean|Object)} [options.perMessageDeflate=true] Enable/disable
+	*     permessage-deflate
+	* @param {Number} [options.protocolVersion=13] Value of the
+	*     `Sec-WebSocket-Version` header
+	* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+	*     not to skip UTF-8 validation for text and close messages
+	* @private
+	*/
+	function initAsClient(websocket, address, protocols, options) {
+		const opts = {
+			allowSynchronousEvents: true,
+			autoPong: true,
+			closeTimeout: CLOSE_TIMEOUT,
+			protocolVersion: protocolVersions[1],
+			maxPayload: 100 * 1024 * 1024,
+			skipUTF8Validation: false,
+			perMessageDeflate: true,
+			followRedirects: false,
+			maxRedirects: 10,
+			...options,
+			socketPath: void 0,
+			hostname: void 0,
+			protocol: void 0,
+			timeout: void 0,
+			method: "GET",
+			host: void 0,
+			path: void 0,
+			port: void 0
+		};
+		websocket._autoPong = opts.autoPong;
+		websocket._closeTimeout = opts.closeTimeout;
+		if (!protocolVersions.includes(opts.protocolVersion)) throw new RangeError(`Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`);
+		let parsedUrl;
+		if (address instanceof URL$2) parsedUrl = address;
+		else try {
+			parsedUrl = new URL$2(address);
+		} catch {
+			throw new SyntaxError(`Invalid URL: ${address}`);
+		}
+		if (parsedUrl.protocol === "http:") parsedUrl.protocol = "ws:";
+		else if (parsedUrl.protocol === "https:") parsedUrl.protocol = "wss:";
+		websocket._url = parsedUrl.href;
+		const isSecure = parsedUrl.protocol === "wss:";
+		const isIpcUrl = parsedUrl.protocol === "ws+unix:";
+		let invalidUrlMessage;
+		if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) invalidUrlMessage = "The URL's protocol must be one of \"ws:\", \"wss:\", \"http:\", \"https:\", or \"ws+unix:\"";
+		else if (isIpcUrl && !parsedUrl.pathname) invalidUrlMessage = "The URL's pathname is empty";
+		else if (parsedUrl.hash) invalidUrlMessage = "The URL contains a fragment identifier";
+		if (invalidUrlMessage) {
+			const err = new SyntaxError(invalidUrlMessage);
+			if (websocket._redirects === 0) throw err;
+			else {
+				emitErrorAndClose(websocket, err);
+				return;
+			}
+		}
+		const defaultPort = isSecure ? 443 : 80;
+		const key = randomBytes(16).toString("base64");
+		const request = isSecure ? https$3.request : http$5.request;
+		const protocolSet = /* @__PURE__ */ new Set();
+		let perMessageDeflate;
+		opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
+		opts.defaultPort = opts.defaultPort || defaultPort;
+		opts.port = parsedUrl.port || defaultPort;
+		opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
+		opts.headers = {
+			...opts.headers,
+			"Sec-WebSocket-Version": opts.protocolVersion,
+			"Sec-WebSocket-Key": key,
+			Connection: "Upgrade",
+			Upgrade: "websocket"
+		};
+		opts.path = parsedUrl.pathname + parsedUrl.search;
+		opts.timeout = opts.handshakeTimeout;
+		if (opts.perMessageDeflate) {
+			perMessageDeflate = new PerMessageDeflate({
+				...opts.perMessageDeflate,
+				isServer: false,
+				maxPayload: opts.maxPayload
+			});
+			opts.headers["Sec-WebSocket-Extensions"] = format({ [PerMessageDeflate.extensionName]: perMessageDeflate.offer() });
+		}
+		if (protocols.length) {
+			for (const protocol of protocols) {
+				if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) throw new SyntaxError("An invalid or duplicated subprotocol was specified");
+				protocolSet.add(protocol);
+			}
+			opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
+		}
+		if (opts.origin) if (opts.protocolVersion < 13) opts.headers["Sec-WebSocket-Origin"] = opts.origin;
+		else opts.headers.Origin = opts.origin;
+		if (parsedUrl.username || parsedUrl.password) opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+		if (isIpcUrl) {
+			const parts = opts.path.split(":");
+			opts.socketPath = parts[0];
+			opts.path = parts[1];
+		}
+		let req;
+		if (opts.followRedirects) {
+			if (websocket._redirects === 0) {
+				websocket._originalIpc = isIpcUrl;
+				websocket._originalSecure = isSecure;
+				websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
+				const headers = options && options.headers;
+				options = {
+					...options,
+					headers: {}
+				};
+				if (headers) for (const [key, value] of Object.entries(headers)) options.headers[key.toLowerCase()] = value;
+			} else if (websocket.listenerCount("redirect") === 0) {
+				const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
+				if (!isSameHost || websocket._originalSecure && !isSecure) {
+					delete opts.headers.authorization;
+					delete opts.headers.cookie;
+					if (!isSameHost) delete opts.headers.host;
+					opts.auth = void 0;
+				}
+			}
+			if (opts.auth && !options.headers.authorization) options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
+			req = websocket._req = request(opts);
+			if (websocket._redirects) websocket.emit("redirect", websocket.url, req);
+		} else req = websocket._req = request(opts);
+		if (opts.timeout) req.on("timeout", () => {
+			abortHandshake(websocket, req, "Opening handshake has timed out");
+		});
+		req.on("error", (err) => {
+			if (req === null || req[kAborted]) return;
+			req = websocket._req = null;
+			emitErrorAndClose(websocket, err);
+		});
+		req.on("response", (res) => {
+			const location = res.headers.location;
+			const statusCode = res.statusCode;
+			if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
+				if (++websocket._redirects > opts.maxRedirects) {
+					abortHandshake(websocket, req, "Maximum redirects exceeded");
+					return;
+				}
+				req.abort();
+				let addr;
+				try {
+					addr = new URL$2(location, address);
+				} catch (e) {
+					emitErrorAndClose(websocket, /* @__PURE__ */ new SyntaxError(`Invalid URL: ${location}`));
+					return;
+				}
+				initAsClient(websocket, addr, protocols, options);
+			} else if (!websocket.emit("unexpected-response", req, res)) abortHandshake(websocket, req, `Unexpected server response: ${res.statusCode}`);
+		});
+		req.on("upgrade", (res, socket, head) => {
+			websocket.emit("upgrade", res);
+			if (websocket.readyState !== WebSocket.CONNECTING) return;
+			req = websocket._req = null;
+			const upgrade = res.headers.upgrade;
+			if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
+				abortHandshake(websocket, socket, "Invalid Upgrade header");
+				return;
+			}
+			const digest = createHash$1("sha1").update(key + GUID).digest("base64");
+			if (res.headers["sec-websocket-accept"] !== digest) {
+				abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
+				return;
+			}
+			const serverProt = res.headers["sec-websocket-protocol"];
+			let protError;
+			if (serverProt !== void 0) {
+				if (!protocolSet.size) protError = "Server sent a subprotocol but none was requested";
+				else if (!protocolSet.has(serverProt)) protError = "Server sent an invalid subprotocol";
+			} else if (protocolSet.size) protError = "Server sent no subprotocol";
+			if (protError) {
+				abortHandshake(websocket, socket, protError);
+				return;
+			}
+			if (serverProt) websocket._protocol = serverProt;
+			const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
+			if (secWebSocketExtensions !== void 0) {
+				if (!perMessageDeflate) {
+					abortHandshake(websocket, socket, "Server sent a Sec-WebSocket-Extensions header but no extension was requested");
+					return;
+				}
+				let extensions;
+				try {
+					extensions = parse(secWebSocketExtensions);
+				} catch (err) {
+					abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Extensions header");
+					return;
+				}
+				const extensionNames = Object.keys(extensions);
+				if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
+					abortHandshake(websocket, socket, "Server indicated an extension that was not requested");
+					return;
+				}
+				try {
+					perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+				} catch (err) {
+					abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Extensions header");
+					return;
+				}
+				websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+			}
+			websocket.setSocket(socket, head, {
+				allowSynchronousEvents: opts.allowSynchronousEvents,
+				generateMask: opts.generateMask,
+				maxPayload: opts.maxPayload,
+				skipUTF8Validation: opts.skipUTF8Validation
+			});
+		});
+		if (opts.finishRequest) opts.finishRequest(req, websocket);
+		else req.end();
+	}
+	/**
+	* Emit the `'error'` and `'close'` events.
+	*
+	* @param {WebSocket} websocket The WebSocket instance
+	* @param {Error} The error to emit
+	* @private
+	*/
+	function emitErrorAndClose(websocket, err) {
+		websocket._readyState = WebSocket.CLOSING;
+		websocket._errorEmitted = true;
+		websocket.emit("error", err);
+		websocket.emitClose();
+	}
+	/**
+	* Create a `net.Socket` and initiate a connection.
+	*
+	* @param {Object} options Connection options
+	* @return {net.Socket} The newly created socket used to start the connection
+	* @private
+	*/
+	function netConnect(options) {
+		options.path = options.socketPath;
+		return net$1.connect(options);
+	}
+	/**
+	* Create a `tls.TLSSocket` and initiate a connection.
+	*
+	* @param {Object} options Connection options
+	* @return {tls.TLSSocket} The newly created socket used to start the connection
+	* @private
+	*/
+	function tlsConnect(options) {
+		options.path = void 0;
+		if (!options.servername && options.servername !== "") options.servername = net$1.isIP(options.host) ? "" : options.host;
+		return tls.connect(options);
+	}
+	/**
+	* Abort the handshake and emit an error.
+	*
+	* @param {WebSocket} websocket The WebSocket instance
+	* @param {(http.ClientRequest|net.Socket|tls.Socket)} stream The request to
+	*     abort or the socket to destroy
+	* @param {String} message The error message
+	* @private
+	*/
+	function abortHandshake(websocket, stream, message) {
+		websocket._readyState = WebSocket.CLOSING;
+		const err = new Error(message);
+		Error.captureStackTrace(err, abortHandshake);
+		if (stream.setHeader) {
+			stream[kAborted] = true;
+			stream.abort();
+			if (stream.socket && !stream.socket.destroyed) stream.socket.destroy();
+			process.nextTick(emitErrorAndClose, websocket, err);
+		} else {
+			stream.destroy(err);
+			stream.once("error", websocket.emit.bind(websocket, "error"));
+			stream.once("close", websocket.emitClose.bind(websocket));
+		}
+	}
+	/**
+	* Handle cases where the `ping()`, `pong()`, or `send()` methods are called
+	* when the `readyState` attribute is `CLOSING` or `CLOSED`.
+	*
+	* @param {WebSocket} websocket The WebSocket instance
+	* @param {*} [data] The data to send
+	* @param {Function} [cb] Callback
+	* @private
+	*/
+	function sendAfterClose(websocket, data, cb) {
+		if (data) {
+			const length = isBlob(data) ? data.size : toBuffer(data).length;
+			if (websocket._socket) websocket._sender._bufferedBytes += length;
+			else websocket._bufferedAmount += length;
+		}
+		if (cb) {
+			const err = /* @__PURE__ */ new Error(`WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`);
+			process.nextTick(cb, err);
+		}
+	}
+	/**
+	* The listener of the `Receiver` `'conclude'` event.
+	*
+	* @param {Number} code The status code
+	* @param {Buffer} reason The reason for closing
+	* @private
+	*/
+	function receiverOnConclude(code, reason) {
+		const websocket = this[kWebSocket];
+		websocket._closeFrameReceived = true;
+		websocket._closeMessage = reason;
+		websocket._closeCode = code;
+		if (websocket._socket[kWebSocket] === void 0) return;
+		websocket._socket.removeListener("data", socketOnData);
+		process.nextTick(resume, websocket._socket);
+		if (code === 1005) websocket.close();
+		else websocket.close(code, reason);
+	}
+	/**
+	* The listener of the `Receiver` `'drain'` event.
+	*
+	* @private
+	*/
+	function receiverOnDrain() {
+		const websocket = this[kWebSocket];
+		if (!websocket.isPaused) websocket._socket.resume();
+	}
+	/**
+	* The listener of the `Receiver` `'error'` event.
+	*
+	* @param {(RangeError|Error)} err The emitted error
+	* @private
+	*/
+	function receiverOnError(err) {
+		const websocket = this[kWebSocket];
+		if (websocket._socket[kWebSocket] !== void 0) {
+			websocket._socket.removeListener("data", socketOnData);
+			process.nextTick(resume, websocket._socket);
+			websocket.close(err[kStatusCode]);
+		}
+		if (!websocket._errorEmitted) {
+			websocket._errorEmitted = true;
+			websocket.emit("error", err);
+		}
+	}
+	/**
+	* The listener of the `Receiver` `'finish'` event.
+	*
+	* @private
+	*/
+	function receiverOnFinish() {
+		this[kWebSocket].emitClose();
+	}
+	/**
+	* The listener of the `Receiver` `'message'` event.
+	*
+	* @param {Buffer|ArrayBuffer|Buffer[])} data The message
+	* @param {Boolean} isBinary Specifies whether the message is binary or not
+	* @private
+	*/
+	function receiverOnMessage(data, isBinary) {
+		this[kWebSocket].emit("message", data, isBinary);
+	}
+	/**
+	* The listener of the `Receiver` `'ping'` event.
+	*
+	* @param {Buffer} data The data included in the ping frame
+	* @private
+	*/
+	function receiverOnPing(data) {
+		const websocket = this[kWebSocket];
+		if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
+		websocket.emit("ping", data);
+	}
+	/**
+	* The listener of the `Receiver` `'pong'` event.
+	*
+	* @param {Buffer} data The data included in the pong frame
+	* @private
+	*/
+	function receiverOnPong(data) {
+		this[kWebSocket].emit("pong", data);
+	}
+	/**
+	* Resume a readable stream
+	*
+	* @param {Readable} stream The readable stream
+	* @private
+	*/
+	function resume(stream) {
+		stream.resume();
+	}
+	/**
+	* The `Sender` error event handler.
+	*
+	* @param {Error} The error
+	* @private
+	*/
+	function senderOnError(err) {
+		const websocket = this[kWebSocket];
+		if (websocket.readyState === WebSocket.CLOSED) return;
+		if (websocket.readyState === WebSocket.OPEN) {
+			websocket._readyState = WebSocket.CLOSING;
+			setCloseTimer(websocket);
+		}
+		this._socket.end();
+		if (!websocket._errorEmitted) {
+			websocket._errorEmitted = true;
+			websocket.emit("error", err);
+		}
+	}
+	/**
+	* Set a timer to destroy the underlying raw socket of a WebSocket.
+	*
+	* @param {WebSocket} websocket The WebSocket instance
+	* @private
+	*/
+	function setCloseTimer(websocket) {
+		websocket._closeTimer = setTimeout(websocket._socket.destroy.bind(websocket._socket), websocket._closeTimeout);
+	}
+	/**
+	* The listener of the socket `'close'` event.
+	*
+	* @private
+	*/
+	function socketOnClose() {
+		const websocket = this[kWebSocket];
+		this.removeListener("close", socketOnClose);
+		this.removeListener("data", socketOnData);
+		this.removeListener("end", socketOnEnd);
+		websocket._readyState = WebSocket.CLOSING;
+		if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && this._readableState.length !== 0) {
+			const chunk = this.read(this._readableState.length);
+			websocket._receiver.write(chunk);
+		}
+		websocket._receiver.end();
+		this[kWebSocket] = void 0;
+		clearTimeout(websocket._closeTimer);
+		if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) websocket.emitClose();
+		else {
+			websocket._receiver.on("error", receiverOnFinish);
+			websocket._receiver.on("finish", receiverOnFinish);
+		}
+	}
+	/**
+	* The listener of the socket `'data'` event.
+	*
+	* @param {Buffer} chunk A chunk of data
+	* @private
+	*/
+	function socketOnData(chunk) {
+		if (!this[kWebSocket]._receiver.write(chunk)) this.pause();
+	}
+	/**
+	* The listener of the socket `'end'` event.
+	*
+	* @private
+	*/
+	function socketOnEnd() {
+		const websocket = this[kWebSocket];
+		websocket._readyState = WebSocket.CLOSING;
+		websocket._receiver.end();
+		this.end();
+	}
+	/**
+	* The listener of the socket `'error'` event.
+	*
+	* @private
+	*/
+	function socketOnError() {
+		const websocket = this[kWebSocket];
+		this.removeListener("error", socketOnError);
+		this.on("error", NOOP);
+		if (websocket) {
+			websocket._readyState = WebSocket.CLOSING;
+			this.destroy();
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/stream.js
+var require_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	require_websocket();
+	const { Duplex: Duplex$1 } = __require("stream");
+	/**
+	* Emits the `'close'` event on a stream.
+	*
+	* @param {Duplex} stream The stream.
+	* @private
+	*/
+	function emitClose(stream) {
+		stream.emit("close");
+	}
+	/**
+	* The listener of the `'end'` event.
+	*
+	* @private
+	*/
+	function duplexOnEnd() {
+		if (!this.destroyed && this._writableState.finished) this.destroy();
+	}
+	/**
+	* The listener of the `'error'` event.
+	*
+	* @param {Error} err The error
+	* @private
+	*/
+	function duplexOnError(err) {
+		this.removeListener("error", duplexOnError);
+		this.destroy();
+		if (this.listenerCount("error") === 0) this.emit("error", err);
+	}
+	/**
+	* Wraps a `WebSocket` in a duplex stream.
+	*
+	* @param {WebSocket} ws The `WebSocket` to wrap
+	* @param {Object} [options] The options for the `Duplex` constructor
+	* @return {Duplex} The duplex stream
+	* @public
+	*/
+	function createWebSocketStream(ws, options) {
+		let terminateOnDestroy = true;
+		const duplex = new Duplex$1({
+			...options,
+			autoDestroy: false,
+			emitClose: false,
+			objectMode: false,
+			writableObjectMode: false
+		});
+		ws.on("message", function message(msg, isBinary) {
+			const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+			if (!duplex.push(data)) ws.pause();
+		});
+		ws.once("error", function error(err) {
+			if (duplex.destroyed) return;
+			terminateOnDestroy = false;
+			duplex.destroy(err);
+		});
+		ws.once("close", function close() {
+			if (duplex.destroyed) return;
+			duplex.push(null);
+		});
+		duplex._destroy = function(err, callback) {
+			if (ws.readyState === ws.CLOSED) {
+				callback(err);
+				process.nextTick(emitClose, duplex);
+				return;
+			}
+			let called = false;
+			ws.once("error", function error(err) {
+				called = true;
+				callback(err);
+			});
+			ws.once("close", function close() {
+				if (!called) callback(err);
+				process.nextTick(emitClose, duplex);
+			});
+			if (terminateOnDestroy) ws.terminate();
+		};
+		duplex._final = function(callback) {
+			if (ws.readyState === ws.CONNECTING) {
+				ws.once("open", function open() {
+					duplex._final(callback);
+				});
+				return;
+			}
+			if (ws._socket === null) return;
+			if (ws._socket._writableState.finished) {
+				callback();
+				if (duplex._readableState.endEmitted) duplex.destroy();
+			} else {
+				ws._socket.once("finish", function finish() {
+					callback();
+				});
+				ws.close();
+			}
+		};
+		duplex._read = function() {
+			if (ws.isPaused) ws.resume();
+		};
+		duplex._write = function(chunk, encoding, callback) {
+			if (ws.readyState === ws.CONNECTING) {
+				ws.once("open", function open() {
+					duplex._write(chunk, encoding, callback);
+				});
+				return;
+			}
+			ws.send(chunk, callback);
+		};
+		duplex.on("end", duplexOnEnd);
+		duplex.on("error", duplexOnError);
+		return duplex;
+	}
+	module.exports = createWebSocketStream;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/subprotocol.js
+var require_subprotocol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { tokenChars } = require_validation();
+	/**
+	* Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
+	*
+	* @param {String} header The field value of the header
+	* @return {Set} The subprotocol names
+	* @public
+	*/
+	function parse(header) {
+		const protocols = /* @__PURE__ */ new Set();
+		let start = -1;
+		let end = -1;
+		let i = 0;
+		for (; i < header.length; i++) {
+			const code = header.charCodeAt(i);
+			if (end === -1 && tokenChars[code] === 1) {
+				if (start === -1) start = i;
+			} else if (i !== 0 && (code === 32 || code === 9)) {
+				if (end === -1 && start !== -1) end = i;
+			} else if (code === 44) {
+				if (start === -1) throw new SyntaxError(`Unexpected character at index ${i}`);
+				if (end === -1) end = i;
+				const protocol = header.slice(start, end);
+				if (protocols.has(protocol)) throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+				protocols.add(protocol);
+				start = end = -1;
+			} else throw new SyntaxError(`Unexpected character at index ${i}`);
+		}
+		if (start === -1 || end !== -1) throw new SyntaxError("Unexpected end of input");
+		const protocol = header.slice(start, i);
+		if (protocols.has(protocol)) throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+		protocols.add(protocol);
+		return protocols;
+	}
+	module.exports = { parse };
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/websocket-server.js
+var require_websocket_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const EventEmitter$1 = __require("events");
+	const http$4 = __require("http");
+	const { Duplex } = __require("stream");
+	const { createHash } = __require("crypto");
+	const extension = require_extension();
+	const PerMessageDeflate = require_permessage_deflate();
+	const subprotocol = require_subprotocol();
+	const WebSocket = require_websocket();
+	const { CLOSE_TIMEOUT, GUID, kWebSocket } = require_constants();
+	const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+	const RUNNING = 0;
+	const CLOSING = 1;
+	const CLOSED = 2;
+	/**
+	* Class representing a WebSocket server.
+	*
+	* @extends EventEmitter
+	*/
+	var WebSocketServer = class extends EventEmitter$1 {
+		/**
+		* Create a `WebSocketServer` instance.
+		*
+		* @param {Object} options Configuration options
+		* @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+		*     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+		*     multiple times in the same tick
+		* @param {Boolean} [options.autoPong=true] Specifies whether or not to
+		*     automatically send a pong in response to a ping
+		* @param {Number} [options.backlog=511] The maximum length of the queue of
+		*     pending connections
+		* @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+		*     track clients
+		* @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
+		*     wait for the closing handshake to finish after `websocket.close()` is
+		*     called
+		* @param {Function} [options.handleProtocols] A hook to handle protocols
+		* @param {String} [options.host] The hostname where to bind the server
+		* @param {Number} [options.maxPayload=104857600] The maximum allowed message
+		*     size
+		* @param {Boolean} [options.noServer=false] Enable no server mode
+		* @param {String} [options.path] Accept only connections matching this path
+		* @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
+		*     permessage-deflate
+		* @param {Number} [options.port] The port where to bind the server
+		* @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
+		*     server to use
+		* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+		*     not to skip UTF-8 validation for text and close messages
+		* @param {Function} [options.verifyClient] A hook to reject connections
+		* @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
+		*     class to use. It must be the `WebSocket` class or class that extends it
+		* @param {Function} [callback] A listener for the `listening` event
+		*/
+		constructor(options, callback) {
+			super();
+			options = {
+				allowSynchronousEvents: true,
+				autoPong: true,
+				maxPayload: 100 * 1024 * 1024,
+				skipUTF8Validation: false,
+				perMessageDeflate: false,
+				handleProtocols: null,
+				clientTracking: true,
+				closeTimeout: CLOSE_TIMEOUT,
+				verifyClient: null,
+				noServer: false,
+				backlog: null,
+				server: null,
+				host: null,
+				path: null,
+				port: null,
+				WebSocket,
+				...options
+			};
+			if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) throw new TypeError("One and only one of the \"port\", \"server\", or \"noServer\" options must be specified");
+			if (options.port != null) {
+				this._server = http$4.createServer((req, res) => {
+					const body = http$4.STATUS_CODES[426];
+					res.writeHead(426, {
+						"Content-Length": body.length,
+						"Content-Type": "text/plain"
+					});
+					res.end(body);
+				});
+				this._server.listen(options.port, options.host, options.backlog, callback);
+			} else if (options.server) this._server = options.server;
+			if (this._server) {
+				const emitConnection = this.emit.bind(this, "connection");
+				this._removeListeners = addListeners(this._server, {
+					listening: this.emit.bind(this, "listening"),
+					error: this.emit.bind(this, "error"),
+					upgrade: (req, socket, head) => {
+						this.handleUpgrade(req, socket, head, emitConnection);
+					}
+				});
+			}
+			if (options.perMessageDeflate === true) options.perMessageDeflate = {};
+			if (options.clientTracking) {
+				this.clients = /* @__PURE__ */ new Set();
+				this._shouldEmitClose = false;
+			}
+			this.options = options;
+			this._state = RUNNING;
+		}
+		/**
+		* Returns the bound address, the address family name, and port of the server
+		* as reported by the operating system if listening on an IP socket.
+		* If the server is listening on a pipe or UNIX domain socket, the name is
+		* returned as a string.
+		*
+		* @return {(Object|String|null)} The address of the server
+		* @public
+		*/
+		address() {
+			if (this.options.noServer) throw new Error("The server is operating in \"noServer\" mode");
+			if (!this._server) return null;
+			return this._server.address();
+		}
+		/**
+		* Stop the server from accepting new connections and emit the `'close'` event
+		* when all existing connections are closed.
+		*
+		* @param {Function} [cb] A one-time listener for the `'close'` event
+		* @public
+		*/
+		close(cb) {
+			if (this._state === CLOSED) {
+				if (cb) this.once("close", () => {
+					cb(/* @__PURE__ */ new Error("The server is not running"));
+				});
+				process.nextTick(emitClose, this);
+				return;
+			}
+			if (cb) this.once("close", cb);
+			if (this._state === CLOSING) return;
+			this._state = CLOSING;
+			if (this.options.noServer || this.options.server) {
+				if (this._server) {
+					this._removeListeners();
+					this._removeListeners = this._server = null;
+				}
+				if (this.clients) if (!this.clients.size) process.nextTick(emitClose, this);
+				else this._shouldEmitClose = true;
+				else process.nextTick(emitClose, this);
+			} else {
+				const server = this._server;
+				this._removeListeners();
+				this._removeListeners = this._server = null;
+				server.close(() => {
+					emitClose(this);
+				});
+			}
+		}
+		/**
+		* See if a given request should be handled by this server instance.
+		*
+		* @param {http.IncomingMessage} req Request object to inspect
+		* @return {Boolean} `true` if the request is valid, else `false`
+		* @public
+		*/
+		shouldHandle(req) {
+			if (this.options.path) {
+				const index = req.url.indexOf("?");
+				if ((index !== -1 ? req.url.slice(0, index) : req.url) !== this.options.path) return false;
+			}
+			return true;
+		}
+		/**
+		* Handle a HTTP Upgrade request.
+		*
+		* @param {http.IncomingMessage} req The request object
+		* @param {Duplex} socket The network socket between the server and client
+		* @param {Buffer} head The first packet of the upgraded stream
+		* @param {Function} cb Callback
+		* @public
+		*/
+		handleUpgrade(req, socket, head, cb) {
+			socket.on("error", socketOnError);
+			const key = req.headers["sec-websocket-key"];
+			const upgrade = req.headers.upgrade;
+			const version = +req.headers["sec-websocket-version"];
+			if (req.method !== "GET") {
+				abortHandshakeOrEmitwsClientError(this, req, socket, 405, "Invalid HTTP method");
+				return;
+			}
+			if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
+				abortHandshakeOrEmitwsClientError(this, req, socket, 400, "Invalid Upgrade header");
+				return;
+			}
+			if (key === void 0 || !keyRegex.test(key)) {
+				abortHandshakeOrEmitwsClientError(this, req, socket, 400, "Missing or invalid Sec-WebSocket-Key header");
+				return;
+			}
+			if (version !== 13 && version !== 8) {
+				abortHandshakeOrEmitwsClientError(this, req, socket, 400, "Missing or invalid Sec-WebSocket-Version header", { "Sec-WebSocket-Version": "13, 8" });
+				return;
+			}
+			if (!this.shouldHandle(req)) {
+				abortHandshake(socket, 400);
+				return;
+			}
+			const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
+			let protocols = /* @__PURE__ */ new Set();
+			if (secWebSocketProtocol !== void 0) try {
+				protocols = subprotocol.parse(secWebSocketProtocol);
+			} catch (err) {
+				abortHandshakeOrEmitwsClientError(this, req, socket, 400, "Invalid Sec-WebSocket-Protocol header");
+				return;
+			}
+			const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
+			const extensions = {};
+			if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
+				const perMessageDeflate = new PerMessageDeflate({
+					...this.options.perMessageDeflate,
+					isServer: true,
+					maxPayload: this.options.maxPayload
+				});
+				try {
+					const offers = extension.parse(secWebSocketExtensions);
+					if (offers[PerMessageDeflate.extensionName]) {
+						perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+						extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+					}
+				} catch (err) {
+					abortHandshakeOrEmitwsClientError(this, req, socket, 400, "Invalid or unacceptable Sec-WebSocket-Extensions header");
+					return;
+				}
+			}
+			if (this.options.verifyClient) {
+				const info = {
+					origin: req.headers[`${version === 8 ? "sec-websocket-origin" : "origin"}`],
+					secure: !!(req.socket.authorized || req.socket.encrypted),
+					req
+				};
+				if (this.options.verifyClient.length === 2) {
+					this.options.verifyClient(info, (verified, code, message, headers) => {
+						if (!verified) return abortHandshake(socket, code || 401, message, headers);
+						this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+					});
+					return;
+				}
+				if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
+			}
+			this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+		}
+		/**
+		* Upgrade the connection to WebSocket.
+		*
+		* @param {Object} extensions The accepted extensions
+		* @param {String} key The value of the `Sec-WebSocket-Key` header
+		* @param {Set} protocols The subprotocols
+		* @param {http.IncomingMessage} req The request object
+		* @param {Duplex} socket The network socket between the server and client
+		* @param {Buffer} head The first packet of the upgraded stream
+		* @param {Function} cb Callback
+		* @throws {Error} If called more than once with the same socket
+		* @private
+		*/
+		completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
+			if (!socket.readable || !socket.writable) return socket.destroy();
+			if (socket[kWebSocket]) throw new Error("server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration");
+			if (this._state > RUNNING) return abortHandshake(socket, 503);
+			const headers = [
+				"HTTP/1.1 101 Switching Protocols",
+				"Upgrade: websocket",
+				"Connection: Upgrade",
+				`Sec-WebSocket-Accept: ${createHash("sha1").update(key + GUID).digest("base64")}`
+			];
+			const ws = new this.options.WebSocket(null, void 0, this.options);
+			if (protocols.size) {
+				const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
+				if (protocol) {
+					headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+					ws._protocol = protocol;
+				}
+			}
+			if (extensions[PerMessageDeflate.extensionName]) {
+				const params = extensions[PerMessageDeflate.extensionName].params;
+				const value = extension.format({ [PerMessageDeflate.extensionName]: [params] });
+				headers.push(`Sec-WebSocket-Extensions: ${value}`);
+				ws._extensions = extensions;
+			}
+			this.emit("headers", headers, req);
+			socket.write(headers.concat("\r\n").join("\r\n"));
+			socket.removeListener("error", socketOnError);
+			ws.setSocket(socket, head, {
+				allowSynchronousEvents: this.options.allowSynchronousEvents,
+				maxPayload: this.options.maxPayload,
+				skipUTF8Validation: this.options.skipUTF8Validation
+			});
+			if (this.clients) {
+				this.clients.add(ws);
+				ws.on("close", () => {
+					this.clients.delete(ws);
+					if (this._shouldEmitClose && !this.clients.size) process.nextTick(emitClose, this);
+				});
+			}
+			cb(ws, req);
+		}
+	};
+	module.exports = WebSocketServer;
+	/**
+	* Add event listeners on an `EventEmitter` using a map of <event, listener>
+	* pairs.
+	*
+	* @param {EventEmitter} server The event emitter
+	* @param {Object.<String, Function>} map The listeners to add
+	* @return {Function} A function that will remove the added listeners when
+	*     called
+	* @private
+	*/
+	function addListeners(server, map) {
+		for (const event of Object.keys(map)) server.on(event, map[event]);
+		return function removeListeners() {
+			for (const event of Object.keys(map)) server.removeListener(event, map[event]);
+		};
+	}
+	/**
+	* Emit a `'close'` event on an `EventEmitter`.
+	*
+	* @param {EventEmitter} server The event emitter
+	* @private
+	*/
+	function emitClose(server) {
+		server._state = CLOSED;
+		server.emit("close");
+	}
+	/**
+	* Handle socket errors.
+	*
+	* @private
+	*/
+	function socketOnError() {
+		this.destroy();
+	}
+	/**
+	* Close the connection when preconditions are not fulfilled.
+	*
+	* @param {Duplex} socket The socket of the upgrade request
+	* @param {Number} code The HTTP response status code
+	* @param {String} [message] The HTTP response body
+	* @param {Object} [headers] Additional HTTP response headers
+	* @private
+	*/
+	function abortHandshake(socket, code, message, headers) {
+		message = message || http$4.STATUS_CODES[code];
+		headers = {
+			Connection: "close",
+			"Content-Type": "text/html",
+			"Content-Length": Buffer.byteLength(message),
+			...headers
+		};
+		socket.once("finish", socket.destroy);
+		socket.end(`HTTP/1.1 ${code} ${http$4.STATUS_CODES[code]}\r\n` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message);
+	}
+	/**
+	* Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
+	* one listener for it, otherwise call `abortHandshake()`.
+	*
+	* @param {WebSocketServer} server The WebSocket server
+	* @param {http.IncomingMessage} req The request object
+	* @param {Duplex} socket The socket of the upgrade request
+	* @param {Number} code The HTTP response status code
+	* @param {String} message The HTTP response body
+	* @param {Object} [headers] The HTTP response headers
+	* @private
+	*/
+	function abortHandshakeOrEmitwsClientError(server, req, socket, code, message, headers) {
+		if (server.listenerCount("wsClientError")) {
+			const err = new Error(message);
+			Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+			server.emit("wsClientError", err, socket, req);
+		} else abortHandshake(socket, code, message, headers);
+	}
+}));
+require_stream();
+require_extension();
+require_permessage_deflate();
+require_receiver();
+require_sender();
+require_subprotocol();
+require_websocket();
+var import_websocket_server = /* @__PURE__ */ __toESM(require_websocket_server(), 1);
+//#endregion
+//#region ../../node_modules/.pnpm/host-validation-middleware@0.1.4/node_modules/host-validation-middleware/dist/index.js
+/**
+* This function assumes that the input is not malformed.
+* This is because we only care about browser requests.
+* Non-browser clients can send any value they want anyway.
+*/
+function extractHostNameFromHostHeader(hostHeader) {
+	const trimmedHost = hostHeader.trim();
+	if (trimmedHost[0] === "[") {
+		const endIpv6 = trimmedHost.indexOf("]");
+		if (endIpv6 < 0) return { type: "invalid" };
+		return net.isIP(trimmedHost.slice(1, endIpv6)) === 6 ? { type: "ipv6" } : { type: "invalid" };
+	}
+	const colonPos = trimmedHost.indexOf(":");
+	const hostname = colonPos === -1 ? trimmedHost : trimmedHost.slice(0, colonPos);
+	if (net.isIP(hostname) === 4) return { type: "ipv4" };
+	return {
+		type: "hostname",
+		value: hostname
+	};
+}
+const isFileOrExtensionProtocolRE = /^(?:file|.+-extension):/i;
+function isHostAllowedInternal(hostHeader, allowedHosts) {
+	if (isFileOrExtensionProtocolRE.test(hostHeader)) return true;
+	const extracted = extractHostNameFromHostHeader(hostHeader);
+	if (extracted.type === "invalid") return false;
+	if (extracted.type === "ipv4" || extracted.type === "ipv6") return true;
+	const hostname = extracted.value;
+	if (hostname === "localhost" || hostname.endsWith(".localhost")) return true;
+	for (const allowedHost of allowedHosts) {
+		if (allowedHost === hostname) return true;
+		if (allowedHost[0] === "." && (allowedHost.slice(1) === hostname || hostname.endsWith(allowedHost))) return true;
+	}
+	return false;
+}
+const cache = /* @__PURE__ */ new WeakMap();
+/**
+* Check if the host contained in the host header is allowed.
+*
+* This function will cache the result if the `allowedHosts` array is frozen.
+*
+* @param hostHeader - The value of host header. See [RFC 9110 7.2](https://datatracker.ietf.org/doc/html/rfc9110#name-host-and-authority).
+* @param allowedHosts - The allowed host patterns. See the README for more details.
+*/
+function isHostAllowed(hostHeader, allowedHosts) {
+	if (hostHeader === void 0) return true;
+	let cachedAllowedHosts;
+	if (Object.isFrozen(allowedHosts)) {
+		if (!cache.has(allowedHosts)) cache.set(allowedHosts, /* @__PURE__ */ new Set());
+		cachedAllowedHosts = cache.get(allowedHosts);
+		if (cachedAllowedHosts.has(hostHeader)) return true;
+	}
+	const result = isHostAllowedInternal(hostHeader, allowedHosts);
+	if (cachedAllowedHosts && result) cachedAllowedHosts.add(hostHeader);
+	return result;
+}
+/**
+* Middleware to validate the host header of incoming requests.
+*
+* If the host header is not in the allowed hosts list, a 403 Forbidden response
+* is sent.
+*/
+function hostValidationMiddleware$1(options) {
+	return async function hostValidationMiddleware(req, res, next) {
+		const hostHeader = req.headers.host;
+		if (!isHostAllowed(hostHeader, options.allowedHosts)) {
+			const hostname = hostHeader?.replace(/:\d+$/, "") ?? "";
+			const errorMessage = options.generateErrorMessage?.(hostname) ?? generateDefaultErrorMessage(hostname);
+			res.writeHead(403, { "Content-Type": options.errorResponseContentType ?? "text/plain" });
+			res.end(errorMessage);
+			return;
+		}
+		next();
+	};
+}
+function generateDefaultErrorMessage(hostname) {
+	return `Blocked request. This host (${JSON.stringify(hostname)}) is not allowed.`;
+}
+//#endregion
+//#region src/node/server/ws.ts
+const WebSocketServerRaw = process.versions.bun ? import.meta.require("ws").WebSocketServer : import_websocket_server.default;
+const isWebSocketServer = Symbol("isWebSocketServer");
+const wsServerEvents = [
+	"connection",
+	"error",
+	"headers",
+	"listening",
+	"message"
+];
+function noop$1() {}
+function hasValidToken(config, url) {
+	const token = url.searchParams.get("token");
+	if (!token) return false;
+	try {
+		return crypto.timingSafeEqual(Buffer.from(token), Buffer.from(config.webSocketToken));
+	} catch {}
+	return false;
+}
+function createWebSocketServer(server, config, httpsOptions) {
+	if (config.server.ws === false) return {
+		[isWebSocketServer]: true,
+		get clients() {
+			return /* @__PURE__ */ new Set();
+		},
+		async close() {},
+		on: noop$1,
+		off: noop$1,
+		setInvokeHandler: noop$1,
+		handleInvoke: async () => ({ error: {
+			name: "TransportError",
+			message: "handleInvoke not implemented",
+			stack: (/* @__PURE__ */ new Error()).stack
+		} }),
+		listen: noop$1,
+		send: noop$1
+	};
+	let wsHttpServer = void 0;
+	const hmr = isObject$1(config.server.hmr) && config.server.hmr;
+	const hmrServer = hmr && hmr.server;
+	const hmrPort = hmr && hmr.port;
+	const wsServer = hmrServer || (!hmrPort || hmrPort === config.server.port) && server;
+	let hmrServerWsListener;
+	const customListeners = /* @__PURE__ */ new Map();
+	const clientsMap = /* @__PURE__ */ new WeakMap();
+	const port = hmrPort || 24678;
+	const host = hmr && hmr.host || void 0;
+	const allowedHosts = config.server.allowedHosts === true ? config.server.allowedHosts : Object.freeze([...config.server.allowedHosts]);
+	const shouldHandle = (req) => {
+		if (req.headers["sec-websocket-protocol"] === "vite-ping") return true;
+		if (allowedHosts !== true && !isHostAllowed(req.headers.host, allowedHosts)) return false;
+		if (config.legacy?.skipWebSocketTokenCheck) return true;
+		if (req.headers.origin) return hasValidToken(config, new URL(`http://example.com${req.url}`));
+		return true;
+	};
+	const handleUpgrade = (req, socket, head, isPing) => {
+		wss.handleUpgrade(req, socket, head, (ws) => {
+			if (isPing) {
+				ws.close(1e3);
+				return;
+			}
+			wss.emit("connection", ws, req);
+		});
+	};
+	const wss = new WebSocketServerRaw({ noServer: true });
+	wss.shouldHandle = shouldHandle;
+	if (wsServer) {
+		let hmrBase = config.base;
+		const hmrPath = hmr ? hmr.path : void 0;
+		if (hmrPath) hmrBase = path.posix.join(hmrBase, hmrPath);
+		hmrServerWsListener = (req, socket, head) => {
+			const protocol = req.headers["sec-websocket-protocol"];
+			const parsedUrl = new URL(`http://example.com${req.url}`);
+			if (["vite-hmr", "vite-ping"].includes(protocol) && parsedUrl.pathname === hmrBase) handleUpgrade(req, socket, head, protocol === "vite-ping");
+		};
+		wsServer.on("upgrade", hmrServerWsListener);
+	} else {
+		const route = ((_, res) => {
+			const statusCode = 426;
+			const body = STATUS_CODES[statusCode];
+			if (!body) throw new Error(`No body text found for the ${statusCode} status code`);
+			res.writeHead(statusCode, {
+				"Content-Length": body.length,
+				"Content-Type": "text/plain"
+			});
+			res.end(body);
+		});
+		if (httpsOptions) wsHttpServer = createServer$1(httpsOptions, route);
+		else wsHttpServer = createServer(route);
+		wsHttpServer.on("upgrade", (req, socket, head) => {
+			const protocol = req.headers["sec-websocket-protocol"];
+			if (protocol === "vite-ping" && server && !server.listening) {
+				req.destroy();
+				return;
+			}
+			handleUpgrade(req, socket, head, protocol === "vite-ping");
+		});
+		wsHttpServer.on("error", (e) => {
+			if (e.code === "EADDRINUSE") config.logger.error(import_picocolors.default.red(`WebSocket server error: Port ${e.port} is already in use`), { error: e });
+			else config.logger.error(import_picocolors.default.red(`WebSocket server error:\n${e.stack || e.message}`), { error: e });
+		});
+	}
+	const emitCustomEvent = (event, data, socket) => {
+		const listeners = customListeners.get(event);
+		if (!listeners?.size) return;
+		const client = getSocketClient(socket);
+		for (const listener of listeners) listener(data, client);
+	};
+	wss.on("connection", (socket) => {
+		socket.on("message", (raw) => {
+			if (!customListeners.size) return;
+			let parsed;
+			try {
+				parsed = JSON.parse(String(raw));
+			} catch {}
+			if (!parsed || parsed.type !== "custom" || !parsed.event) return;
+			emitCustomEvent(parsed.event, parsed.data, socket);
+		});
+		socket.on("error", (err) => {
+			config.logger.error(`${import_picocolors.default.red(`ws error:`)}\n${err.stack}`, {
+				timestamp: true,
+				error: err
+			});
+		});
+		socket.on("close", () => {
+			emitCustomEvent("vite:client:disconnect", void 0, socket);
+		});
+		emitCustomEvent("vite:client:connect", void 0, socket);
+		socket.send(JSON.stringify({ type: "connected" }));
+		if (bufferedMessage) {
+			socket.send(JSON.stringify(bufferedMessage));
+			bufferedMessage = null;
+		}
+	});
+	wss.on("error", (e) => {
+		if (e.code === "EADDRINUSE") config.logger.error(import_picocolors.default.red(`WebSocket server error: Port ${e.port} is already in use`), { error: e });
+		else config.logger.error(import_picocolors.default.red(`WebSocket server error:\n${e.stack || e.message}`), { error: e });
+	});
+	function getSocketClient(socket) {
+		if (!clientsMap.has(socket)) clientsMap.set(socket, {
+			send: (...args) => {
+				let payload;
+				if (typeof args[0] === "string") payload = {
+					type: "custom",
+					event: args[0],
+					data: args[1]
+				};
+				else payload = args[0];
+				socket.send(JSON.stringify(payload));
+			},
+			socket
+		});
+		return clientsMap.get(socket);
+	}
+	let bufferedMessage = null;
+	const normalizedHotChannel = normalizeHotChannel({
+		send(payload) {
+			if ((payload.type === "error" || payload.type === "full-reload") && !wss.clients.size) {
+				bufferedMessage = payload;
+				return;
+			}
+			const stringified = JSON.stringify(payload);
+			wss.clients.forEach((client) => {
+				if (client.readyState === 1) client.send(stringified);
+			});
+		},
+		on(event, fn) {
+			if (!customListeners.has(event)) customListeners.set(event, /* @__PURE__ */ new Set());
+			customListeners.get(event).add(fn);
+		},
+		off(event, fn) {
+			customListeners.get(event)?.delete(fn);
+		},
+		listen() {
+			wsHttpServer?.listen(port, host);
+		},
+		close() {
+			if (hmrServerWsListener && wsServer) wsServer.off("upgrade", hmrServerWsListener);
+			return new Promise((resolve, reject) => {
+				wss.clients.forEach((client) => {
+					client.terminate();
+				});
+				wss.close((err) => {
+					if (err) reject(err);
+					else if (wsHttpServer) wsHttpServer.close((err) => {
+						if (err) reject(err);
+						else resolve();
+					});
+					else resolve();
+				});
+			});
+		}
+	}, config.server.hmr !== false, false);
+	return {
+		...normalizedHotChannel,
+		on: ((event, fn) => {
+			if (wsServerEvents.includes(event)) {
+				wss.on(event, fn);
+				return;
+			}
+			normalizedHotChannel.on(event, fn);
+		}),
+		off: ((event, fn) => {
+			if (wsServerEvents.includes(event)) {
+				wss.off(event, fn);
+				return;
+			}
+			normalizedHotChannel.off(event, fn);
+		}),
+		async close() {
+			await normalizedHotChannel.close();
+		},
+		[isWebSocketServer]: true,
+		get clients() {
+			return new Set(Array.from(wss.clients).map(getSocketClient));
+		}
+	};
+}
+//#endregion
+//#region src/node/server/middlewares/base.ts
+function baseMiddleware(rawBase, middlewareMode) {
+	return function viteBaseMiddleware(req, res, next) {
+		const url = req.url;
+		const pathname = cleanUrl(url);
+		const base = rawBase;
+		if (pathname.startsWith(base)) {
+			req.url = stripBase(url, base);
+			return next();
+		}
+		if (middlewareMode) return next();
+		if (pathname === "/" || pathname === "/index.html") {
+			res.writeHead(302, { Location: base + url.slice(pathname.length) });
+			res.end();
+			return;
+		}
+		const redirectPath = withTrailingSlash(url) !== base ? joinUrlSegments(base, url) : base;
+		if (req.headers.accept?.includes("text/html")) {
+			res.writeHead(404, { "Content-Type": "text/html" });
+			res.end(`The server is configured with a public base URL of ${base} - did you mean to visit <a href="${redirectPath}">${redirectPath}</a> instead?`);
+			return;
+		} else {
+			res.writeHead(404, { "Content-Type": "text/plain" });
+			res.end(`The server is configured with a public base URL of ${base} - did you mean to visit ${redirectPath} instead?`);
+			return;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/follow-redirects@1.15.11_obug@1.0.2/node_modules/follow-redirects/debug.js
+var require_debug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var debug;
+	module.exports = function() {
+		if (!debug) {
+			try {
+				debug = (init_node(), __toCommonJS(node_exports))("follow-redirects");
+			} catch (error) {}
+			if (typeof debug !== "function") debug = function() {};
+		}
+		debug.apply(null, arguments);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/follow-redirects@1.15.11_obug@1.0.2/node_modules/follow-redirects/index.js
+var require_follow_redirects = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var url$1 = __require("url");
+	var URL = url$1.URL;
+	var http$3 = __require("http");
+	var https$2 = __require("https");
+	var Writable = __require("stream").Writable;
+	var assert$1 = __require("assert");
+	var debug = require_debug();
+	// istanbul ignore next
+	(function detectUnsupportedEnvironment() {
+		var looksLikeNode = typeof process !== "undefined";
+		var looksLikeBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+		var looksLikeV8 = isFunction(Error.captureStackTrace);
+		if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) console.warn("The follow-redirects package should be excluded from browser builds.");
+	})();
+	var useNativeURL = false;
+	try {
+		assert$1(new URL(""));
+	} catch (error) {
+		useNativeURL = error.code === "ERR_INVALID_URL";
+	}
+	var preservedUrlFields = [
+		"auth",
+		"host",
+		"hostname",
+		"href",
+		"path",
+		"pathname",
+		"port",
+		"protocol",
+		"query",
+		"search",
+		"hash"
+	];
+	var events = [
+		"abort",
+		"aborted",
+		"connect",
+		"error",
+		"socket",
+		"timeout"
+	];
+	var eventHandlers = Object.create(null);
+	events.forEach(function(event) {
+		eventHandlers[event] = function(arg1, arg2, arg3) {
+			this._redirectable.emit(event, arg1, arg2, arg3);
+		};
+	});
+	var InvalidUrlError = createErrorType("ERR_INVALID_URL", "Invalid URL", TypeError);
+	var RedirectionError = createErrorType("ERR_FR_REDIRECTION_FAILURE", "Redirected request failed");
+	var TooManyRedirectsError = createErrorType("ERR_FR_TOO_MANY_REDIRECTS", "Maximum number of redirects exceeded", RedirectionError);
+	var MaxBodyLengthExceededError = createErrorType("ERR_FR_MAX_BODY_LENGTH_EXCEEDED", "Request body larger than maxBodyLength limit");
+	var WriteAfterEndError = createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
+	// istanbul ignore next
+	var destroy = Writable.prototype.destroy || noop;
+	function RedirectableRequest(options, responseCallback) {
+		Writable.call(this);
+		this._sanitizeOptions(options);
+		this._options = options;
+		this._ended = false;
+		this._ending = false;
+		this._redirectCount = 0;
+		this._redirects = [];
+		this._requestBodyLength = 0;
+		this._requestBodyBuffers = [];
+		if (responseCallback) this.on("response", responseCallback);
+		var self = this;
+		this._onNativeResponse = function(response) {
+			try {
+				self._processResponse(response);
+			} catch (cause) {
+				self.emit("error", cause instanceof RedirectionError ? cause : new RedirectionError({ cause }));
+			}
+		};
+		this._performRequest();
+	}
+	RedirectableRequest.prototype = Object.create(Writable.prototype);
+	RedirectableRequest.prototype.abort = function() {
+		destroyRequest(this._currentRequest);
+		this._currentRequest.abort();
+		this.emit("abort");
+	};
+	RedirectableRequest.prototype.destroy = function(error) {
+		destroyRequest(this._currentRequest, error);
+		destroy.call(this, error);
+		return this;
+	};
+	RedirectableRequest.prototype.write = function(data, encoding, callback) {
+		if (this._ending) throw new WriteAfterEndError();
+		if (!isString(data) && !isBuffer(data)) throw new TypeError("data should be a string, Buffer or Uint8Array");
+		if (isFunction(encoding)) {
+			callback = encoding;
+			encoding = null;
+		}
+		if (data.length === 0) {
+			if (callback) callback();
+			return;
+		}
+		if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
+			this._requestBodyLength += data.length;
+			this._requestBodyBuffers.push({
+				data,
+				encoding
+			});
+			this._currentRequest.write(data, encoding, callback);
+		} else {
+			this.emit("error", new MaxBodyLengthExceededError());
+			this.abort();
+		}
+	};
+	RedirectableRequest.prototype.end = function(data, encoding, callback) {
+		if (isFunction(data)) {
+			callback = data;
+			data = encoding = null;
+		} else if (isFunction(encoding)) {
+			callback = encoding;
+			encoding = null;
+		}
+		if (!data) {
+			this._ended = this._ending = true;
+			this._currentRequest.end(null, null, callback);
+		} else {
+			var self = this;
+			var currentRequest = this._currentRequest;
+			this.write(data, encoding, function() {
+				self._ended = true;
+				currentRequest.end(null, null, callback);
+			});
+			this._ending = true;
+		}
+	};
+	RedirectableRequest.prototype.setHeader = function(name, value) {
+		this._options.headers[name] = value;
+		this._currentRequest.setHeader(name, value);
+	};
+	RedirectableRequest.prototype.removeHeader = function(name) {
+		delete this._options.headers[name];
+		this._currentRequest.removeHeader(name);
+	};
+	RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
+		var self = this;
+		function destroyOnTimeout(socket) {
+			socket.setTimeout(msecs);
+			socket.removeListener("timeout", socket.destroy);
+			socket.addListener("timeout", socket.destroy);
+		}
+		function startTimer(socket) {
+			if (self._timeout) clearTimeout(self._timeout);
+			self._timeout = setTimeout(function() {
+				self.emit("timeout");
+				clearTimer();
+			}, msecs);
+			destroyOnTimeout(socket);
+		}
+		function clearTimer() {
+			if (self._timeout) {
+				clearTimeout(self._timeout);
+				self._timeout = null;
+			}
+			self.removeListener("abort", clearTimer);
+			self.removeListener("error", clearTimer);
+			self.removeListener("response", clearTimer);
+			self.removeListener("close", clearTimer);
+			if (callback) self.removeListener("timeout", callback);
+			if (!self.socket) self._currentRequest.removeListener("socket", startTimer);
+		}
+		if (callback) this.on("timeout", callback);
+		if (this.socket) startTimer(this.socket);
+		else this._currentRequest.once("socket", startTimer);
+		this.on("socket", destroyOnTimeout);
+		this.on("abort", clearTimer);
+		this.on("error", clearTimer);
+		this.on("response", clearTimer);
+		this.on("close", clearTimer);
+		return this;
+	};
+	[
+		"flushHeaders",
+		"getHeader",
+		"setNoDelay",
+		"setSocketKeepAlive"
+	].forEach(function(method) {
+		RedirectableRequest.prototype[method] = function(a, b) {
+			return this._currentRequest[method](a, b);
+		};
+	});
+	[
+		"aborted",
+		"connection",
+		"socket"
+	].forEach(function(property) {
+		Object.defineProperty(RedirectableRequest.prototype, property, { get: function() {
+			return this._currentRequest[property];
+		} });
+	});
+	RedirectableRequest.prototype._sanitizeOptions = function(options) {
+		if (!options.headers) options.headers = {};
+		if (options.host) {
+			if (!options.hostname) options.hostname = options.host;
+			delete options.host;
+		}
+		if (!options.pathname && options.path) {
+			var searchPos = options.path.indexOf("?");
+			if (searchPos < 0) options.pathname = options.path;
+			else {
+				options.pathname = options.path.substring(0, searchPos);
+				options.search = options.path.substring(searchPos);
+			}
+		}
+	};
+	RedirectableRequest.prototype._performRequest = function() {
+		var protocol = this._options.protocol;
+		var nativeProtocol = this._options.nativeProtocols[protocol];
+		if (!nativeProtocol) throw new TypeError("Unsupported protocol " + protocol);
+		if (this._options.agents) {
+			var scheme = protocol.slice(0, -1);
+			this._options.agent = this._options.agents[scheme];
+		}
+		var request = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
+		request._redirectable = this;
+		for (var event of events) request.on(event, eventHandlers[event]);
+		this._currentUrl = /^\//.test(this._options.path) ? url$1.format(this._options) : this._options.path;
+		if (this._isRedirect) {
+			var i = 0;
+			var self = this;
+			var buffers = this._requestBodyBuffers;
+			(function writeNext(error) {
+				// istanbul ignore else
+				if (request === self._currentRequest) {
+					// istanbul ignore if
+					if (error) self.emit("error", error);
+					else if (i < buffers.length) {
+						var buffer = buffers[i++];
+						// istanbul ignore else
+						if (!request.finished) request.write(buffer.data, buffer.encoding, writeNext);
+					} else if (self._ended) request.end();
+				}
+			})();
+		}
+	};
+	RedirectableRequest.prototype._processResponse = function(response) {
+		var statusCode = response.statusCode;
+		if (this._options.trackRedirects) this._redirects.push({
+			url: this._currentUrl,
+			headers: response.headers,
+			statusCode
+		});
+		var location = response.headers.location;
+		if (!location || this._options.followRedirects === false || statusCode < 300 || statusCode >= 400) {
+			response.responseUrl = this._currentUrl;
+			response.redirects = this._redirects;
+			this.emit("response", response);
+			this._requestBodyBuffers = [];
+			return;
+		}
+		destroyRequest(this._currentRequest);
+		response.destroy();
+		if (++this._redirectCount > this._options.maxRedirects) throw new TooManyRedirectsError();
+		var requestHeaders;
+		var beforeRedirect = this._options.beforeRedirect;
+		if (beforeRedirect) requestHeaders = Object.assign({ Host: response.req.getHeader("host") }, this._options.headers);
+		var method = this._options.method;
+		if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" || statusCode === 303 && !/^(?:GET|HEAD)$/.test(this._options.method)) {
+			this._options.method = "GET";
+			this._requestBodyBuffers = [];
+			removeMatchingHeaders(/^content-/i, this._options.headers);
+		}
+		var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
+		var currentUrlParts = parseUrl(this._currentUrl);
+		var currentHost = currentHostHeader || currentUrlParts.host;
+		var currentUrl = /^\w+:/.test(location) ? this._currentUrl : url$1.format(Object.assign(currentUrlParts, { host: currentHost }));
+		var redirectUrl = resolveUrl(location, currentUrl);
+		debug("redirecting to", redirectUrl.href);
+		this._isRedirect = true;
+		spreadUrlObject(redirectUrl, this._options);
+		if (redirectUrl.protocol !== currentUrlParts.protocol && redirectUrl.protocol !== "https:" || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
+		if (isFunction(beforeRedirect)) {
+			var responseDetails = {
+				headers: response.headers,
+				statusCode
+			};
+			var requestDetails = {
+				url: currentUrl,
+				method,
+				headers: requestHeaders
+			};
+			beforeRedirect(this._options, responseDetails, requestDetails);
+			this._sanitizeOptions(this._options);
+		}
+		this._performRequest();
+	};
+	function wrap(protocols) {
+		var exports$1 = {
+			maxRedirects: 21,
+			maxBodyLength: 10 * 1024 * 1024
+		};
+		var nativeProtocols = {};
+		Object.keys(protocols).forEach(function(scheme) {
+			var protocol = scheme + ":";
+			var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
+			var wrappedProtocol = exports$1[scheme] = Object.create(nativeProtocol);
+			function request(input, options, callback) {
+				if (isURL(input)) input = spreadUrlObject(input);
+				else if (isString(input)) input = spreadUrlObject(parseUrl(input));
+				else {
+					callback = options;
+					options = validateUrl(input);
+					input = { protocol };
+				}
+				if (isFunction(options)) {
+					callback = options;
+					options = null;
+				}
+				options = Object.assign({
+					maxRedirects: exports$1.maxRedirects,
+					maxBodyLength: exports$1.maxBodyLength
+				}, input, options);
+				options.nativeProtocols = nativeProtocols;
+				if (!isString(options.host) && !isString(options.hostname)) options.hostname = "::1";
+				assert$1.equal(options.protocol, protocol, "protocol mismatch");
+				debug("options", options);
+				return new RedirectableRequest(options, callback);
+			}
+			function get(input, options, callback) {
+				var wrappedRequest = wrappedProtocol.request(input, options, callback);
+				wrappedRequest.end();
+				return wrappedRequest;
+			}
+			Object.defineProperties(wrappedProtocol, {
+				request: {
+					value: request,
+					configurable: true,
+					enumerable: true,
+					writable: true
+				},
+				get: {
+					value: get,
+					configurable: true,
+					enumerable: true,
+					writable: true
+				}
+			});
+		});
+		return exports$1;
+	}
+	function noop() {}
+	function parseUrl(input) {
+		var parsed;
+		// istanbul ignore else
+		if (useNativeURL) parsed = new URL(input);
+		else {
+			parsed = validateUrl(url$1.parse(input));
+			if (!isString(parsed.protocol)) throw new InvalidUrlError({ input });
+		}
+		return parsed;
+	}
+	function resolveUrl(relative, base) {
+		// istanbul ignore next
+		return useNativeURL ? new URL(relative, base) : parseUrl(url$1.resolve(base, relative));
+	}
+	function validateUrl(input) {
+		if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) throw new InvalidUrlError({ input: input.href || input });
+		if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) throw new InvalidUrlError({ input: input.href || input });
+		return input;
+	}
+	function spreadUrlObject(urlObject, target) {
+		var spread = target || {};
+		for (var key of preservedUrlFields) spread[key] = urlObject[key];
+		if (spread.hostname.startsWith("[")) spread.hostname = spread.hostname.slice(1, -1);
+		if (spread.port !== "") spread.port = Number(spread.port);
+		spread.path = spread.search ? spread.pathname + spread.search : spread.pathname;
+		return spread;
+	}
+	function removeMatchingHeaders(regex, headers) {
+		var lastValue;
+		for (var header in headers) if (regex.test(header)) {
+			lastValue = headers[header];
+			delete headers[header];
+		}
+		return lastValue === null || typeof lastValue === "undefined" ? void 0 : String(lastValue).trim();
+	}
+	function createErrorType(code, message, baseClass) {
+		function CustomError(properties) {
+			// istanbul ignore else
+			if (isFunction(Error.captureStackTrace)) Error.captureStackTrace(this, this.constructor);
+			Object.assign(this, properties || {});
+			this.code = code;
+			this.message = this.cause ? message + ": " + this.cause.message : message;
+		}
+		CustomError.prototype = new (baseClass || Error)();
+		Object.defineProperties(CustomError.prototype, {
+			constructor: {
+				value: CustomError,
+				enumerable: false
+			},
+			name: {
+				value: "Error [" + code + "]",
+				enumerable: false
+			}
+		});
+		return CustomError;
+	}
+	function destroyRequest(request, error) {
+		for (var event of events) request.removeListener(event, eventHandlers[event]);
+		request.on("error", noop);
+		request.destroy(error);
+	}
+	function isSubdomain(subdomain, domain) {
+		assert$1(isString(subdomain) && isString(domain));
+		var dot = subdomain.length - domain.length - 1;
+		return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
+	}
+	function isString(value) {
+		return typeof value === "string" || value instanceof String;
+	}
+	function isFunction(value) {
+		return typeof value === "function";
+	}
+	function isBuffer(value) {
+		return typeof value === "object" && "length" in value;
+	}
+	function isURL(value) {
+		return URL && value instanceof URL;
+	}
+	module.exports = wrap({
+		http: http$3,
+		https: https$2
+	});
+	module.exports.wrap = wrap;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/http-proxy-3@1.23.2_ms@2.1.3/node_modules/http-proxy-3/dist/lib/http-proxy/common.js
+var require_common = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.isSSL = void 0;
+	exports.setupOutgoing = setupOutgoing;
+	exports.setupSocket = setupSocket;
+	exports.getPort = getPort;
+	exports.hasEncryptedConnection = hasEncryptedConnection;
+	exports.urlJoin = urlJoin;
+	exports.rewriteCookieProperty = rewriteCookieProperty;
+	exports.toURL = toURL;
+	const node_tls_1 = __require("node:tls");
+	const upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
+	exports.isSSL = /^https|wss/;
+	const HEADER_BLACKLIST = "trailer";
+	const HTTP2_HEADER_BLACKLIST = [
+		":method",
+		":path",
+		":scheme",
+		":authority",
+		"connection",
+		"keep-alive"
+	];
+	function setupOutgoing(outgoing, options, req, forward) {
+		const target = options[forward || "target"];
+		outgoing.port = +(target.port ?? (target.protocol !== void 0 && exports.isSSL.test(target.protocol) ? 443 : 80));
+		for (const e of [
+			"host",
+			"hostname",
+			"socketPath",
+			"pfx",
+			"key",
+			"passphrase",
+			"cert",
+			"ca",
+			"ciphers",
+			"secureProtocol"
+		]) outgoing[e] = target[e];
+		outgoing.method = options.method || req.method;
+		outgoing.headers = { ...req.headers };
+		if (req.headers?.[":authority"]) outgoing.headers.host = req.headers[":authority"];
+		if (options.headers) outgoing.headers = {
+			...outgoing.headers,
+			...options.headers
+		};
+		for (const header in outgoing.headers) if (HEADER_BLACKLIST == header.toLowerCase()) {
+			delete outgoing.headers[header];
+			break;
+		}
+		if (req.httpVersionMajor > 1) for (const header of HTTP2_HEADER_BLACKLIST) delete outgoing.headers[header];
+		if (options.auth) {
+			delete outgoing.headers.authorization;
+			outgoing.auth = options.auth;
+		}
+		if (options.ca) outgoing.ca = options.ca;
+		if (target.protocol !== void 0 && exports.isSSL.test(target.protocol)) outgoing.rejectUnauthorized = typeof options.secure === "undefined" ? true : options.secure;
+		outgoing.agent = options.agent || false;
+		outgoing.localAddress = options.localAddress;
+		if (!outgoing.agent) {
+			outgoing.headers = outgoing.headers || {};
+			if (typeof outgoing.headers.connection !== "string" || !upgradeHeader.test(outgoing.headers.connection)) outgoing.headers.connection = "close";
+		}
+		const targetPath = target && options.prependPath !== false && "pathname" in target ? getPath(`${target.pathname}${target.search ?? ""}`) : "/";
+		let outgoingPath = options.toProxy ? req.url : getPath(req.url);
+		outgoingPath = !options.ignorePath ? outgoingPath : "";
+		outgoing.path = urlJoin(targetPath, outgoingPath ?? "");
+		if (options.changeOrigin) outgoing.headers.host = target.protocol !== void 0 && required(outgoing.port, target.protocol) && !hasPort(outgoing.host) ? outgoing.host + ":" + outgoing.port : outgoing.host;
+		outgoing.url = "href" in target && target.href || (target.protocol === "https" ? "https" : "http") + "://" + outgoing.host + (outgoing.port ? ":" + outgoing.port : "");
+		if (req.httpVersionMajor > 1) for (const header of HTTP2_HEADER_BLACKLIST) delete outgoing.headers[header];
+		return outgoing;
+	}
+	function setupSocket(socket) {
+		socket.setTimeout(0);
+		socket.setNoDelay(true);
+		socket.setKeepAlive(true, 0);
+		return socket;
+	}
+	function getPort(req) {
+		const hostHeader = req.headers[":authority"] || req.headers.host;
+		const res = hostHeader ? hostHeader.match(/:(\d+)/) : "";
+		return res ? res[1] : hasEncryptedConnection(req) ? "443" : "80";
+	}
+	function hasEncryptedConnection(req) {
+		const conn = req.connection;
+		return conn instanceof node_tls_1.TLSSocket && conn.encrypted || Boolean(conn.pair);
+	}
+	function urlJoin(...args) {
+		const queryParams = [];
+		let queryParamRaw = "";
+		args.forEach((url, index) => {
+			const qpStart = url.indexOf("?");
+			if (qpStart !== -1) {
+				queryParams.push(url.substring(qpStart + 1));
+				args[index] = url.substring(0, qpStart);
+			}
+		});
+		queryParamRaw = queryParams.filter(Boolean).join("&");
+		let retSegs = "";
+		for (const seg of args) {
+			if (!seg) continue;
+			if (retSegs.endsWith("/")) if (seg.startsWith("/")) retSegs += seg.slice(1);
+			else retSegs += seg;
+			else if (seg.startsWith("/")) retSegs += seg;
+			else retSegs += "/" + seg;
+		}
+		return queryParamRaw ? retSegs + "?" + queryParamRaw : retSegs;
+	}
+	function rewriteCookieProperty(header, config, property) {
+		if (Array.isArray(header)) return header.map((headerElement) => {
+			return rewriteCookieProperty(headerElement, config, property);
+		});
+		return header.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", "i"), (match, prefix, previousValue) => {
+			let newValue;
+			if (previousValue in config) newValue = config[previousValue];
+			else if ("*" in config) newValue = config["*"];
+			else return match;
+			if (newValue) return prefix + newValue;
+			else return "";
+		});
+	}
+	function hasPort(host) {
+		return !!~host.indexOf(":");
+	}
+	function getPath(url) {
+		if (url === "" || url?.startsWith("?")) return url;
+		const u = toURL(url);
+		return `${u.pathname ?? ""}${u.search ?? ""}`;
+	}
+	function toURL(url) {
+		if (url instanceof URL) return url;
+		else if (typeof url === "object" && "href" in url && typeof url.href === "string") url = url.href;
+		if (!url) url = "";
+		if (typeof url != "string") url = `${url}`;
+		if (url.startsWith("//")) url = `http://base.invalid${url}`;
+		return new URL(url, "http://base.invalid");
+	}
+	function required(port, protocol) {
+		protocol = protocol.split(":")[0];
+		port = +port;
+		if (!port) return false;
+		switch (protocol) {
+			case "http":
+			case "ws": return port !== 80;
+			case "https":
+			case "wss": return port !== 443;
+		}
+		return port !== 0;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/http-proxy-3@1.23.2_ms@2.1.3/node_modules/http-proxy-3/dist/lib/http-proxy/passes/web-outgoing.js
+var require_web_outgoing = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	});
+	var __importStar = exports && exports.__importStar || (function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o) {
+				var ar = [];
+				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+			}
+			__setModuleDefault(result, mod);
+			return result;
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.OUTGOING_PASSES = void 0;
+	exports.removeChunked = removeChunked;
+	exports.setConnection = setConnection;
+	exports.setRedirectHostRewrite = setRedirectHostRewrite;
+	exports.writeHeaders = writeHeaders;
+	exports.writeStatusCode = writeStatusCode;
+	const common = __importStar(require_common());
+	const redirectRegex = /^201|30(1|2|7|8)$/;
+	function removeChunked(_req, _res, proxyRes) {
+		delete proxyRes.headers["transfer-encoding"];
+	}
+	function setConnection(req, _res, proxyRes) {
+		if (req.httpVersion === "1.0") proxyRes.headers["connection"] = req.headers["connection"] || "close";
+		else if (req.httpVersion !== "2.0" && !proxyRes.headers["connection"]) proxyRes.headers["connection"] = req.headers["connection"] || "keep-alive";
+	}
+	function setRedirectHostRewrite(req, _res, proxyRes, options) {
+		if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers["location"] && redirectRegex.test(`${proxyRes.statusCode}`)) {
+			const target = common.toURL(options.target);
+			const location = proxyRes.headers["location"];
+			if (typeof location != "string") return;
+			const u = common.toURL(location);
+			if (target.host != u.host) return;
+			if (options.hostRewrite) u.host = options.hostRewrite;
+			else if (options.autoRewrite) u.host = req.headers[":authority"] ?? req.headers["host"] ?? "";
+			if (options.protocolRewrite) u.protocol = options.protocolRewrite;
+			proxyRes.headers["location"] = u.toString();
+		}
+	}
+	function writeHeaders(_req, res, proxyRes, options) {
+		const rewriteCookieDomainConfig = typeof options.cookieDomainRewrite === "string" ? { "*": options.cookieDomainRewrite } : options.cookieDomainRewrite;
+		const rewriteCookiePathConfig = typeof options.cookiePathRewrite === "string" ? { "*": options.cookiePathRewrite } : options.cookiePathRewrite;
+		const preserveHeaderKeyCase = options.preserveHeaderKeyCase;
+		const setHeader = (key, header) => {
+			if (header == void 0) return;
+			if (rewriteCookieDomainConfig && key.toLowerCase() === "set-cookie") header = common.rewriteCookieProperty(header, rewriteCookieDomainConfig, "domain");
+			if (rewriteCookiePathConfig && key.toLowerCase() === "set-cookie") header = common.rewriteCookieProperty(header, rewriteCookiePathConfig, "path");
+			res.setHeader(String(key).trim(), header);
+		};
+		let rawHeaderKeyMap;
+		if (preserveHeaderKeyCase && proxyRes.rawHeaders != void 0) {
+			rawHeaderKeyMap = {};
+			for (let i = 0; i < proxyRes.rawHeaders.length; i += 2) {
+				const key = proxyRes.rawHeaders[i];
+				rawHeaderKeyMap[key.toLowerCase()] = key;
+			}
+		}
+		for (const key0 in proxyRes.headers) {
+			let key = key0;
+			if (_req.httpVersionMajor > 1 && (key === "connection" || key === "keep-alive")) continue;
+			const header = proxyRes.headers[key];
+			if (preserveHeaderKeyCase && rawHeaderKeyMap) key = rawHeaderKeyMap[key] ?? key;
+			setHeader(key, header);
+		}
+	}
+	function writeStatusCode(_req, res, proxyRes) {
+		res.statusCode = proxyRes.statusCode;
+		if (proxyRes.statusMessage && _req.httpVersionMajor === 1) res.statusMessage = proxyRes.statusMessage;
+	}
+	exports.OUTGOING_PASSES = {
+		removeChunked,
+		setConnection,
+		setRedirectHostRewrite,
+		writeHeaders,
+		writeStatusCode
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/http-proxy-3@1.23.2_ms@2.1.3/node_modules/http-proxy-3/dist/lib/http-proxy/passes/web-incoming.js
+var require_web_incoming = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	});
+	var __importStar = exports && exports.__importStar || (function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o) {
+				var ar = [];
+				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+			}
+			__setModuleDefault(result, mod);
+			return result;
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.WEB_PASSES = void 0;
+	exports.deleteLength = deleteLength;
+	exports.timeout = timeout;
+	exports.XHeaders = XHeaders;
+	exports.stream = stream;
+	const http$2 = __importStar(__require("node:http"));
+	const https$1 = __importStar(__require("node:https"));
+	const followRedirects = __importStar(require_follow_redirects());
+	const common = __importStar(require_common());
+	const web_outgoing_1 = require_web_outgoing();
+	const node_stream_1 = __require("node:stream");
+	const web_o = Object.values(web_outgoing_1.OUTGOING_PASSES);
+	const nativeAgents = {
+		http: http$2,
+		https: https$1
+	};
+	function deleteLength(req) {
+		if ((req.method === "DELETE" || req.method === "OPTIONS") && !req.headers["content-length"]) {
+			req.headers["content-length"] = "0";
+			delete req.headers["transfer-encoding"];
+		}
+	}
+	function timeout(req, _res, options) {
+		if (options.timeout) req.socket.setTimeout(options.timeout);
+	}
+	function XHeaders(req, _res, options) {
+		if (!options.xfwd) return;
+		const encrypted = common.hasEncryptedConnection(req);
+		const values = {
+			for: req.connection.remoteAddress || req.socket.remoteAddress,
+			port: common.getPort(req),
+			proto: encrypted ? "https" : "http"
+		};
+		for (const header of [
+			"for",
+			"port",
+			"proto"
+		]) req.headers["x-forwarded-" + header] = (req.headers["x-forwarded-" + header] || "") + (req.headers["x-forwarded-" + header] ? "," : "") + values[header];
+		req.headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || req.headers[":authority"] || req.headers["host"] || "";
+	}
+	function stream(req, res, options, _, server, cb) {
+		server.emit("start", req, res, options.target || options.forward);
+		if (options.fetch || options.fetchOptions || process.env.FORCE_FETCH_PATH === "true") return stream2(req, res, options, _, server, cb);
+		const agents = options.followRedirects ? followRedirects : nativeAgents;
+		const http = agents.http;
+		const https = agents.https;
+		if (options.forward) {
+			const proto = options.forward.protocol === "https:" ? https : http;
+			const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req, "forward");
+			const forwardReq = proto.request(outgoingOptions);
+			const forwardError = createErrorHandler(forwardReq, options.forward);
+			req.on("error", forwardError);
+			forwardReq.on("error", forwardError);
+			(options.buffer || req).pipe(forwardReq);
+			if (!options.target) return res.end();
+		}
+		const proto = options.target.protocol === "https:" ? https : http;
+		const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req);
+		const proxyReq = proto.request(outgoingOptions);
+		proxyReq.on("socket", (socket) => {
+			if (server && !proxyReq.getHeader("expect")) server.emit("proxyReq", proxyReq, req, res, options, socket);
+		});
+		if (options.proxyTimeout) proxyReq.setTimeout(options.proxyTimeout, () => {
+			proxyReq.destroy();
+		});
+		res.on("close", () => {
+			if (!res.writableFinished) proxyReq.destroy();
+		});
+		const proxyError = createErrorHandler(proxyReq, options.target);
+		req.on("error", proxyError);
+		proxyReq.on("error", proxyError);
+		function createErrorHandler(proxyReq, url) {
+			return (err) => {
+				if (req.socket.destroyed && err.code === "ECONNRESET") {
+					server.emit("econnreset", err, req, res, url);
+					proxyReq.destroy();
+					return;
+				}
+				if (cb) cb(err, req, res, url);
+				else server.emit("error", err, req, res, url);
+			};
+		}
+		(options.buffer || req).pipe(proxyReq);
+		proxyReq.on("response", (proxyRes) => {
+			server?.emit("proxyRes", proxyRes, req, res);
+			if (!res.headersSent && !options.selfHandleResponse) for (const pass of web_o) pass(req, res, proxyRes, options);
+			if (!res.finished) {
+				proxyRes.on("end", () => {
+					server?.emit("end", req, res, proxyRes);
+				});
+				if (!options.selfHandleResponse) proxyRes.pipe(res);
+			} else server?.emit("end", req, res, proxyRes);
+		});
+	}
+	async function stream2(req, res, options, _, server, cb) {
+		const handleError = (err, target) => {
+			const e = err;
+			if (e.code === void 0 && e.cause?.code) e.code = e.cause.code;
+			if (cb) cb(err, req, res, target);
+			else server.emit("error", err, req, res, target);
+		};
+		req.on("error", (err) => {
+			if (req.socket.destroyed && err.code === "ECONNRESET") {
+				const target = options.target || options.forward;
+				if (target) server.emit("econnreset", err, req, res, target);
+				return;
+			}
+			handleError(err);
+		});
+		const customFetch = options.fetch || fetch;
+		const fetchOptions = options.fetchOptions ?? {};
+		const prepareRequest = (outgoing) => {
+			const requestOptions = {
+				method: outgoing.method,
+				...fetchOptions.requestOptions
+			};
+			const headers = new Headers(fetchOptions.requestOptions?.headers);
+			if (!fetchOptions.requestOptions?.headers && outgoing.headers) {
+				for (const [key, value] of Object.entries(outgoing.headers)) if (typeof key === "string") {
+					if (Array.isArray(value)) for (const v of value) headers.append(key, v);
+					else if (value != null) headers.append(key, value);
+				}
+			}
+			if (options.auth) headers.set("authorization", `Basic ${Buffer.from(options.auth).toString("base64")}`);
+			if (options.proxyTimeout) requestOptions.signal = AbortSignal.timeout(options.proxyTimeout);
+			requestOptions.headers = headers;
+			if (options.buffer) requestOptions.body = options.buffer;
+			else if (req.method !== "GET" && req.method !== "HEAD") {
+				requestOptions.body = req;
+				requestOptions.duplex = "half";
+			}
+			return requestOptions;
+		};
+		if (options.forward) {
+			const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req, "forward");
+			const requestOptions = prepareRequest(outgoingOptions);
+			let targetUrl = new URL(outgoingOptions.url).origin + outgoingOptions.path;
+			if (targetUrl.startsWith("ws")) targetUrl = targetUrl.replace("ws", "http");
+			if (fetchOptions.onBeforeRequest) try {
+				await fetchOptions.onBeforeRequest(requestOptions, req, res, options);
+			} catch (err) {
+				handleError(err, options.forward);
+				return;
+			}
+			try {
+				const result = await customFetch(targetUrl, requestOptions);
+				if (fetchOptions.onAfterResponse) try {
+					await fetchOptions.onAfterResponse(result, req, res, options);
+				} catch (err) {
+					handleError(err, options.forward);
+					return;
+				}
+			} catch (err) {
+				handleError(err, options.forward);
+			}
+			if (!options.target) return res.end();
+		}
+		const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req);
+		const requestOptions = prepareRequest(outgoingOptions);
+		let targetUrl = new URL(outgoingOptions.url).origin + outgoingOptions.path;
+		if (targetUrl.startsWith("ws")) targetUrl = targetUrl.replace("ws", "http");
+		if (fetchOptions.onBeforeRequest) try {
+			await fetchOptions.onBeforeRequest(requestOptions, req, res, options);
+		} catch (err) {
+			handleError(err, options.target);
+			return;
+		}
+		try {
+			const response = await customFetch(targetUrl, requestOptions);
+			if (fetchOptions.onAfterResponse) try {
+				await fetchOptions.onAfterResponse(response, req, res, options);
+			} catch (err) {
+				handleError(err, options.target);
+				return;
+			}
+			const fakeProxyRes = {
+				statusCode: response.status,
+				statusMessage: response.statusText,
+				headers: Object.fromEntries(response.headers.entries()),
+				rawHeaders: Object.entries(response.headers).flatMap(([key, value]) => {
+					if (Array.isArray(value)) return value.flatMap((v) => v != null ? [key, v] : []);
+					return value != null ? [key, value] : [];
+				})
+			};
+			server?.emit("proxyRes", fakeProxyRes, req, res);
+			if (!res.headersSent && !options.selfHandleResponse) for (const pass of web_o) pass(req, res, fakeProxyRes, options);
+			if (!res.writableEnded) {
+				const nodeStream = response.body ? node_stream_1.Readable.from(response.body) : null;
+				if (nodeStream) {
+					nodeStream.on("error", (err) => {
+						handleError(err, options.target);
+					});
+					nodeStream.on("end", () => {
+						server?.emit("end", req, res, fakeProxyRes);
+					});
+					if (!options.selfHandleResponse) nodeStream.pipe(res, { end: true });
+					else nodeStream.resume();
+				} else server?.emit("end", req, res, fakeProxyRes);
+			} else server?.emit("end", req, res, fakeProxyRes);
+		} catch (err) {
+			handleError(err, options.target);
+		}
+	}
+	exports.WEB_PASSES = {
+		deleteLength,
+		timeout,
+		XHeaders,
+		stream
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/http-proxy-3@1.23.2_ms@2.1.3/node_modules/http-proxy-3/dist/lib/http-proxy/passes/ws-incoming.js
+var require_ws_incoming = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	});
+	var __importStar = exports && exports.__importStar || (function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o) {
+				var ar = [];
+				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+			}
+			__setModuleDefault(result, mod);
+			return result;
+		};
+	})();
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.WS_PASSES = void 0;
+	exports.numOpenSockets = numOpenSockets;
+	exports.checkMethodAndHeader = checkMethodAndHeader;
+	exports.XHeaders = XHeaders;
+	exports.stream = stream;
+	const http$1 = __importStar(__require("node:http"));
+	const https = __importStar(__require("node:https"));
+	const common = __importStar(require_common());
+	const web_outgoing_1 = require_web_outgoing();
+	const log = (0, __importDefault((init_node(), __toCommonJS(node_exports))).default)("http-proxy-3:ws-incoming");
+	const web_o = Object.values(web_outgoing_1.OUTGOING_PASSES);
+	function createSocketCounter(name) {
+		let sockets = /* @__PURE__ */ new Set();
+		return ({ add, rm } = {}) => {
+			if (add) {
+				if (!add.id) add.id = Math.random();
+				if (!sockets.has(add.id)) sockets.add(add.id);
+			}
+			if (rm) {
+				if (!rm.id) rm.id = Math.random();
+				if (sockets.has(rm.id)) sockets.delete(rm.id);
+			}
+			log("socket counter:", { [name]: sockets.size }, add ? "add" : rm ? "rm" : "");
+			return sockets.size;
+		};
+	}
+	const socketCounter = createSocketCounter("socket");
+	const proxySocketCounter = createSocketCounter("proxySocket");
+	var MockResponse = class {
+		constructor() {
+			this.headers = {};
+			this.statusCode = 200;
+			this.statusMessage = "";
+		}
+		setHeader(key, value) {
+			this.headers[key] = value;
+			return this;
+		}
+	};
+	function numOpenSockets() {
+		return socketCounter() + proxySocketCounter();
+	}
+	function checkMethodAndHeader(req, socket) {
+		log("websocket: checkMethodAndHeader");
+		if (req.method !== "GET" || !req.headers.upgrade) {
+			socket.destroy();
+			return true;
+		}
+		if (req.headers.upgrade.toLowerCase() !== "websocket") {
+			socket.destroy();
+			return true;
+		}
+	}
+	function XHeaders(req, _socket, options) {
+		if (!options.xfwd) return;
+		log("websocket: XHeaders");
+		const values = {
+			for: req.connection.remoteAddress || req.socket.remoteAddress,
+			port: common.getPort(req),
+			proto: common.hasEncryptedConnection(req) ? "wss" : "ws"
+		};
+		for (const header of [
+			"for",
+			"port",
+			"proto"
+		]) req.headers["x-forwarded-" + header] = (req.headers["x-forwarded-" + header] || "") + (req.headers["x-forwarded-" + header] ? "," : "") + values[header];
+	}
+	function stream(req, socket, options, head, server, cb) {
+		log("websocket: new stream");
+		const proxySockets = [];
+		socketCounter({ add: socket });
+		const cleanUpProxySockets = () => {
+			for (const p of proxySockets) p.end();
+		};
+		socket.on("close", () => {
+			socketCounter({ rm: socket });
+			cleanUpProxySockets();
+		});
+		socket.on("error", cleanUpProxySockets);
+		const createHttpHeader = (line, headers) => {
+			return Object.keys(headers).reduce((head, key) => {
+				const value = headers[key];
+				if (!Array.isArray(value)) {
+					head.push(key + ": " + value);
+					return head;
+				}
+				for (let i = 0; i < value.length; i++) head.push(key + ": " + value[i]);
+				return head;
+			}, [line]).join("\r\n") + "\r\n\r\n";
+		};
+		common.setupSocket(socket);
+		if (head && head.length) socket.unshift(head);
+		const proto = common.isSSL.test(options.target.protocol) ? https : http$1;
+		const outgoingOptions = common.setupOutgoing(options.ssl || {}, options, req);
+		const proxyReq = proto.request(outgoingOptions);
+		if (server) server.emit("proxyReqWs", proxyReq, req, socket, options, head);
+		proxyReq.on("error", onOutgoingError);
+		proxyReq.on("upgrade", (proxyRes, proxySocket, proxyHead) => {
+			log("upgrade");
+			proxySocketCounter({ add: proxySocket });
+			proxySockets.push(proxySocket);
+			proxySocket.on("close", () => {
+				proxySocketCounter({ rm: proxySocket });
+			});
+			proxySocket.on("error", onOutgoingError);
+			proxySocket.on("end", () => {
+				server.emit("close", proxyRes, proxySocket, proxyHead);
+			});
+			proxySocket.on("close", () => {
+				socket.end();
+			});
+			common.setupSocket(proxySocket);
+			if (proxyHead && proxyHead.length) proxySocket.unshift(proxyHead);
+			socket.write(createHttpHeader("HTTP/1.1 101 Switching Protocols", proxyRes.headers));
+			proxySocket.pipe(socket).pipe(proxySocket);
+			server.emit("open", proxySocket);
+		});
+		function onOutgoingError(err) {
+			if (cb) cb(err, req, socket);
+			else server.emit("error", err, req, socket);
+			socket.destroySoon();
+		}
+		proxyReq.on("response", (proxyRes) => {
+			log("got non-ws HTTP response", {
+				statusCode: proxyRes.statusCode,
+				statusMessage: proxyRes.statusMessage
+			});
+			const res = new MockResponse();
+			for (const pass of web_o) pass(req, res, proxyRes, options);
+			let writeChunk = (chunk) => {
+				socket.write(chunk);
+			};
+			if (req.httpVersion === "1.1" && proxyRes.headers["content-length"] === void 0) {
+				res.headers["transfer-encoding"] = "chunked";
+				writeChunk = (chunk) => {
+					socket.write(chunk.length.toString(16));
+					socket.write("\r\n");
+					socket.write(chunk);
+					socket.write("\r\n");
+				};
+			}
+			const proxyHead = createHttpHeader(`HTTP/${req.httpVersion} ${proxyRes.statusCode} ${proxyRes.statusMessage}`, res.headers);
+			if (!socket.destroyed) {
+				socket.write(proxyHead);
+				proxyRes.on("data", (chunk) => {
+					writeChunk(chunk);
+				});
+				proxyRes.on("end", () => {
+					writeChunk("");
+					socket.destroySoon();
+				});
+			} else proxyRes.resume();
+		});
+		proxyReq.end();
+	}
+	exports.WS_PASSES = {
+		checkMethodAndHeader,
+		XHeaders,
+		stream
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/http-proxy-3@1.23.2_ms@2.1.3/node_modules/http-proxy-3/dist/lib/http-proxy/index.js
+var require_http_proxy = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	});
+	var __importStar = exports && exports.__importStar || (function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o) {
+				var ar = [];
+				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+			}
+			__setModuleDefault(result, mod);
+			return result;
+		};
+	})();
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ProxyServer = void 0;
+	const http = __importStar(__require("node:http"));
+	const http2 = __importStar(__require("node:http2"));
+	const web_incoming_1 = require_web_incoming();
+	const ws_incoming_1 = require_ws_incoming();
+	const node_events_1 = __require("node:events");
+	const debug_1 = __importDefault((init_node(), __toCommonJS(node_exports)));
+	const common_1 = require_common();
+	const log = (0, debug_1.default)("http-proxy-3");
+	exports.ProxyServer = class ProxyServer extends node_events_1.EventEmitter {
+		/**
+		* Creates the proxy server with specified options.
+		* @param options - Config object passed to the proxy
+		*/
+		constructor(options = {}) {
+			super();
+			this.createRightProxy = (type) => {
+				log("createRightProxy", { type });
+				return (options) => {
+					return (...args) => {
+						const req = args[0];
+						log("proxy: ", {
+							type,
+							path: req.url
+						});
+						const res = args[1];
+						const passes = type === "ws" ? this.wsPasses : this.webPasses;
+						if (type == "ws") res.on("error", (err) => {
+							this.emit("error", err, req, res);
+						});
+						let counter = args.length - 1;
+						let head;
+						let cb;
+						if (typeof args[counter] === "function") {
+							cb = args[counter];
+							counter--;
+						}
+						let requestOptions;
+						if (!(args[counter] instanceof Buffer) && args[counter] !== res) {
+							requestOptions = {
+								...options,
+								...args[counter]
+							};
+							counter--;
+						} else requestOptions = { ...options };
+						if (args[counter] instanceof Buffer) head = args[counter];
+						for (const e of ["target", "forward"]) if (typeof requestOptions[e] === "string") requestOptions[e] = (0, common_1.toURL)(requestOptions[e]);
+						if (!requestOptions.target && !requestOptions.forward) {
+							this.emit("error", /* @__PURE__ */ new Error("Must set target or forward"), req, res);
+							return;
+						}
+						for (const pass of passes)
+ /**
+						* Call of passes functions
+						*     pass(req, res, options, head)
+						*
+						* In WebSockets case, the `res` variable
+						* refer to the connection socket
+						*    pass(req, socket, options, head)
+						*/
+						if (pass(req, res, requestOptions, head, this, cb)) break;
+					};
+				};
+			};
+			this.onError = (err) => {
+				if (this.listeners("error").length === 1) throw err;
+			};
+			/**
+			* A function that wraps the object in a webserver, for your convenience
+			* @param port - Port to listen on
+			* @param hostname - The hostname to listen on
+			*/
+			this.listen = (port, hostname) => {
+				log("listen", {
+					port,
+					hostname
+				});
+				const requestListener = (req, res) => {
+					this.web(req, res);
+				};
+				this._server = this.options.ssl ? http2.createSecureServer({
+					...this.options.ssl,
+					allowHTTP1: true
+				}, requestListener) : http.createServer(requestListener);
+				if (this.options.ws) this._server.on("upgrade", (req, socket, head) => {
+					this.ws(req, socket, head);
+				});
+				this._server.listen(port, hostname);
+				return this;
+			};
+			this.address = () => {
+				return this._server?.address();
+			};
+			/**
+			* A function that closes the inner webserver and stops listening on given port
+			*/
+			this.close = (cb) => {
+				if (this._server == null) {
+					cb?.();
+					return;
+				}
+				this._server.close((err) => {
+					this._server = null;
+					cb?.(err);
+				});
+			};
+			this.before = (type, passName, cb) => {
+				if (type !== "ws" && type !== "web") throw new Error("type must be `web` or `ws`");
+				const passes = type === "ws" ? this.wsPasses : this.webPasses;
+				let i = false;
+				passes.forEach((v, idx) => {
+					if (v.name === passName) i = idx;
+				});
+				if (i === false) throw new Error("No such pass");
+				passes.splice(i, 0, cb);
+			};
+			this.after = (type, passName, cb) => {
+				if (type !== "ws" && type !== "web") throw new Error("type must be `web` or `ws`");
+				const passes = type === "ws" ? this.wsPasses : this.webPasses;
+				let i = false;
+				passes.forEach((v, idx) => {
+					if (v.name === passName) i = idx;
+				});
+				if (i === false) throw new Error("No such pass");
+				passes.splice(i++, 0, cb);
+			};
+			log("creating a ProxyServer", options);
+			options.prependPath = options.prependPath !== false;
+			this.options = options;
+			this.web = this.createRightProxy("web")(options);
+			this.ws = this.createRightProxy("ws")(options);
+			this.webPasses = Object.values(web_incoming_1.WEB_PASSES);
+			this.wsPasses = Object.values(ws_incoming_1.WS_PASSES);
+			this.on("error", this.onError);
+		}
+		/**
+		* Creates the proxy server with specified options.
+		* @param options Config object passed to the proxy
+		* @returns Proxy object with handlers for `ws` and `web` requests
+		*/
+		static createProxyServer(options) {
+			return new ProxyServer(options);
+		}
+		/**
+		* Creates the proxy server with specified options.
+		* @param options Config object passed to the proxy
+		* @returns Proxy object with handlers for `ws` and `web` requests
+		*/
+		static createServer(options) {
+			return new ProxyServer(options);
+		}
+		/**
+		* Creates the proxy server with specified options.
+		* @param options Config object passed to the proxy
+		* @returns Proxy object with handlers for `ws` and `web` requests
+		*/
+		static createProxy(options) {
+			return new ProxyServer(options);
+		}
+	};
+}));
+//#endregion
+//#region src/node/server/middlewares/proxy.ts
+var import_lib$1 = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.numOpenSockets = exports.ProxyServer = void 0;
+	exports.createProxyServer = createProxyServer;
+	const index_1 = require_http_proxy();
+	Object.defineProperty(exports, "ProxyServer", {
+		enumerable: true,
+		get: function() {
+			return index_1.ProxyServer;
+		}
+	});
+	var ws_incoming_1 = require_ws_incoming();
+	Object.defineProperty(exports, "numOpenSockets", {
+		enumerable: true,
+		get: function() {
+			return ws_incoming_1.numOpenSockets;
+		}
+	});
+	/**
+	* Creates the proxy server.
+	*
+	* Examples:
+	*
+	*    httpProxy.createProxyServer({ .. }, 8000)
+	*    // => '{ web: [Function], ws: [Function] ... }'
+	*
+	* @param {Object} Options Config object passed to the proxy
+	*
+	* @return {Object} Proxy Proxy object with handlers for `ws` and `web` requests
+	*
+	* @api public
+	*/
+	function createProxyServer(options = {}) {
+		return new index_1.ProxyServer(options);
+	}
+})))(), 1);
+const debug$11 = createDebugger("vite:proxy");
+const rewriteOriginHeader = (proxyReq, options, config) => {
+	if (options.rewriteWsOrigin) {
+		const { target } = options;
+		if (proxyReq.headersSent) {
+			config.logger.warn(import_picocolors.default.yellow(`Unable to rewrite Origin header as headers are already sent.`));
+			return;
+		}
+		if (proxyReq.getHeader("origin") && target) {
+			const changedOrigin = typeof target === "object" ? `${target.protocol ?? "http:"}//${target.host}` : target;
+			proxyReq.setHeader("origin", changedOrigin);
+		}
+	}
+};
+function proxyMiddleware(httpServer, options, config) {
+	const proxies = {};
+	Object.keys(options).forEach((context) => {
+		let opts = options[context];
+		if (!opts) return;
+		if (typeof opts === "string") opts = {
+			target: opts,
+			changeOrigin: true
+		};
+		const proxy = import_lib$1.createProxyServer(opts);
+		if (opts.configure) opts.configure(proxy, opts);
+		proxy.on("error", (err, _req, res) => {
+			if ("req" in res) {
+				config.logger.error(`${import_picocolors.default.red(`http proxy error: ${res.req.url}`)}\n${err.stack}`, {
+					timestamp: true,
+					error: err
+				});
+				if (!res.headersSent && !res.writableEnded) res.writeHead(502, { "Content-Type": "text/plain" }).end();
+			} else {
+				config.logger.error(`${import_picocolors.default.red(`ws proxy error:`)}\n${err.stack}`, {
+					timestamp: true,
+					error: err
+				});
+				res.end();
+			}
+		});
+		proxy.on("proxyReqWs", (proxyReq, _req, socket, options) => {
+			rewriteOriginHeader(proxyReq, options, config);
+			socket.on("error", (err) => {
+				config.logger.error(`${import_picocolors.default.red(`ws proxy socket error:`)}\n${err.stack}`, {
+					timestamp: true,
+					error: err
+				});
+			});
+		});
+		proxies[context] = [proxy, { ...opts }];
+	});
+	if (httpServer) httpServer.on("upgrade", async (req, socket, head) => {
+		const url = req.url;
+		for (const context in proxies) if (doesProxyContextMatchUrl(context, url)) {
+			const [proxy, opts] = proxies[context];
+			if (opts.ws || opts.target?.toString().startsWith("ws:") || opts.target?.toString().startsWith("wss:")) {
+				if (opts.bypass) try {
+					const bypassResult = await opts.bypass(req, void 0, opts);
+					if (typeof bypassResult === "string") {
+						debug$11?.(`bypass: ${req.url} -> ${bypassResult}`);
+						req.url = bypassResult;
+						return;
+					}
+					if (bypassResult === false) {
+						debug$11?.(`bypass: ${req.url} -> 404`);
+						socket.end("HTTP/1.1 404 Not Found\r\n\r\n", "");
+						return;
+					}
+				} catch (err) {
+					config.logger.error(`${import_picocolors.default.red(`ws proxy bypass error:`)}\n${err.stack}`, {
+						timestamp: true,
+						error: err
+					});
+					return;
+				}
+				if (opts.rewrite) req.url = opts.rewrite(url);
+				debug$11?.(`${req.url} -> ws ${opts.target}`);
+				proxy.ws(req, socket, head);
+				return;
+			}
+		}
+	});
+	return async function viteProxyMiddleware(req, res, next) {
+		const url = req.url;
+		for (const context in proxies) if (doesProxyContextMatchUrl(context, url)) {
+			const [proxy, opts] = proxies[context];
+			const options = {};
+			if (opts.bypass) try {
+				const bypassResult = await opts.bypass(req, res, opts);
+				if (typeof bypassResult === "string") {
+					debug$11?.(`bypass: ${req.url} -> ${bypassResult}`);
+					req.url = bypassResult;
+					if (res.writableEnded) return;
+					return next();
+				}
+				if (bypassResult === false) {
+					debug$11?.(`bypass: ${req.url} -> 404`);
+					res.statusCode = 404;
+					return res.end();
+				}
+			} catch (e) {
+				debug$11?.(`bypass: ${req.url} -> ${e}`);
+				return next(e);
+			}
+			debug$11?.(`${req.url} -> ${opts.target || opts.forward}`);
+			if (opts.rewrite) req.url = opts.rewrite(req.url);
+			proxy.web(req, res, options);
+			return;
+		}
+		next();
+	};
+}
+function doesProxyContextMatchUrl(context, url) {
+	return context[0] === "^" && new RegExp(context).test(url) || url.startsWith(context);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/etag@1.8.1/node_modules/etag/index.js
+/*!
+* etag
+* Copyright(c) 2014-2016 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_etag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = etag;
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var crypto$1 = __require("crypto");
+	var Stats = __require("fs").Stats;
+	/**
+	* Module variables.
+	* @private
+	*/
+	var toString = Object.prototype.toString;
+	/**
+	* Generate an entity tag.
+	*
+	* @param {Buffer|string} entity
+	* @return {string}
+	* @private
+	*/
+	function entitytag(entity) {
+		if (entity.length === 0) return "\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"";
+		var hash = crypto$1.createHash("sha1").update(entity, "utf8").digest("base64").substring(0, 27);
+		return "\"" + (typeof entity === "string" ? Buffer.byteLength(entity, "utf8") : entity.length).toString(16) + "-" + hash + "\"";
+	}
+	/**
+	* Create a simple ETag.
+	*
+	* @param {string|Buffer|Stats} entity
+	* @param {object} [options]
+	* @param {boolean} [options.weak]
+	* @return {String}
+	* @public
+	*/
+	function etag(entity, options) {
+		if (entity == null) throw new TypeError("argument entity is required");
+		var isStats = isstats(entity);
+		var weak = options && typeof options.weak === "boolean" ? options.weak : isStats;
+		if (!isStats && typeof entity !== "string" && !Buffer.isBuffer(entity)) throw new TypeError("argument entity must be string, Buffer, or fs.Stats");
+		var tag = isStats ? stattag(entity) : entitytag(entity);
+		return weak ? "W/" + tag : tag;
+	}
+	/**
+	* Determine if object is a Stats object.
+	*
+	* @param {object} obj
+	* @return {boolean}
+	* @api private
+	*/
+	function isstats(obj) {
+		if (typeof Stats === "function" && obj instanceof Stats) return true;
+		return obj && typeof obj === "object" && "ctime" in obj && toString.call(obj.ctime) === "[object Date]" && "mtime" in obj && toString.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number";
+	}
+	/**
+	* Generate a tag for a stat.
+	*
+	* @param {object} stat
+	* @return {string}
+	* @private
+	*/
+	function stattag(stat) {
+		var mtime = stat.mtime.getTime().toString(16);
+		return "\"" + stat.size.toString(16) + "-" + mtime + "\"";
+	}
+}));
+//#endregion
+//#region src/node/environment.ts
+/**
+* Creates a function that hides the complexities of a WeakMap with an initial value
+* to implement object metadata. Used by plugins to implement cross hooks per
+* environment metadata
+*
+* @experimental
+*/
+function perEnvironmentState(initial) {
+	const stateMap = /* @__PURE__ */ new WeakMap();
+	return function(context) {
+		const { environment } = context;
+		let state = stateMap.get(environment);
+		if (!state) {
+			state = initial(environment);
+			stateMap.set(environment, state);
+		}
+		return state;
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/strip-literal@3.1.0/node_modules/strip-literal/dist/index.mjs
+var import_js_tokens = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+	Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
+	Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/uy;
+	StringLiteral = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y;
+	NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
+	Template = /[`}](?:[^`\\$]+|\\[^]|\$(?!\{))*(`|\$\{)?/y;
+	WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/uy;
+	LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+	MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y;
+	SingleLineComment = /\/\/.*/y;
+	HashbangComment = /^#!.*/;
+	JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
+	JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/uy;
+	JSXString = /(['"])(?:[^'"]+|(?!\1)['"])*(\1)?/y;
+	JSXText = /[^<>{}]+/y;
+	TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
+	TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
+	KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
+	KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
+	Newline = RegExp(LineTerminatorSequence.source);
+	module.exports = function* (input, { jsx = false } = {}) {
+		var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
+		({length} = input);
+		lastIndex = 0;
+		lastSignificantToken = "";
+		stack = [{ tag: "JS" }];
+		braces = [];
+		parenNesting = 0;
+		postfixIncDec = false;
+		if (match = HashbangComment.exec(input)) {
+			yield {
+				type: "HashbangComment",
+				value: match[0]
+			};
+			lastIndex = match[0].length;
+		}
+		while (lastIndex < length) {
+			mode = stack[stack.length - 1];
+			switch (mode.tag) {
+				case "JS":
+				case "JSNonExpressionParen":
+				case "InterpolationInTemplate":
+				case "InterpolationInJSX":
+					if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+						RegularExpressionLiteral.lastIndex = lastIndex;
+						if (match = RegularExpressionLiteral.exec(input)) {
+							lastIndex = RegularExpressionLiteral.lastIndex;
+							lastSignificantToken = match[0];
+							postfixIncDec = true;
+							yield {
+								type: "RegularExpressionLiteral",
+								value: match[0],
+								closed: match[1] !== void 0 && match[1] !== "\\"
+							};
+							continue;
+						}
+					}
+					Punctuator.lastIndex = lastIndex;
+					if (match = Punctuator.exec(input)) {
+						punctuator = match[0];
+						nextLastIndex = Punctuator.lastIndex;
+						nextLastSignificantToken = punctuator;
+						switch (punctuator) {
+							case "(":
+								if (lastSignificantToken === "?NonExpressionParenKeyword") stack.push({
+									tag: "JSNonExpressionParen",
+									nesting: parenNesting
+								});
+								parenNesting++;
+								postfixIncDec = false;
+								break;
+							case ")":
+								parenNesting--;
+								postfixIncDec = true;
+								if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
+									stack.pop();
+									nextLastSignificantToken = "?NonExpressionParenEnd";
+									postfixIncDec = false;
+								}
+								break;
+							case "{":
+								Punctuator.lastIndex = 0;
+								isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
+								braces.push(isExpression);
+								postfixIncDec = false;
+								break;
+							case "}":
+								switch (mode.tag) {
+									case "InterpolationInTemplate":
+										if (braces.length === mode.nesting) {
+											Template.lastIndex = lastIndex;
+											match = Template.exec(input);
+											lastIndex = Template.lastIndex;
+											lastSignificantToken = match[0];
+											if (match[1] === "${") {
+												lastSignificantToken = "?InterpolationInTemplate";
+												postfixIncDec = false;
+												yield {
+													type: "TemplateMiddle",
+													value: match[0]
+												};
+											} else {
+												stack.pop();
+												postfixIncDec = true;
+												yield {
+													type: "TemplateTail",
+													value: match[0],
+													closed: match[1] === "`"
+												};
+											}
+											continue;
+										}
+										break;
+									case "InterpolationInJSX": if (braces.length === mode.nesting) {
+										stack.pop();
+										lastIndex += 1;
+										lastSignificantToken = "}";
+										yield {
+											type: "JSXPunctuator",
+											value: "}"
+										};
+										continue;
+									}
+								}
+								postfixIncDec = braces.pop();
+								nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
+								break;
+							case "]":
+								postfixIncDec = true;
+								break;
+							case "++":
+							case "--":
+								nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
+								break;
+							case "<":
+								if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+									stack.push({ tag: "JSXTag" });
+									lastIndex += 1;
+									lastSignificantToken = "<";
+									yield {
+										type: "JSXPunctuator",
+										value: punctuator
+									};
+									continue;
+								}
+								postfixIncDec = false;
+								break;
+							default: postfixIncDec = false;
+						}
+						lastIndex = nextLastIndex;
+						lastSignificantToken = nextLastSignificantToken;
+						yield {
+							type: "Punctuator",
+							value: punctuator
+						};
+						continue;
+					}
+					Identifier.lastIndex = lastIndex;
+					if (match = Identifier.exec(input)) {
+						lastIndex = Identifier.lastIndex;
+						nextLastSignificantToken = match[0];
+						switch (match[0]) {
+							case "for":
+							case "if":
+							case "while":
+							case "with": if (lastSignificantToken !== "." && lastSignificantToken !== "?.") nextLastSignificantToken = "?NonExpressionParenKeyword";
+						}
+						lastSignificantToken = nextLastSignificantToken;
+						postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
+						yield {
+							type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
+							value: match[0]
+						};
+						continue;
+					}
+					StringLiteral.lastIndex = lastIndex;
+					if (match = StringLiteral.exec(input)) {
+						lastIndex = StringLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield {
+							type: "StringLiteral",
+							value: match[0],
+							closed: match[2] !== void 0
+						};
+						continue;
+					}
+					NumericLiteral.lastIndex = lastIndex;
+					if (match = NumericLiteral.exec(input)) {
+						lastIndex = NumericLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield {
+							type: "NumericLiteral",
+							value: match[0]
+						};
+						continue;
+					}
+					Template.lastIndex = lastIndex;
+					if (match = Template.exec(input)) {
+						lastIndex = Template.lastIndex;
+						lastSignificantToken = match[0];
+						if (match[1] === "${") {
+							lastSignificantToken = "?InterpolationInTemplate";
+							stack.push({
+								tag: "InterpolationInTemplate",
+								nesting: braces.length
+							});
+							postfixIncDec = false;
+							yield {
+								type: "TemplateHead",
+								value: match[0]
+							};
+						} else {
+							postfixIncDec = true;
+							yield {
+								type: "NoSubstitutionTemplate",
+								value: match[0],
+								closed: match[1] === "`"
+							};
+						}
+						continue;
+					}
+					break;
+				case "JSXTag":
+				case "JSXTagEnd":
+					JSXPunctuator.lastIndex = lastIndex;
+					if (match = JSXPunctuator.exec(input)) {
+						lastIndex = JSXPunctuator.lastIndex;
+						nextLastSignificantToken = match[0];
+						switch (match[0]) {
+							case "<":
+								stack.push({ tag: "JSXTag" });
+								break;
+							case ">":
+								stack.pop();
+								if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
+									nextLastSignificantToken = "?JSX";
+									postfixIncDec = true;
+								} else stack.push({ tag: "JSXChildren" });
+								break;
+							case "{":
+								stack.push({
+									tag: "InterpolationInJSX",
+									nesting: braces.length
+								});
+								nextLastSignificantToken = "?InterpolationInJSX";
+								postfixIncDec = false;
+								break;
+							case "/": if (lastSignificantToken === "<") {
+								stack.pop();
+								if (stack[stack.length - 1].tag === "JSXChildren") stack.pop();
+								stack.push({ tag: "JSXTagEnd" });
+							}
+						}
+						lastSignificantToken = nextLastSignificantToken;
+						yield {
+							type: "JSXPunctuator",
+							value: match[0]
+						};
+						continue;
+					}
+					JSXIdentifier.lastIndex = lastIndex;
+					if (match = JSXIdentifier.exec(input)) {
+						lastIndex = JSXIdentifier.lastIndex;
+						lastSignificantToken = match[0];
+						yield {
+							type: "JSXIdentifier",
+							value: match[0]
+						};
+						continue;
+					}
+					JSXString.lastIndex = lastIndex;
+					if (match = JSXString.exec(input)) {
+						lastIndex = JSXString.lastIndex;
+						lastSignificantToken = match[0];
+						yield {
+							type: "JSXString",
+							value: match[0],
+							closed: match[2] !== void 0
+						};
+						continue;
+					}
+					break;
+				case "JSXChildren":
+					JSXText.lastIndex = lastIndex;
+					if (match = JSXText.exec(input)) {
+						lastIndex = JSXText.lastIndex;
+						lastSignificantToken = match[0];
+						yield {
+							type: "JSXText",
+							value: match[0]
+						};
+						continue;
+					}
+					switch (input[lastIndex]) {
+						case "<":
+							stack.push({ tag: "JSXTag" });
+							lastIndex++;
+							lastSignificantToken = "<";
+							yield {
+								type: "JSXPunctuator",
+								value: "<"
+							};
+							continue;
+						case "{":
+							stack.push({
+								tag: "InterpolationInJSX",
+								nesting: braces.length
+							});
+							lastIndex++;
+							lastSignificantToken = "?InterpolationInJSX";
+							postfixIncDec = false;
+							yield {
+								type: "JSXPunctuator",
+								value: "{"
+							};
+							continue;
+					}
+			}
+			WhiteSpace.lastIndex = lastIndex;
+			if (match = WhiteSpace.exec(input)) {
+				lastIndex = WhiteSpace.lastIndex;
+				yield {
+					type: "WhiteSpace",
+					value: match[0]
+				};
+				continue;
+			}
+			LineTerminatorSequence.lastIndex = lastIndex;
+			if (match = LineTerminatorSequence.exec(input)) {
+				lastIndex = LineTerminatorSequence.lastIndex;
+				postfixIncDec = false;
+				if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere";
+				yield {
+					type: "LineTerminatorSequence",
+					value: match[0]
+				};
+				continue;
+			}
+			MultiLineComment.lastIndex = lastIndex;
+			if (match = MultiLineComment.exec(input)) {
+				lastIndex = MultiLineComment.lastIndex;
+				if (Newline.test(match[0])) {
+					postfixIncDec = false;
+					if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere";
+				}
+				yield {
+					type: "MultiLineComment",
+					value: match[0],
+					closed: match[1] !== void 0
+				};
+				continue;
+			}
+			SingleLineComment.lastIndex = lastIndex;
+			if (match = SingleLineComment.exec(input)) {
+				lastIndex = SingleLineComment.lastIndex;
+				postfixIncDec = false;
+				yield {
+					type: "SingleLineComment",
+					value: match[0]
+				};
+				continue;
+			}
+			firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
+			lastIndex += firstCodePoint.length;
+			lastSignificantToken = firstCodePoint;
+			postfixIncDec = false;
+			yield {
+				type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
+				value: firstCodePoint
+			};
+		}
+	};
+})))(), 1);
+const FILL_COMMENT = " ";
+function stripLiteralFromToken(token, fillChar, filter) {
+	if (token.type === "SingleLineComment") return FILL_COMMENT.repeat(token.value.length);
+	if (token.type === "MultiLineComment") return token.value.replace(/[^\n]/g, FILL_COMMENT);
+	if (token.type === "StringLiteral") {
+		if (!token.closed) return token.value;
+		const body = token.value.slice(1, -1);
+		if (filter(body)) return token.value[0] + fillChar.repeat(body.length) + token.value[token.value.length - 1];
+	}
+	if (token.type === "NoSubstitutionTemplate") {
+		const body = token.value.slice(1, -1);
+		if (filter(body)) return `\`${body.replace(/[^\n]/g, fillChar)}\``;
+	}
+	if (token.type === "RegularExpressionLiteral") {
+		const body = token.value;
+		if (filter(body)) return body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${fillChar.repeat($1.length)}/${$2}`);
+	}
+	if (token.type === "TemplateHead") {
+		const body = token.value.slice(1, -2);
+		if (filter(body)) return `\`${body.replace(/[^\n]/g, fillChar)}\${`;
+	}
+	if (token.type === "TemplateTail") {
+		const body = token.value.slice(0, -2);
+		if (filter(body)) return `}${body.replace(/[^\n]/g, fillChar)}\``;
+	}
+	if (token.type === "TemplateMiddle") {
+		const body = token.value.slice(1, -2);
+		if (filter(body)) return `}${body.replace(/[^\n]/g, fillChar)}\${`;
+	}
+	return token.value;
+}
+function optionsWithDefaults(options) {
+	return {
+		fillChar: options?.fillChar ?? " ",
+		filter: options?.filter ?? (() => true)
+	};
+}
+function stripLiteral(code, options) {
+	let result = "";
+	const _options = optionsWithDefaults(options);
+	for (const token of (0, import_js_tokens.default)(code, { jsx: false })) result += stripLiteralFromToken(token, _options.fillChar, _options.filter);
+	return result;
+}
+//#endregion
+//#region src/node/assetSource.ts
+const ALLOWED_META_NAME = [
+	"msapplication-tileimage",
+	"msapplication-square70x70logo",
+	"msapplication-square150x150logo",
+	"msapplication-wide310x150logo",
+	"msapplication-square310x310logo",
+	"msapplication-config",
+	"twitter:image"
+];
+const ALLOWED_META_PROPERTY = [
+	"og:image",
+	"og:image:url",
+	"og:image:secure_url",
+	"og:audio",
+	"og:audio:secure_url",
+	"og:video",
+	"og:video:secure_url"
+];
+const DEFAULT_HTML_ASSET_SOURCES = {
+	audio: { srcAttributes: ["src"] },
+	embed: { srcAttributes: ["src"] },
+	img: {
+		srcAttributes: ["src"],
+		srcsetAttributes: ["srcset"]
+	},
+	image: { srcAttributes: ["href", "xlink:href"] },
+	input: { srcAttributes: ["src"] },
+	link: {
+		srcAttributes: ["href"],
+		srcsetAttributes: ["imagesrcset"]
+	},
+	object: { srcAttributes: ["data"] },
+	source: {
+		srcAttributes: ["src"],
+		srcsetAttributes: ["srcset"]
+	},
+	track: { srcAttributes: ["src"] },
+	use: { srcAttributes: ["href", "xlink:href"] },
+	video: { srcAttributes: ["src", "poster"] },
+	meta: {
+		srcAttributes: ["content"],
+		filter({ attributes }) {
+			if (attributes.name && ALLOWED_META_NAME.includes(attributes.name.trim().toLowerCase())) return true;
+			if (attributes.property && ALLOWED_META_PROPERTY.includes(attributes.property.trim().toLowerCase())) return true;
+			return false;
+		}
+	}
+};
+/**
+* Given a HTML node, find all attributes that references an asset to be processed
+*/
+function getNodeAssetAttributes(node) {
+	const matched = DEFAULT_HTML_ASSET_SOURCES[node.nodeName];
+	if (!matched) return [];
+	const attributes = {};
+	for (const attr of node.attrs) attributes[getAttrKey(attr)] = attr.value;
+	if ("vite-ignore" in attributes) return [{
+		type: "remove",
+		key: "vite-ignore",
+		value: "",
+		attributes,
+		location: node.sourceCodeLocation.attrs["vite-ignore"]
+	}];
+	const actions = [];
+	function handleAttributeKey(key, type) {
+		const value = attributes[key];
+		if (!value) return;
+		if (matched.filter && !matched.filter({
+			key,
+			value,
+			attributes
+		})) return;
+		actions.push({
+			type,
+			key,
+			value,
+			attributes,
+			location: node.sourceCodeLocation.attrs[key]
+		});
+	}
+	matched.srcAttributes?.forEach((key) => handleAttributeKey(key, "src"));
+	matched.srcsetAttributes?.forEach((key) => handleAttributeKey(key, "srcset"));
+	return actions;
+}
+function getAttrKey(attr) {
+	return attr.prefix === void 0 ? attr.name : `${attr.prefix}:${attr.name}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/mrmime@2.0.1/node_modules/mrmime/index.mjs
+const mimes = {
+	"3g2": "video/3gpp2",
+	"3gp": "video/3gpp",
+	"3gpp": "video/3gpp",
+	"3mf": "model/3mf",
+	"aac": "audio/aac",
+	"ac": "application/pkix-attr-cert",
+	"adp": "audio/adpcm",
+	"adts": "audio/aac",
+	"ai": "application/postscript",
+	"aml": "application/automationml-aml+xml",
+	"amlx": "application/automationml-amlx+zip",
+	"amr": "audio/amr",
+	"apng": "image/apng",
+	"appcache": "text/cache-manifest",
+	"appinstaller": "application/appinstaller",
+	"appx": "application/appx",
+	"appxbundle": "application/appxbundle",
+	"asc": "application/pgp-keys",
+	"atom": "application/atom+xml",
+	"atomcat": "application/atomcat+xml",
+	"atomdeleted": "application/atomdeleted+xml",
+	"atomsvc": "application/atomsvc+xml",
+	"au": "audio/basic",
+	"avci": "image/avci",
+	"avcs": "image/avcs",
+	"avif": "image/avif",
+	"aw": "application/applixware",
+	"bdoc": "application/bdoc",
+	"bin": "application/octet-stream",
+	"bmp": "image/bmp",
+	"bpk": "application/octet-stream",
+	"btf": "image/prs.btif",
+	"btif": "image/prs.btif",
+	"buffer": "application/octet-stream",
+	"ccxml": "application/ccxml+xml",
+	"cdfx": "application/cdfx+xml",
+	"cdmia": "application/cdmi-capability",
+	"cdmic": "application/cdmi-container",
+	"cdmid": "application/cdmi-domain",
+	"cdmio": "application/cdmi-object",
+	"cdmiq": "application/cdmi-queue",
+	"cer": "application/pkix-cert",
+	"cgm": "image/cgm",
+	"cjs": "application/node",
+	"class": "application/java-vm",
+	"coffee": "text/coffeescript",
+	"conf": "text/plain",
+	"cpl": "application/cpl+xml",
+	"cpt": "application/mac-compactpro",
+	"crl": "application/pkix-crl",
+	"css": "text/css",
+	"csv": "text/csv",
+	"cu": "application/cu-seeme",
+	"cwl": "application/cwl",
+	"cww": "application/prs.cww",
+	"davmount": "application/davmount+xml",
+	"dbk": "application/docbook+xml",
+	"deb": "application/octet-stream",
+	"def": "text/plain",
+	"deploy": "application/octet-stream",
+	"dib": "image/bmp",
+	"disposition-notification": "message/disposition-notification",
+	"dist": "application/octet-stream",
+	"distz": "application/octet-stream",
+	"dll": "application/octet-stream",
+	"dmg": "application/octet-stream",
+	"dms": "application/octet-stream",
+	"doc": "application/msword",
+	"dot": "application/msword",
+	"dpx": "image/dpx",
+	"drle": "image/dicom-rle",
+	"dsc": "text/prs.lines.tag",
+	"dssc": "application/dssc+der",
+	"dtd": "application/xml-dtd",
+	"dump": "application/octet-stream",
+	"dwd": "application/atsc-dwd+xml",
+	"ear": "application/java-archive",
+	"ecma": "application/ecmascript",
+	"elc": "application/octet-stream",
+	"emf": "image/emf",
+	"eml": "message/rfc822",
+	"emma": "application/emma+xml",
+	"emotionml": "application/emotionml+xml",
+	"eps": "application/postscript",
+	"epub": "application/epub+zip",
+	"exe": "application/octet-stream",
+	"exi": "application/exi",
+	"exp": "application/express",
+	"exr": "image/aces",
+	"ez": "application/andrew-inset",
+	"fdf": "application/fdf",
+	"fdt": "application/fdt+xml",
+	"fits": "image/fits",
+	"g3": "image/g3fax",
+	"gbr": "application/rpki-ghostbusters",
+	"geojson": "application/geo+json",
+	"gif": "image/gif",
+	"glb": "model/gltf-binary",
+	"gltf": "model/gltf+json",
+	"gml": "application/gml+xml",
+	"gpx": "application/gpx+xml",
+	"gram": "application/srgs",
+	"grxml": "application/srgs+xml",
+	"gxf": "application/gxf",
+	"gz": "application/gzip",
+	"h261": "video/h261",
+	"h263": "video/h263",
+	"h264": "video/h264",
+	"heic": "image/heic",
+	"heics": "image/heic-sequence",
+	"heif": "image/heif",
+	"heifs": "image/heif-sequence",
+	"hej2": "image/hej2k",
+	"held": "application/atsc-held+xml",
+	"hjson": "application/hjson",
+	"hlp": "application/winhlp",
+	"hqx": "application/mac-binhex40",
+	"hsj2": "image/hsj2",
+	"htm": "text/html",
+	"html": "text/html",
+	"ics": "text/calendar",
+	"ief": "image/ief",
+	"ifb": "text/calendar",
+	"iges": "model/iges",
+	"igs": "model/iges",
+	"img": "application/octet-stream",
+	"in": "text/plain",
+	"ini": "text/plain",
+	"ink": "application/inkml+xml",
+	"inkml": "application/inkml+xml",
+	"ipfix": "application/ipfix",
+	"iso": "application/octet-stream",
+	"its": "application/its+xml",
+	"jade": "text/jade",
+	"jar": "application/java-archive",
+	"jhc": "image/jphc",
+	"jls": "image/jls",
+	"jp2": "image/jp2",
+	"jpe": "image/jpeg",
+	"jpeg": "image/jpeg",
+	"jpf": "image/jpx",
+	"jpg": "image/jpeg",
+	"jpg2": "image/jp2",
+	"jpgm": "image/jpm",
+	"jpgv": "video/jpeg",
+	"jph": "image/jph",
+	"jpm": "image/jpm",
+	"jpx": "image/jpx",
+	"js": "text/javascript",
+	"json": "application/json",
+	"json5": "application/json5",
+	"jsonld": "application/ld+json",
+	"jsonml": "application/jsonml+json",
+	"jsx": "text/jsx",
+	"jt": "model/jt",
+	"jxl": "image/jxl",
+	"jxr": "image/jxr",
+	"jxra": "image/jxra",
+	"jxrs": "image/jxrs",
+	"jxs": "image/jxs",
+	"jxsc": "image/jxsc",
+	"jxsi": "image/jxsi",
+	"jxss": "image/jxss",
+	"kar": "audio/midi",
+	"ktx": "image/ktx",
+	"ktx2": "image/ktx2",
+	"less": "text/less",
+	"lgr": "application/lgr+xml",
+	"list": "text/plain",
+	"litcoffee": "text/coffeescript",
+	"log": "text/plain",
+	"lostxml": "application/lost+xml",
+	"lrf": "application/octet-stream",
+	"m1v": "video/mpeg",
+	"m21": "application/mp21",
+	"m2a": "audio/mpeg",
+	"m2t": "video/mp2t",
+	"m2ts": "video/mp2t",
+	"m2v": "video/mpeg",
+	"m3a": "audio/mpeg",
+	"m4a": "audio/mp4",
+	"m4p": "application/mp4",
+	"m4s": "video/iso.segment",
+	"ma": "application/mathematica",
+	"mads": "application/mads+xml",
+	"maei": "application/mmt-aei+xml",
+	"man": "text/troff",
+	"manifest": "text/cache-manifest",
+	"map": "application/json",
+	"mar": "application/octet-stream",
+	"markdown": "text/markdown",
+	"mathml": "application/mathml+xml",
+	"mb": "application/mathematica",
+	"mbox": "application/mbox",
+	"md": "text/markdown",
+	"mdx": "text/mdx",
+	"me": "text/troff",
+	"mesh": "model/mesh",
+	"meta4": "application/metalink4+xml",
+	"metalink": "application/metalink+xml",
+	"mets": "application/mets+xml",
+	"mft": "application/rpki-manifest",
+	"mid": "audio/midi",
+	"midi": "audio/midi",
+	"mime": "message/rfc822",
+	"mj2": "video/mj2",
+	"mjp2": "video/mj2",
+	"mjs": "text/javascript",
+	"mml": "text/mathml",
+	"mods": "application/mods+xml",
+	"mov": "video/quicktime",
+	"mp2": "audio/mpeg",
+	"mp21": "application/mp21",
+	"mp2a": "audio/mpeg",
+	"mp3": "audio/mpeg",
+	"mp4": "video/mp4",
+	"mp4a": "audio/mp4",
+	"mp4s": "application/mp4",
+	"mp4v": "video/mp4",
+	"mpd": "application/dash+xml",
+	"mpe": "video/mpeg",
+	"mpeg": "video/mpeg",
+	"mpf": "application/media-policy-dataset+xml",
+	"mpg": "video/mpeg",
+	"mpg4": "video/mp4",
+	"mpga": "audio/mpeg",
+	"mpp": "application/dash-patch+xml",
+	"mrc": "application/marc",
+	"mrcx": "application/marcxml+xml",
+	"ms": "text/troff",
+	"mscml": "application/mediaservercontrol+xml",
+	"msh": "model/mesh",
+	"msi": "application/octet-stream",
+	"msix": "application/msix",
+	"msixbundle": "application/msixbundle",
+	"msm": "application/octet-stream",
+	"msp": "application/octet-stream",
+	"mtl": "model/mtl",
+	"mts": "video/mp2t",
+	"musd": "application/mmt-usd+xml",
+	"mxf": "application/mxf",
+	"mxmf": "audio/mobile-xmf",
+	"mxml": "application/xv+xml",
+	"n3": "text/n3",
+	"nb": "application/mathematica",
+	"nq": "application/n-quads",
+	"nt": "application/n-triples",
+	"obj": "model/obj",
+	"oda": "application/oda",
+	"oga": "audio/ogg",
+	"ogg": "audio/ogg",
+	"ogv": "video/ogg",
+	"ogx": "application/ogg",
+	"omdoc": "application/omdoc+xml",
+	"onepkg": "application/onenote",
+	"onetmp": "application/onenote",
+	"onetoc": "application/onenote",
+	"onetoc2": "application/onenote",
+	"opf": "application/oebps-package+xml",
+	"opus": "audio/ogg",
+	"otf": "font/otf",
+	"owl": "application/rdf+xml",
+	"oxps": "application/oxps",
+	"p10": "application/pkcs10",
+	"p7c": "application/pkcs7-mime",
+	"p7m": "application/pkcs7-mime",
+	"p7s": "application/pkcs7-signature",
+	"p8": "application/pkcs8",
+	"pdf": "application/pdf",
+	"pfr": "application/font-tdpfr",
+	"pgp": "application/pgp-encrypted",
+	"pkg": "application/octet-stream",
+	"pki": "application/pkixcmp",
+	"pkipath": "application/pkix-pkipath",
+	"pls": "application/pls+xml",
+	"png": "image/png",
+	"prc": "model/prc",
+	"prf": "application/pics-rules",
+	"provx": "application/provenance+xml",
+	"ps": "application/postscript",
+	"pskcxml": "application/pskc+xml",
+	"pti": "image/prs.pti",
+	"qt": "video/quicktime",
+	"raml": "application/raml+yaml",
+	"rapd": "application/route-apd+xml",
+	"rdf": "application/rdf+xml",
+	"relo": "application/p2p-overlay+xml",
+	"rif": "application/reginfo+xml",
+	"rl": "application/resource-lists+xml",
+	"rld": "application/resource-lists-diff+xml",
+	"rmi": "audio/midi",
+	"rnc": "application/relax-ng-compact-syntax",
+	"rng": "application/xml",
+	"roa": "application/rpki-roa",
+	"roff": "text/troff",
+	"rq": "application/sparql-query",
+	"rs": "application/rls-services+xml",
+	"rsat": "application/atsc-rsat+xml",
+	"rsd": "application/rsd+xml",
+	"rsheet": "application/urc-ressheet+xml",
+	"rss": "application/rss+xml",
+	"rtf": "text/rtf",
+	"rtx": "text/richtext",
+	"rusd": "application/route-usd+xml",
+	"s3m": "audio/s3m",
+	"sbml": "application/sbml+xml",
+	"scq": "application/scvp-cv-request",
+	"scs": "application/scvp-cv-response",
+	"sdp": "application/sdp",
+	"senmlx": "application/senml+xml",
+	"sensmlx": "application/sensml+xml",
+	"ser": "application/java-serialized-object",
+	"setpay": "application/set-payment-initiation",
+	"setreg": "application/set-registration-initiation",
+	"sgi": "image/sgi",
+	"sgm": "text/sgml",
+	"sgml": "text/sgml",
+	"shex": "text/shex",
+	"shf": "application/shf+xml",
+	"shtml": "text/html",
+	"sieve": "application/sieve",
+	"sig": "application/pgp-signature",
+	"sil": "audio/silk",
+	"silo": "model/mesh",
+	"siv": "application/sieve",
+	"slim": "text/slim",
+	"slm": "text/slim",
+	"sls": "application/route-s-tsid+xml",
+	"smi": "application/smil+xml",
+	"smil": "application/smil+xml",
+	"snd": "audio/basic",
+	"so": "application/octet-stream",
+	"spdx": "text/spdx",
+	"spp": "application/scvp-vp-response",
+	"spq": "application/scvp-vp-request",
+	"spx": "audio/ogg",
+	"sql": "application/sql",
+	"sru": "application/sru+xml",
+	"srx": "application/sparql-results+xml",
+	"ssdl": "application/ssdl+xml",
+	"ssml": "application/ssml+xml",
+	"stk": "application/hyperstudio",
+	"stl": "model/stl",
+	"stpx": "model/step+xml",
+	"stpxz": "model/step-xml+zip",
+	"stpz": "model/step+zip",
+	"styl": "text/stylus",
+	"stylus": "text/stylus",
+	"svg": "image/svg+xml",
+	"svgz": "image/svg+xml",
+	"swidtag": "application/swid+xml",
+	"t": "text/troff",
+	"t38": "image/t38",
+	"td": "application/urc-targetdesc+xml",
+	"tei": "application/tei+xml",
+	"teicorpus": "application/tei+xml",
+	"text": "text/plain",
+	"tfi": "application/thraud+xml",
+	"tfx": "image/tiff-fx",
+	"tif": "image/tiff",
+	"tiff": "image/tiff",
+	"toml": "application/toml",
+	"tr": "text/troff",
+	"trig": "application/trig",
+	"ts": "video/mp2t",
+	"tsd": "application/timestamped-data",
+	"tsv": "text/tab-separated-values",
+	"ttc": "font/collection",
+	"ttf": "font/ttf",
+	"ttl": "text/turtle",
+	"ttml": "application/ttml+xml",
+	"txt": "text/plain",
+	"u3d": "model/u3d",
+	"u8dsn": "message/global-delivery-status",
+	"u8hdr": "message/global-headers",
+	"u8mdn": "message/global-disposition-notification",
+	"u8msg": "message/global",
+	"ubj": "application/ubjson",
+	"uri": "text/uri-list",
+	"uris": "text/uri-list",
+	"urls": "text/uri-list",
+	"vcard": "text/vcard",
+	"vrml": "model/vrml",
+	"vtt": "text/vtt",
+	"vxml": "application/voicexml+xml",
+	"war": "application/java-archive",
+	"wasm": "application/wasm",
+	"wav": "audio/wav",
+	"weba": "audio/webm",
+	"webm": "video/webm",
+	"webmanifest": "application/manifest+json",
+	"webp": "image/webp",
+	"wgsl": "text/wgsl",
+	"wgt": "application/widget",
+	"wif": "application/watcherinfo+xml",
+	"wmf": "image/wmf",
+	"woff": "font/woff",
+	"woff2": "font/woff2",
+	"wrl": "model/vrml",
+	"wsdl": "application/wsdl+xml",
+	"wspolicy": "application/wspolicy+xml",
+	"x3d": "model/x3d+xml",
+	"x3db": "model/x3d+fastinfoset",
+	"x3dbz": "model/x3d+binary",
+	"x3dv": "model/x3d-vrml",
+	"x3dvz": "model/x3d+vrml",
+	"x3dz": "model/x3d+xml",
+	"xaml": "application/xaml+xml",
+	"xav": "application/xcap-att+xml",
+	"xca": "application/xcap-caps+xml",
+	"xcs": "application/calendar+xml",
+	"xdf": "application/xcap-diff+xml",
+	"xdssc": "application/dssc+xml",
+	"xel": "application/xcap-el+xml",
+	"xenc": "application/xenc+xml",
+	"xer": "application/patch-ops-error+xml",
+	"xfdf": "application/xfdf",
+	"xht": "application/xhtml+xml",
+	"xhtml": "application/xhtml+xml",
+	"xhvml": "application/xv+xml",
+	"xlf": "application/xliff+xml",
+	"xm": "audio/xm",
+	"xml": "text/xml",
+	"xns": "application/xcap-ns+xml",
+	"xop": "application/xop+xml",
+	"xpl": "application/xproc+xml",
+	"xsd": "application/xml",
+	"xsf": "application/prs.xsf+xml",
+	"xsl": "application/xml",
+	"xslt": "application/xml",
+	"xspf": "application/xspf+xml",
+	"xvm": "application/xv+xml",
+	"xvml": "application/xv+xml",
+	"yaml": "text/yaml",
+	"yang": "application/yang",
+	"yin": "application/yin+xml",
+	"yml": "text/yaml",
+	"zip": "application/zip"
+};
+function lookup(extn) {
+	let tmp = ("" + extn).trim().toLowerCase();
+	let idx = tmp.lastIndexOf(".");
+	return mimes[!~idx ? tmp : tmp.substring(++idx)];
+}
+//#endregion
+//#region src/node/plugins/asset.ts
+const assetUrlRE = /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g;
+const jsSourceMapRE = /\.[cm]?js\.map$/;
+const noInlineRE = /[?&]no-inline\b/;
+const inlineRE$3 = /[?&]inline\b/;
+const assetCache = /* @__PURE__ */ new WeakMap();
+/** a set of referenceId for entry CSS assets for each environment */
+const cssEntriesMap = /* @__PURE__ */ new WeakMap();
+function registerCustomMime() {
+	mimes.ico = "image/x-icon";
+	mimes.cur = "image/x-icon";
+	mimes.flac = "audio/flac";
+	mimes.eot = "application/vnd.ms-fontobject";
+}
+function renderAssetUrlInJS(pluginContext, chunk, opts, code) {
+	const { environment } = pluginContext;
+	const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(opts.format, environment.config.isWorker);
+	let match;
+	let s;
+	assetUrlRE.lastIndex = 0;
+	while (match = assetUrlRE.exec(code)) {
+		s ||= new MagicString(code);
+		const [full, referenceId, postfix = ""] = match;
+		const file = pluginContext.getFileName(referenceId);
+		chunk.viteMetadata.importedAssets.add(cleanUrl(file));
+		const replacement = toOutputFilePathInJS(environment, file + postfix, "asset", chunk.fileName, "js", toRelativeRuntime);
+		const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`;
+		s.update(match.index, match.index + full.length, replacementString);
+	}
+	const publicAssetUrlMap = publicAssetUrlCache.get(environment.getTopLevelConfig());
+	publicAssetUrlRE.lastIndex = 0;
+	while (match = publicAssetUrlRE.exec(code)) {
+		s ||= new MagicString(code);
+		const [full, hash] = match;
+		const replacement = toOutputFilePathInJS(environment, publicAssetUrlMap.get(hash).slice(1), "public", chunk.fileName, "js", toRelativeRuntime);
+		const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`;
+		s.update(match.index, match.index + full.length, replacementString);
+	}
+	return s;
+}
+/**
+* Also supports loading plain strings with import text from './foo.txt?raw'
+*/
+function assetPlugin(config) {
+	registerCustomMime();
+	return {
+		name: "vite:asset",
+		perEnvironmentStartEndDuringDev: true,
+		buildStart() {
+			assetCache.set(this.environment, /* @__PURE__ */ new Map());
+			cssEntriesMap.set(this.environment, /* @__PURE__ */ new Map());
+		},
+		resolveId: {
+			filter: { id: [
+				urlRE$1,
+				DEFAULT_ASSETS_RE,
+				...makeIdFiltersToMatchWithQuery(config.rawAssetsInclude).map((v) => typeof v === "string" ? picomatch.makeRe(v, { dot: true }) : v)
+			] },
+			handler(id) {
+				if (!config.assetsInclude(cleanUrl(id)) && !urlRE$1.test(id)) return;
+				if (checkPublicFile(id, config)) return id;
+			}
+		},
+		load: {
+			filter: { id: {
+				include: [
+					rawRE$1,
+					urlRE$1,
+					DEFAULT_ASSETS_RE,
+					...makeIdFiltersToMatchWithQuery(config.rawAssetsInclude)
+				],
+				exclude: /^\0/
+			} },
+			async handler(id) {
+				if (rawRE$1.test(id)) {
+					const file = checkPublicFile(id, config) || cleanUrl(id);
+					this.addWatchFile(file);
+					return {
+						code: `export default ${JSON.stringify(await fsp.readFile(file, "utf-8"))}`,
+						map: { mappings: "" },
+						moduleType: "js"
+					};
+				}
+				if (!urlRE$1.test(id) && !config.assetsInclude(cleanUrl(id))) return;
+				id = removeUrlQuery(id);
+				let url = await fileToUrl$1(this, id);
+				if (!url.startsWith("data:") && this.environment.mode === "dev") {
+					const mod = this.environment.moduleGraph.getModuleById(id);
+					if (mod && mod.lastHMRTimestamp > 0) url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
+				}
+				return {
+					code: `export default ${JSON.stringify(encodeURIPath(url))}`,
+					moduleSideEffects: config.command === "build" && this.getModuleInfo(id)?.isEntry ? "no-treeshake" : false,
+					meta: config.command === "build" ? { "vite:asset": true } : void 0,
+					moduleType: "js"
+				};
+			}
+		},
+		...config.command === "build" ? { renderChunk(code, chunk, opts) {
+			const s = renderAssetUrlInJS(this, chunk, opts, code);
+			if (s) return {
+				code: s.toString(),
+				map: this.environment.config.build.sourcemap ? s.generateMap({ hires: "boundary" }) : null
+			};
+			else return null;
+		} } : {},
+		generateBundle(_, bundle) {
+			let importedFiles;
+			for (const file in bundle) {
+				const chunk = bundle[file];
+				if (chunk.type === "chunk" && chunk.isEntry && chunk.moduleIds.length === 1 && config.assetsInclude(chunk.moduleIds[0]) && this.getModuleInfo(chunk.moduleIds[0])?.meta["vite:asset"]) {
+					if (!importedFiles) {
+						importedFiles = /* @__PURE__ */ new Set();
+						for (const file in bundle) {
+							const chunk = bundle[file];
+							if (chunk.type === "chunk") {
+								for (const importedFile of chunk.imports) importedFiles.add(importedFile);
+								for (const importedFile of chunk.dynamicImports) importedFiles.add(importedFile);
+							}
+						}
+					}
+					if (!importedFiles.has(file)) delete bundle[file];
+				}
+			}
+			if (config.command === "build" && !this.environment.config.build.emitAssets) {
+				for (const file in bundle) if (bundle[file].type === "asset" && !file.endsWith("ssr-manifest.json") && !jsSourceMapRE.test(file)) delete bundle[file];
+			}
+		},
+		watchChange(id) {
+			assetCache.get(this.environment)?.delete(normalizePath(id));
+		}
+	};
+}
+async function fileToUrl$1(pluginContext, id, asFileUrl = false) {
+	const { environment } = pluginContext;
+	if (!environment.config.isBundled) return fileToDevUrl(environment, id, asFileUrl);
+	else return fileToBuiltUrl(pluginContext, id);
+}
+async function fileToDevUrl(environment, id, asFileUrl = false) {
+	const config = environment.getTopLevelConfig();
+	const publicFile = checkPublicFile(id, config);
+	if (inlineRE$3.test(id)) {
+		const file = publicFile || cleanUrl(id);
+		return assetToDataURL(environment, file, await fsp.readFile(file));
+	}
+	const cleanedId = cleanUrl(id);
+	if (cleanedId.endsWith(".svg")) {
+		const file = publicFile || cleanedId;
+		const content = await fsp.readFile(file);
+		if (shouldInline(environment, file, id, content, void 0, void 0)) return assetToDataURL(environment, file, content);
+	}
+	if (asFileUrl) return pathToFileURL(cleanedId).href;
+	let rtn;
+	if (publicFile) rtn = id;
+	else if (id.startsWith(withTrailingSlash(config.root))) rtn = "/" + path.posix.relative(config.root, id);
+	else rtn = path.posix.join(FS_PREFIX, id);
+	return joinUrlSegments(joinUrlSegments(config.server.origin ?? "", config.decodedBase), removeLeadingSlash(rtn));
+}
+function getPublicAssetFilename(hash, config) {
+	return publicAssetUrlCache.get(config)?.get(hash);
+}
+const publicAssetUrlCache = /* @__PURE__ */ new WeakMap();
+const publicAssetUrlRE = /__VITE_PUBLIC_ASSET__([a-z\d]{8})__/g;
+function publicFileToBuiltUrl(url, config) {
+	if (config.command !== "build") return joinUrlSegments(config.decodedBase, url);
+	const hash = getHash(url);
+	let cache = publicAssetUrlCache.get(config);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		publicAssetUrlCache.set(config, cache);
+	}
+	if (!cache.get(hash)) cache.set(hash, url);
+	return `__VITE_PUBLIC_ASSET__${hash}__`;
+}
+const GIT_LFS_PREFIX = Buffer$1.from("version https://git-lfs.github.com");
+function isGitLfsPlaceholder(content) {
+	if (content.length < GIT_LFS_PREFIX.length) return false;
+	return GIT_LFS_PREFIX.compare(content, 0, GIT_LFS_PREFIX.length) === 0;
+}
+/**
+* Register an asset to be emitted as part of the bundle (if necessary)
+* and returns the resolved public URL
+*/
+async function fileToBuiltUrl(pluginContext, id, skipPublicCheck = false, forceInline) {
+	const environment = pluginContext.environment;
+	const topLevelConfig = environment.getTopLevelConfig();
+	if (!skipPublicCheck) {
+		const publicFile = checkPublicFile(id, topLevelConfig);
+		if (publicFile) if (inlineRE$3.test(id)) id = publicFile;
+		else return publicFileToBuiltUrl(id, topLevelConfig);
+	}
+	const cache = assetCache.get(environment);
+	const cached = cache.get(id);
+	if (cached) return cached;
+	let { file, postfix } = splitFileAndPostfix(id);
+	const content = await fsp.readFile(file);
+	let url;
+	if (shouldInline(environment, file, id, content, pluginContext, forceInline)) url = assetToDataURL(environment, file, content);
+	else {
+		const originalFileName = normalizePath(path.relative(environment.config.root, file));
+		const referenceId = pluginContext.emitFile({
+			type: "asset",
+			name: path.basename(file),
+			originalFileName,
+			source: content
+		});
+		if (environment.config.command === "build" && noInlineRE.test(postfix)) postfix = postfix.replace(noInlineRE, "").replace(/^&/, "?");
+		if (environment.config.command === "serve" && environment.config.isBundled) url = toOutputFilePathInJSForBundledDev(environment, pluginContext.getFileName(referenceId));
+		else url = `__VITE_ASSET__${referenceId}__${postfix ? `$_${postfix}__` : ``}`;
+	}
+	cache.set(id, url);
+	return url;
+}
+function toOutputFilePathInJSForBundledDev(environment, filename) {
+	const outputUrl = toOutputFilePathInJS(environment, filename, "asset", "assets/dummy.js", "js", () => {
+		throw new Error("unreachable");
+	});
+	if (typeof outputUrl === "object") throw new Error("unreachable");
+	return outputUrl;
+}
+async function urlToBuiltUrl(pluginContext, url, importer, forceInline) {
+	const topLevelConfig = pluginContext.environment.getTopLevelConfig();
+	if (checkPublicFile(url, topLevelConfig)) return publicFileToBuiltUrl(url, topLevelConfig);
+	return fileToBuiltUrl(pluginContext, normalizePath(url[0] === "/" ? path.join(topLevelConfig.root, url) : path.join(path.dirname(importer), url)), true, forceInline);
+}
+function shouldInline(environment, file, id, content, buildPluginContext, forceInline) {
+	if (noInlineRE.test(id)) return false;
+	if (inlineRE$3.test(id)) return true;
+	if (buildPluginContext) {
+		if (environment.config.build.lib) return true;
+		if (buildPluginContext.getModuleInfo(id)?.isEntry) return false;
+	}
+	if (forceInline !== void 0) return forceInline;
+	if (file.endsWith(".html")) return false;
+	if (file.endsWith(".svg") && id.includes("#")) return false;
+	let limit;
+	const { assetsInlineLimit } = environment.config.build;
+	if (typeof assetsInlineLimit === "function") {
+		const userShouldInline = assetsInlineLimit(file, content);
+		if (userShouldInline != null) return userShouldInline;
+		limit = DEFAULT_ASSETS_INLINE_LIMIT;
+	} else limit = Number(assetsInlineLimit);
+	return content.length < limit && !isGitLfsPlaceholder(content);
+}
+function assetToDataURL(environment, file, content) {
+	if (environment.config.build.lib && isGitLfsPlaceholder(content)) environment.logger.warn(import_picocolors.default.yellow(`Inlined file ${file} was not downloaded via Git LFS`));
+	if (file.endsWith(".svg")) return svgToDataURL(content);
+	else return `data:${lookup(file) ?? "application/octet-stream"};base64,${content.toString("base64")}`;
+}
+const nestedQuotesRE = /"[^"']*'[^"]*"|'[^'"]*"[^']*'/;
+function svgToDataURL(content) {
+	const stringContent = content.toString();
+	if (stringContent.includes("<text") || stringContent.includes("<foreignObject") || nestedQuotesRE.test(stringContent)) return `data:image/svg+xml;base64,${content.toString("base64")}`;
+	else return "data:image/svg+xml," + stringContent.trim().replaceAll(/>\s+</g, "><").replaceAll("\"", "'").replaceAll("%", "%25").replaceAll("#", "%23").replaceAll("<", "%3c").replaceAll(">", "%3e").replaceAll(/\s+/g, "%20");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lilconfig@3.1.3/node_modules/lilconfig/src/index.js
+var require_src$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$2 = __require("path");
+	const fs$2 = __require("fs");
+	const os$1 = __require("os");
+	const url = __require("url");
+	const fsReadFileAsync = fs$2.promises.readFile;
+	/** @type {(name: string, sync: boolean) => string[]} */
+	function getDefaultSearchPlaces(name, sync) {
+		return [
+			"package.json",
+			`.${name}rc.json`,
+			`.${name}rc.js`,
+			`.${name}rc.cjs`,
+			...sync ? [] : [`.${name}rc.mjs`],
+			`.config/${name}rc`,
+			`.config/${name}rc.json`,
+			`.config/${name}rc.js`,
+			`.config/${name}rc.cjs`,
+			...sync ? [] : [`.config/${name}rc.mjs`],
+			`${name}.config.js`,
+			`${name}.config.cjs`,
+			...sync ? [] : [`${name}.config.mjs`]
+		];
+	}
+	/**
+	* @type {(p: string) => string}
+	*
+	* see #17
+	* On *nix, if cwd is not under homedir,
+	* the last path will be '', ('/build' -> '')
+	* but it should be '/' actually.
+	* And on Windows, this will never happen. ('C:\build' -> 'C:')
+	*/
+	function parentDir(p) {
+		return path$2.dirname(p) || path$2.sep;
+	}
+	/** @type {import('./index').LoaderSync} */
+	const jsonLoader = (_, content) => JSON.parse(content);
+	const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+	/** @type {import('./index').LoadersSync} */
+	const defaultLoadersSync = Object.freeze({
+		".js": requireFunc,
+		".json": requireFunc,
+		".cjs": requireFunc,
+		noExt: jsonLoader
+	});
+	module.exports.defaultLoadersSync = defaultLoadersSync;
+	/** @type {import('./index').Loader} */
+	const dynamicImport = async (id) => {
+		try {
+			return (await import(
+				/* webpackIgnore: true */
+				url.pathToFileURL(id).href
+)).default;
+		} catch (e) {
+			try {
+				return requireFunc(id);
+			} catch (requireE) {
+				if (requireE.code === "ERR_REQUIRE_ESM" || requireE instanceof SyntaxError && requireE.toString().includes("Cannot use import statement outside a module")) throw e;
+				throw requireE;
+			}
+		}
+	};
+	/** @type {import('./index').Loaders} */
+	const defaultLoaders = Object.freeze({
+		".js": dynamicImport,
+		".mjs": dynamicImport,
+		".cjs": dynamicImport,
+		".json": jsonLoader,
+		noExt: jsonLoader
+	});
+	module.exports.defaultLoaders = defaultLoaders;
+	/**
+	* @param {string} name
+	* @param {import('./index').Options | import('./index').OptionsSync} options
+	* @param {boolean} sync
+	* @returns {Required<import('./index').Options | import('./index').OptionsSync>}
+	*/
+	function getOptions(name, options, sync) {
+		/** @type {Required<import('./index').Options>} */
+		const conf = {
+			stopDir: os$1.homedir(),
+			searchPlaces: getDefaultSearchPlaces(name, sync),
+			ignoreEmptySearchPlaces: true,
+			cache: true,
+			transform: (x) => x,
+			packageProp: [name],
+			...options,
+			loaders: {
+				...sync ? defaultLoadersSync : defaultLoaders,
+				...options.loaders
+			}
+		};
+		conf.searchPlaces.forEach((place) => {
+			const key = path$2.extname(place) || "noExt";
+			const loader = conf.loaders[key];
+			if (!loader) throw new Error(`Missing loader for extension "${place}"`);
+			if (typeof loader !== "function") throw new Error(`Loader for extension "${place}" is not a function: Received ${typeof loader}.`);
+		});
+		return conf;
+	}
+	/** @type {(props: string | string[], obj: Record<string, any>) => unknown} */
+	function getPackageProp(props, obj) {
+		if (typeof props === "string" && props in obj) return obj[props];
+		return (Array.isArray(props) ? props : props.split(".")).reduce((acc, prop) => acc === void 0 ? acc : acc[prop], obj) || null;
+	}
+	/** @param {string} filepath */
+	function validateFilePath(filepath) {
+		if (!filepath) throw new Error("load must pass a non-empty string");
+	}
+	/** @type {(loader: import('./index').Loader, ext: string) => void} */
+	function validateLoader(loader, ext) {
+		if (!loader) throw new Error(`No loader specified for extension "${ext}"`);
+		if (typeof loader !== "function") throw new Error("loader is not a function");
+	}
+	/** @type {(enableCache: boolean) => <T>(c: Map<string, T>, filepath: string, res: T) => T} */
+	const makeEmplace = (enableCache) => (c, filepath, res) => {
+		if (enableCache) c.set(filepath, res);
+		return res;
+	};
+	/** @type {import('./index').lilconfig} */
+	module.exports.lilconfig = function lilconfig(name, options) {
+		const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache } = getOptions(name, options ?? {}, false);
+		const searchCache = /* @__PURE__ */ new Map();
+		const loadCache = /* @__PURE__ */ new Map();
+		const emplace = makeEmplace(cache);
+		return {
+			async search(searchFrom = process.cwd()) {
+				/** @type {import('./index').LilconfigResult} */
+				const result = {
+					config: null,
+					filepath: ""
+				};
+				/** @type {Set<string>} */
+				const visited = /* @__PURE__ */ new Set();
+				let dir = searchFrom;
+				dirLoop: while (true) {
+					if (cache) {
+						const r = searchCache.get(dir);
+						if (r !== void 0) {
+							for (const p of visited) searchCache.set(p, r);
+							return r;
+						}
+						visited.add(dir);
+					}
+					for (const searchPlace of searchPlaces) {
+						const filepath = path$2.join(dir, searchPlace);
+						try {
+							await fs$2.promises.access(filepath);
+						} catch {
+							continue;
+						}
+						const content = String(await fsReadFileAsync(filepath));
+						const loaderKey = path$2.extname(searchPlace) || "noExt";
+						const loader = loaders[loaderKey];
+						if (searchPlace === "package.json") {
+							const maybeConfig = getPackageProp(packageProp, await loader(filepath, content));
+							if (maybeConfig != null) {
+								result.config = maybeConfig;
+								result.filepath = filepath;
+								break dirLoop;
+							}
+							continue;
+						}
+						const isEmpty = content.trim() === "";
+						if (isEmpty && ignoreEmptySearchPlaces) continue;
+						if (isEmpty) {
+							result.isEmpty = true;
+							result.config = void 0;
+						} else {
+							validateLoader(loader, loaderKey);
+							result.config = await loader(filepath, content);
+						}
+						result.filepath = filepath;
+						break dirLoop;
+					}
+					if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+					dir = parentDir(dir);
+				}
+				const transformed = result.filepath === "" && result.config === null ? transform(null) : transform(result);
+				if (cache) for (const p of visited) searchCache.set(p, transformed);
+				return transformed;
+			},
+			async load(filepath) {
+				validateFilePath(filepath);
+				const absPath = path$2.resolve(process.cwd(), filepath);
+				if (cache && loadCache.has(absPath)) return loadCache.get(absPath);
+				const { base, ext } = path$2.parse(absPath);
+				const loaderKey = ext || "noExt";
+				const loader = loaders[loaderKey];
+				validateLoader(loader, loaderKey);
+				const content = String(await fsReadFileAsync(absPath));
+				if (base === "package.json") return emplace(loadCache, absPath, transform({
+					config: getPackageProp(packageProp, await loader(absPath, content)),
+					filepath: absPath
+				}));
+				/** @type {import('./index').LilconfigResult} */
+				const result = {
+					config: null,
+					filepath: absPath
+				};
+				const isEmpty = content.trim() === "";
+				if (isEmpty && ignoreEmptySearchPlaces) return emplace(loadCache, absPath, transform({
+					config: void 0,
+					filepath: absPath,
+					isEmpty: true
+				}));
+				result.config = isEmpty ? void 0 : await loader(absPath, content);
+				return emplace(loadCache, absPath, transform(isEmpty ? {
+					...result,
+					isEmpty,
+					config: void 0
+				} : result));
+			},
+			clearLoadCache() {
+				if (cache) loadCache.clear();
+			},
+			clearSearchCache() {
+				if (cache) searchCache.clear();
+			},
+			clearCaches() {
+				if (cache) {
+					loadCache.clear();
+					searchCache.clear();
+				}
+			}
+		};
+	};
+	/** @type {import('./index').lilconfigSync} */
+	module.exports.lilconfigSync = function lilconfigSync(name, options) {
+		const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache } = getOptions(name, options ?? {}, true);
+		const searchCache = /* @__PURE__ */ new Map();
+		const loadCache = /* @__PURE__ */ new Map();
+		const emplace = makeEmplace(cache);
+		return {
+			search(searchFrom = process.cwd()) {
+				/** @type {import('./index').LilconfigResult} */
+				const result = {
+					config: null,
+					filepath: ""
+				};
+				/** @type {Set<string>} */
+				const visited = /* @__PURE__ */ new Set();
+				let dir = searchFrom;
+				dirLoop: while (true) {
+					if (cache) {
+						const r = searchCache.get(dir);
+						if (r !== void 0) {
+							for (const p of visited) searchCache.set(p, r);
+							return r;
+						}
+						visited.add(dir);
+					}
+					for (const searchPlace of searchPlaces) {
+						const filepath = path$2.join(dir, searchPlace);
+						try {
+							fs$2.accessSync(filepath);
+						} catch {
+							continue;
+						}
+						const loaderKey = path$2.extname(searchPlace) || "noExt";
+						const loader = loaders[loaderKey];
+						const content = String(fs$2.readFileSync(filepath));
+						if (searchPlace === "package.json") {
+							const maybeConfig = getPackageProp(packageProp, loader(filepath, content));
+							if (maybeConfig != null) {
+								result.config = maybeConfig;
+								result.filepath = filepath;
+								break dirLoop;
+							}
+							continue;
+						}
+						const isEmpty = content.trim() === "";
+						if (isEmpty && ignoreEmptySearchPlaces) continue;
+						if (isEmpty) {
+							result.isEmpty = true;
+							result.config = void 0;
+						} else {
+							validateLoader(loader, loaderKey);
+							result.config = loader(filepath, content);
+						}
+						result.filepath = filepath;
+						break dirLoop;
+					}
+					if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+					dir = parentDir(dir);
+				}
+				const transformed = result.filepath === "" && result.config === null ? transform(null) : transform(result);
+				if (cache) for (const p of visited) searchCache.set(p, transformed);
+				return transformed;
+			},
+			load(filepath) {
+				validateFilePath(filepath);
+				const absPath = path$2.resolve(process.cwd(), filepath);
+				if (cache && loadCache.has(absPath)) return loadCache.get(absPath);
+				const { base, ext } = path$2.parse(absPath);
+				const loaderKey = ext || "noExt";
+				const loader = loaders[loaderKey];
+				validateLoader(loader, loaderKey);
+				const content = String(fs$2.readFileSync(absPath));
+				if (base === "package.json") return transform({
+					config: getPackageProp(packageProp, loader(absPath, content)),
+					filepath: absPath
+				});
+				const result = {
+					config: null,
+					filepath: absPath
+				};
+				const isEmpty = content.trim() === "";
+				if (isEmpty && ignoreEmptySearchPlaces) return emplace(loadCache, absPath, transform({
+					filepath: absPath,
+					config: void 0,
+					isEmpty: true
+				}));
+				result.config = isEmpty ? void 0 : loader(absPath, content);
+				return emplace(loadCache, absPath, transform(isEmpty ? {
+					...result,
+					isEmpty,
+					config: void 0
+				} : result));
+			},
+			clearLoadCache() {
+				if (cache) loadCache.clear();
+			},
+			clearSearchCache() {
+				if (cache) searchCache.clear();
+			},
+			clearCaches() {
+				if (cache) {
+					loadCache.clear();
+					searchCache.clear();
+				}
+			}
+		};
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.6.1_postcss@8.5.14_tsx@4.21.0_yaml@2.8.2/node_modules/postcss-load-config/src/req.js
+var require_req = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { createRequire: createRequire$1 } = __require("node:module");
+	const { fileURLToPath: fileURLToPath$1, pathToFileURL: pathToFileURL$1 } = __require("node:url");
+	const TS_EXT_RE = /\.[mc]?ts$/;
+	let tsx;
+	let jiti;
+	let importError = [];
+	/**
+	* @param {string} name
+	* @param {string} rootFile
+	* @returns {Promise<any>}
+	*/
+	async function req(name, rootFile = fileURLToPath$1(import.meta.url)) {
+		let url = createRequire$1(rootFile).resolve(name);
+		try {
+			return (await import(`${pathToFileURL$1(url)}?t=${Date.now()}`)).default;
+		} catch (err) {
+			if (!TS_EXT_RE.test(url))
+ /* c8 ignore start */
+			throw err;
+		}
+		if (tsx === void 0) try {
+			tsx = await import("tsx/cjs/api");
+		} catch (error) {
+			importError.push(error);
+		}
+		if (tsx) {
+			let loaded = tsx.require(name, rootFile);
+			return loaded && "__esModule" in loaded ? loaded.default : loaded;
+		}
+		if (jiti === void 0) try {
+			jiti = (await import("jiti")).default;
+		} catch (error) {
+			importError.push(error);
+		}
+		if (jiti) return jiti(rootFile, { interopDefault: true })(name);
+		throw new Error(`'tsx' or 'jiti' is required for the TypeScript configuration files. Make sure it is installed\nError: ${importError.map((error) => error.message).join("\n")}`);
+	}
+	module.exports = req;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.6.1_postcss@8.5.14_tsx@4.21.0_yaml@2.8.2/node_modules/postcss-load-config/src/options.js
+var require_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const req = require_req();
+	/**
+	* Load Options
+	*
+	* @private
+	* @method options
+	*
+	* @param  {Object} config  PostCSS Config
+	*
+	* @return {Promise<Object>} options PostCSS Options
+	*/
+	async function options(config, file) {
+		if (config.parser && typeof config.parser === "string") try {
+			config.parser = await req(config.parser, file);
+		} catch (err) {
+			throw new Error(`Loading PostCSS Parser failed: ${err.message}\n\n(@${file})`);
+		}
+		if (config.syntax && typeof config.syntax === "string") try {
+			config.syntax = await req(config.syntax, file);
+		} catch (err) {
+			throw new Error(`Loading PostCSS Syntax failed: ${err.message}\n\n(@${file})`);
+		}
+		if (config.stringifier && typeof config.stringifier === "string") try {
+			config.stringifier = await req(config.stringifier, file);
+		} catch (err) {
+			throw new Error(`Loading PostCSS Stringifier failed: ${err.message}\n\n(@${file})`);
+		}
+		return config;
+	}
+	module.exports = options;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.6.1_postcss@8.5.14_tsx@4.21.0_yaml@2.8.2/node_modules/postcss-load-config/src/plugins.js
+var require_plugins = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const req = require_req();
+	/**
+	* Plugin Loader
+	*
+	* @private
+	* @method load
+	*
+	* @param  {String} plugin PostCSS Plugin Name
+	* @param  {Object} options PostCSS Plugin Options
+	*
+	* @return {Promise<Function>} PostCSS Plugin
+	*/
+	async function load(plugin, options, file) {
+		try {
+			if (options === null || options === void 0 || Object.keys(options).length === 0) return await req(plugin, file);
+			else return (await req(plugin, file))(options);
+		} catch (err) {
+			throw new Error(`Loading PostCSS Plugin failed: ${err.message}\n\n(@${file})`);
+		}
+	}
+	/**
+	* Load Plugins
+	*
+	* @private
+	* @method plugins
+	*
+	* @param {Object} config PostCSS Config Plugins
+	*
+	* @return {Promise<Array>} plugins PostCSS Plugins
+	*/
+	async function plugins(config, file) {
+		let list = [];
+		if (Array.isArray(config.plugins)) list = config.plugins.filter(Boolean);
+		else {
+			list = Object.entries(config.plugins).filter(([, options]) => {
+				return options !== false;
+			}).map(([plugin, options]) => {
+				return load(plugin, options, file);
+			});
+			list = await Promise.all(list);
+		}
+		if (list.length && list.length > 0) list.forEach((plugin, i) => {
+			if (plugin.default) plugin = plugin.default;
+			if (plugin.postcss === true) plugin = plugin();
+			else if (plugin.postcss) plugin = plugin.postcss;
+			if (!(typeof plugin === "object" && Array.isArray(plugin.plugins) || typeof plugin === "object" && plugin.postcssPlugin || typeof plugin === "function")) throw new TypeError(`Invalid PostCSS Plugin found at: plugins[${i}]\n\n(@${file})`);
+		});
+		return list;
+	}
+	module.exports = plugins;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.6.1_postcss@8.5.14_tsx@4.21.0_yaml@2.8.2/node_modules/postcss-load-config/src/index.js
+var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { resolve: resolve$3 } = __require("node:path");
+	const config = require_src$1();
+	const loadOptions = require_options();
+	const loadPlugins = require_plugins();
+	const req = require_req();
+	const interopRequireDefault = (obj) => obj && obj.__esModule ? obj : { default: obj };
+	/**
+	* Process the result from cosmiconfig
+	*
+	* @param  {Object} ctx Config Context
+	* @param  {Object} result Cosmiconfig result
+	*
+	* @return {Promise<Object>} PostCSS Config
+	*/
+	async function processResult(ctx, result) {
+		let file = result.filepath || "";
+		let projectConfig = interopRequireDefault(result.config).default || {};
+		if (typeof projectConfig === "function") projectConfig = projectConfig(ctx);
+		else projectConfig = Object.assign({}, projectConfig, ctx);
+		if (!projectConfig.plugins) projectConfig.plugins = [];
+		let res = {
+			file,
+			options: await loadOptions(projectConfig, file),
+			plugins: await loadPlugins(projectConfig, file)
+		};
+		delete projectConfig.plugins;
+		return res;
+	}
+	/**
+	* Builds the Config Context
+	*
+	* @param  {Object} ctx Config Context
+	*
+	* @return {Object} Config Context
+	*/
+	function createContext(ctx) {
+		/**
+		* @type {Object}
+		*
+		* @prop {String} cwd=process.cwd() Config search start location
+		* @prop {String} env=process.env.NODE_ENV Config Enviroment, will be set to `development` by `postcss-load-config` if `process.env.NODE_ENV` is `undefined`
+		*/
+		ctx = Object.assign({
+			cwd: process.cwd(),
+			env: process.env.NODE_ENV
+		}, ctx);
+		if (!ctx.env) process.env.NODE_ENV = "development";
+		return ctx;
+	}
+	async function loader(filepath) {
+		return req(filepath);
+	}
+	let yaml;
+	async function yamlLoader(_, content) {
+		if (!yaml) try {
+			yaml = await import("yaml");
+		} catch (e) {
+			/* c8 ignore start */
+			throw new Error(`'yaml' is required for the YAML configuration files. Make sure it is installed\nError: ${e.message}`);
+		}
+		return yaml.parse(content);
+	}
+	/** @return {import('lilconfig').Options} */
+	const withLoaders = (options = {}) => {
+		let moduleName = "postcss";
+		return {
+			...options,
+			loaders: {
+				...options.loaders,
+				".cjs": loader,
+				".cts": loader,
+				".js": loader,
+				".mjs": loader,
+				".mts": loader,
+				".ts": loader,
+				".yaml": yamlLoader,
+				".yml": yamlLoader
+			},
+			searchPlaces: [
+				...options.searchPlaces || [],
+				"package.json",
+				`.${moduleName}rc`,
+				`.${moduleName}rc.json`,
+				`.${moduleName}rc.yaml`,
+				`.${moduleName}rc.yml`,
+				`.${moduleName}rc.ts`,
+				`.${moduleName}rc.cts`,
+				`.${moduleName}rc.mts`,
+				`.${moduleName}rc.js`,
+				`.${moduleName}rc.cjs`,
+				`.${moduleName}rc.mjs`,
+				`${moduleName}.config.ts`,
+				`${moduleName}.config.cts`,
+				`${moduleName}.config.mts`,
+				`${moduleName}.config.js`,
+				`${moduleName}.config.cjs`,
+				`${moduleName}.config.mjs`
+			]
+		};
+	};
+	/**
+	* Load Config
+	*
+	* @method rc
+	*
+	* @param  {Object} ctx Config Context
+	* @param  {String} path Config Path
+	* @param  {Object} options Config Options
+	*
+	* @return {Promise} config PostCSS Config
+	*/
+	function rc(ctx, path, options) {
+		/**
+		* @type {Object} The full Config Context
+		*/
+		ctx = createContext(ctx);
+		/**
+		* @type {String} `process.cwd()`
+		*/
+		path = path ? resolve$3(path) : process.cwd();
+		return config.lilconfig("postcss", withLoaders(options)).search(path).then((result) => {
+			if (!result) throw new Error(`No PostCSS Config found in: ${path}`);
+			return processResult(ctx, result);
+		});
+	}
+	/**
+	* Autoload Config for PostCSS
+	*
+	* @author Michael Ciniawsky @michael-ciniawsky <michael.ciniawsky@gmail.com>
+	* @license MIT
+	*
+	* @module postcss-load-config
+	* @version 2.1.0
+	*
+	* @requires comsiconfig
+	* @requires ./options
+	* @requires ./plugins
+	*/
+	module.exports = rc;
+}));
+//#endregion
+//#region src/node/server/sourcemap.ts
+var import_convert_source_map = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "commentRegex", { get: function getCommentRegex() {
+		return /^\s*?\/[\/\*][@#]\s+?sourceMappingURL=data:(((?:application|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(base64))?,(.*?)$/gm;
+	} });
+	Object.defineProperty(exports, "mapFileCommentRegex", { get: function getMapFileCommentRegex() {
+		return /(?:\/\/[@#][ \t]+?sourceMappingURL=([^\s'"`]+?)[ \t]*?$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*?(?:\*\/){1}[ \t]*?$)/gm;
+	} });
+	var decodeBase64;
+	if (typeof Buffer !== "undefined") if (typeof Buffer.from === "function") decodeBase64 = decodeBase64WithBufferFrom;
+	else decodeBase64 = decodeBase64WithNewBuffer;
+	else decodeBase64 = decodeBase64WithAtob;
+	function decodeBase64WithBufferFrom(base64) {
+		return Buffer.from(base64, "base64").toString();
+	}
+	function decodeBase64WithNewBuffer(base64) {
+		if (typeof value === "number") throw new TypeError("The value to decode must not be of type number.");
+		return new Buffer(base64, "base64").toString();
+	}
+	function decodeBase64WithAtob(base64) {
+		return decodeURIComponent(escape(atob(base64)));
+	}
+	function stripComment(sm) {
+		return sm.split(",").pop();
+	}
+	function readFromFileMap(sm, read) {
+		var r = exports.mapFileCommentRegex.exec(sm);
+		var filename = r[1] || r[2];
+		try {
+			var sm = read(filename);
+			if (sm != null && typeof sm.catch === "function") return sm.catch(throwError);
+			else return sm;
+		} catch (e) {
+			throwError(e);
+		}
+		function throwError(e) {
+			throw new Error("An error occurred while trying to read the map file at " + filename + "\n" + e.stack);
+		}
+	}
+	function Converter(sm, opts) {
+		opts = opts || {};
+		if (opts.hasComment) sm = stripComment(sm);
+		if (opts.encoding === "base64") sm = decodeBase64(sm);
+		else if (opts.encoding === "uri") sm = decodeURIComponent(sm);
+		if (opts.isJSON || opts.encoding) sm = JSON.parse(sm);
+		this.sourcemap = sm;
+	}
+	Converter.prototype.toJSON = function(space) {
+		return JSON.stringify(this.sourcemap, null, space);
+	};
+	if (typeof Buffer !== "undefined") if (typeof Buffer.from === "function") Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
+	else Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
+	else Converter.prototype.toBase64 = encodeBase64WithBtoa;
+	function encodeBase64WithBufferFrom() {
+		var json = this.toJSON();
+		return Buffer.from(json, "utf8").toString("base64");
+	}
+	function encodeBase64WithNewBuffer() {
+		var json = this.toJSON();
+		if (typeof json === "number") throw new TypeError("The json to encode must not be of type number.");
+		return new Buffer(json, "utf8").toString("base64");
+	}
+	function encodeBase64WithBtoa() {
+		var json = this.toJSON();
+		return btoa(unescape(encodeURIComponent(json)));
+	}
+	Converter.prototype.toURI = function() {
+		var json = this.toJSON();
+		return encodeURIComponent(json);
+	};
+	Converter.prototype.toComment = function(options) {
+		var encoding, content, data;
+		if (options != null && options.encoding === "uri") {
+			encoding = "";
+			content = this.toURI();
+		} else {
+			encoding = ";base64";
+			content = this.toBase64();
+		}
+		data = "sourceMappingURL=data:application/json;charset=utf-8" + encoding + "," + content;
+		return options != null && options.multiline ? "/*# " + data + " */" : "//# " + data;
+	};
+	Converter.prototype.toObject = function() {
+		return JSON.parse(this.toJSON());
+	};
+	Converter.prototype.addProperty = function(key, value) {
+		if (this.sourcemap.hasOwnProperty(key)) throw new Error("property \"" + key + "\" already exists on the sourcemap, use set property instead");
+		return this.setProperty(key, value);
+	};
+	Converter.prototype.setProperty = function(key, value) {
+		this.sourcemap[key] = value;
+		return this;
+	};
+	Converter.prototype.getProperty = function(key) {
+		return this.sourcemap[key];
+	};
+	exports.fromObject = function(obj) {
+		return new Converter(obj);
+	};
+	exports.fromJSON = function(json) {
+		return new Converter(json, { isJSON: true });
+	};
+	exports.fromURI = function(uri) {
+		return new Converter(uri, { encoding: "uri" });
+	};
+	exports.fromBase64 = function(base64) {
+		return new Converter(base64, { encoding: "base64" });
+	};
+	exports.fromComment = function(comment) {
+		var m, encoding;
+		comment = comment.replace(/^\/\*/g, "//").replace(/\*\/$/g, "");
+		m = exports.commentRegex.exec(comment);
+		encoding = m && m[4] || "uri";
+		return new Converter(comment, {
+			encoding,
+			hasComment: true
+		});
+	};
+	function makeConverter(sm) {
+		return new Converter(sm, { isJSON: true });
+	}
+	exports.fromMapFileComment = function(comment, read) {
+		if (typeof read === "string") throw new Error("String directory paths are no longer supported with `fromMapFileComment`\nPlease review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading");
+		var sm = readFromFileMap(comment, read);
+		if (sm != null && typeof sm.then === "function") return sm.then(makeConverter);
+		else return makeConverter(sm);
+	};
+	exports.fromSource = function(content) {
+		var m = content.match(exports.commentRegex);
+		return m ? exports.fromComment(m.pop()) : null;
+	};
+	exports.fromMapFileSource = function(content, read) {
+		if (typeof read === "string") throw new Error("String directory paths are no longer supported with `fromMapFileSource`\nPlease review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading");
+		var m = content.match(exports.mapFileCommentRegex);
+		return m ? exports.fromMapFileComment(m.pop(), read) : null;
+	};
+	exports.removeComments = function(src) {
+		return src.replace(exports.commentRegex, "");
+	};
+	exports.removeMapFileComments = function(src) {
+		return src.replace(exports.mapFileCommentRegex, "");
+	};
+	exports.generateMapFileComment = function(file, options) {
+		var data = "sourceMappingURL=" + file;
+		return options && options.multiline ? "/*# " + data + " */" : "//# " + data;
+	};
+})))(), 1);
+const debug$10 = createDebugger("vite:sourcemap", { onlyWhenFocused: true });
+/**
+* Given a file path inside node_modules, returns the package root directory.
+* For scoped packages like `node_modules/@scope/pkg/dist/foo.js`, returns `node_modules/@scope/pkg`.
+* Returns `undefined` if the file is not inside node_modules.
+*/
+function getNodeModulesPackageRoot(filePath) {
+	const normalized = normalizePath(filePath);
+	const nodeModulesIndex = normalized.lastIndexOf("/node_modules/");
+	if (nodeModulesIndex === -1) return void 0;
+	const packageStart = nodeModulesIndex + 14;
+	const rest = normalized.slice(packageStart);
+	const firstSlash = rest.indexOf("/");
+	let packageName;
+	if (rest.startsWith("@")) {
+		const secondSlash = rest.indexOf("/", firstSlash + 1);
+		packageName = secondSlash === -1 ? rest : rest.slice(0, secondSlash);
+	} else packageName = firstSlash === -1 ? rest : rest.slice(0, firstSlash);
+	return normalized.slice(0, packageStart) + packageName;
+}
+const virtualSourceRE = /^(?:dep:|browser-external:|virtual:)|\0/;
+async function computeSourceRoute(map, file) {
+	let sourceRoot;
+	try {
+		sourceRoot = await fsp.realpath(path.resolve(path.dirname(file), map.sourceRoot || ""));
+	} catch {}
+	return sourceRoot;
+}
+async function injectSourcesContent(map, file, logger) {
+	let sourceRootPromise;
+	const packageRoot = getNodeModulesPackageRoot(file);
+	const missingSources = [];
+	const sourcesContent = map.sourcesContent || [];
+	const sourcesContentPromises = [];
+	for (let index = 0; index < map.sources.length; index++) {
+		const sourcePath = map.sources[index];
+		if (sourcesContent[index] == null && sourcePath && !virtualSourceRE.test(sourcePath)) sourcesContentPromises.push((async () => {
+			sourceRootPromise ??= computeSourceRoute(map, file);
+			const sourceRoot = await sourceRootPromise;
+			let resolvedSourcePath = cleanUrl(decodeURI(sourcePath));
+			if (sourceRoot) resolvedSourcePath = path.resolve(sourceRoot, resolvedSourcePath);
+			if (packageRoot) {
+				const resolvedSourcePathNormalized = normalizePath(path.resolve(resolvedSourcePath));
+				if (!isParentDirectory(packageRoot, resolvedSourcePathNormalized)) {
+					sourcesContent[index] = null;
+					logger.warnOnce(import_picocolors.default.yellow(`Sourcemap for ${JSON.stringify(file)} points to a source file outside its package: ${JSON.stringify(resolvedSourcePathNormalized)}`));
+					return;
+				}
+			}
+			sourcesContent[index] = await fsp.readFile(resolvedSourcePath, "utf-8").catch(() => {
+				missingSources.push(resolvedSourcePath);
+				return null;
+			});
+		})());
+	}
+	await Promise.all(sourcesContentPromises);
+	map.sourcesContent = sourcesContent;
+	if (missingSources.length) {
+		logger.warnOnce(`Sourcemap for "${file}" points to missing source files`);
+		debug$10?.(`Missing sources:\n  ` + missingSources.join(`\n  `));
+	}
+}
+function genSourceMapUrl(map) {
+	if (typeof map !== "string") map = JSON.stringify(map);
+	return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
+}
+function getCodeWithSourcemap(type, code, map) {
+	if (debug$10) code += `\n/*${JSON.stringify(map, null, 2).replace(/\*\//g, "*\\/")}*/\n`;
+	if (type === "js") code += `\n//# sourceMappingURL=${genSourceMapUrl(map)}`;
+	else if (type === "css") code += `\n/*# sourceMappingURL=${genSourceMapUrl(map)} */`;
+	return code;
+}
+function applySourcemapIgnoreList(map, sourcemapPath, sourcemapIgnoreList, logger) {
+	let { x_google_ignoreList } = map;
+	if (x_google_ignoreList === void 0) x_google_ignoreList = [];
+	if (map.sources) {
+		for (let sourcesIndex = 0; sourcesIndex < map.sources.length; ++sourcesIndex) {
+			const sourcePath = map.sources[sourcesIndex];
+			if (!sourcePath) continue;
+			const ignoreList = sourcemapIgnoreList(path.isAbsolute(sourcePath) ? sourcePath : path.resolve(path.dirname(sourcemapPath), sourcePath), sourcemapPath);
+			if (logger && typeof ignoreList !== "boolean") logger.warn("sourcemapIgnoreList function must return a boolean.");
+			if (ignoreList && !x_google_ignoreList.includes(sourcesIndex)) x_google_ignoreList.push(sourcesIndex);
+		}
+		if (x_google_ignoreList.length > 0) {
+			if (!map.x_google_ignoreList) map.x_google_ignoreList = x_google_ignoreList;
+		}
+	}
+}
+function extractSourcemapFromFile(code, filePath, logger) {
+	const map = (import_convert_source_map.fromSource(code) || import_convert_source_map.fromMapFileSource(code, createConvertSourceMapReadMap(filePath, logger)))?.toObject();
+	if (map) return {
+		code: code.replace(import_convert_source_map.default.mapFileCommentRegex, blankReplacer),
+		map
+	};
+}
+function createConvertSourceMapReadMap(originalFileName, logger) {
+	const packageRoot = getNodeModulesPackageRoot(originalFileName);
+	return (filename) => {
+		const resolvedPath = path.resolve(path.dirname(originalFileName), filename);
+		if (packageRoot && !isParentDirectory(packageRoot, normalizePath(resolvedPath))) {
+			logger.warnOnce(import_picocolors.default.yellow(`Sourcemap in "${originalFileName}" references a map file outside its package: "${filename}"`));
+			return "{}";
+		}
+		return fs.readFileSync(resolvedPath, "utf-8");
+	};
+}
+//#endregion
+//#region src/node/idResolver.ts
+/**
+* Some projects like Astro were overriding config.createResolver to add a custom
+* alias plugin. For the client and ssr environments, we root through it to avoid
+* breaking changes for now.
+*/
+function createBackCompatIdResolver(config, options) {
+	const compatResolve = config.createResolver(options);
+	let resolve;
+	return async (environment, id, importer, aliasOnly) => {
+		if (environment.name === "client" || environment.name === "ssr") return compatResolve(id, importer, aliasOnly, environment.name === "ssr");
+		resolve ??= createIdResolver(config, options);
+		return resolve(environment, id, importer, aliasOnly);
+	};
+}
+/**
+* Create an internal resolver to be used in special scenarios, e.g.
+* optimizer and handling css @imports
+*/
+function createIdResolver(config, options) {
+	const scan = options?.scan;
+	const pluginContainerMap = /* @__PURE__ */ new Map();
+	async function resolve(environment, id, importer) {
+		let pluginContainer = pluginContainerMap.get(environment);
+		if (!pluginContainer) {
+			pluginContainer = await createEnvironmentPluginContainer(environment, [alias$1({ entries: environment.config.resolve.alias }), ...oxcResolvePlugin({
+				root: config.root,
+				isProduction: config.isProduction,
+				isBuild: config.command === "build",
+				asSrc: true,
+				preferRelative: false,
+				tryIndex: true,
+				...options,
+				idOnly: true
+			}, environment.config)], void 0, false);
+			pluginContainerMap.set(environment, pluginContainer);
+		}
+		return await pluginContainer.resolveId(id, importer, { scan });
+	}
+	const aliasOnlyPluginContainerMap = /* @__PURE__ */ new Map();
+	async function resolveAlias(environment, id, importer) {
+		let pluginContainer = aliasOnlyPluginContainerMap.get(environment);
+		if (!pluginContainer) {
+			pluginContainer = await createEnvironmentPluginContainer(environment, [alias$1({ entries: environment.config.resolve.alias })], void 0, false);
+			aliasOnlyPluginContainerMap.set(environment, pluginContainer);
+		}
+		return await pluginContainer.resolveId(id, importer, { scan });
+	}
+	return async (environment, id, importer, aliasOnly) => {
+		return (await (aliasOnly ? resolveAlias : resolve)(environment, id, importer))?.id;
+	};
+}
+//#endregion
+//#region src/node/baseEnvironment.ts
+const environmentColors = [
+	import_picocolors.default.blue,
+	import_picocolors.default.magenta,
+	import_picocolors.default.green,
+	import_picocolors.default.gray
+];
+var PartialEnvironment = class {
+	name;
+	getTopLevelConfig() {
+		return this._topLevelConfig;
+	}
+	config;
+	logger;
+	/**
+	* @internal
+	*/
+	_options;
+	/**
+	* @internal
+	*/
+	_topLevelConfig;
+	constructor(name, topLevelConfig, options = topLevelConfig.environments[name]) {
+		if (!/^[\w$]+$/.test(name)) throw new Error(`Invalid environment name "${name}". Environment names must only contain alphanumeric characters and "$", "_".`);
+		this.name = name;
+		this._topLevelConfig = topLevelConfig;
+		this._options = options;
+		this.config = new Proxy(options, { get: (target, prop) => {
+			if (prop === "logger") return this.logger;
+			if (prop in target) return this._options[prop];
+			return this._topLevelConfig[prop];
+		} });
+		const environment = import_picocolors.default.dim(`(${this.name})`);
+		const infoColor = environmentColors[[...this.name].reduce((acc, c) => acc + c.charCodeAt(0), 0) % environmentColors.length || 0];
+		this.logger = {
+			get hasWarned() {
+				return topLevelConfig.logger.hasWarned;
+			},
+			info(msg, opts) {
+				return topLevelConfig.logger.info(msg, {
+					...opts,
+					environment: infoColor(environment)
+				});
+			},
+			warn(msg, opts) {
+				return topLevelConfig.logger.warn(msg, {
+					...opts,
+					environment: import_picocolors.default.yellow(environment)
+				});
+			},
+			warnOnce(msg, opts) {
+				return topLevelConfig.logger.warnOnce(msg, {
+					...opts,
+					environment: import_picocolors.default.yellow(environment)
+				});
+			},
+			error(msg, opts) {
+				return topLevelConfig.logger.error(msg, {
+					...opts,
+					environment: import_picocolors.default.red(environment)
+				});
+			},
+			clearScreen(type) {
+				return topLevelConfig.logger.clearScreen(type);
+			},
+			hasErrorLogged(error) {
+				return topLevelConfig.logger.hasErrorLogged(error);
+			}
+		};
+	}
+};
+var BaseEnvironment = class extends PartialEnvironment {
+	get plugins() {
+		return this.config.plugins;
+	}
+	/**
+	* @internal
+	*/
+	_initiated = false;
+	constructor(name, config, options = config.environments[name]) {
+		super(name, config, options);
+	}
+};
+//#endregion
+//#region src/node/server/searchRoot.ts
+const ROOT_FILES = ["pnpm-workspace.yaml", "lerna.json"];
+function hasWorkspacePackageJSON(root) {
+	const path = join(root, "package.json");
+	if (!isFileReadable(path)) return false;
+	try {
+		return !!(JSON.parse(fs.readFileSync(path, "utf-8")) || {}).workspaces;
+	} catch {
+		return false;
+	}
+}
+function hasWorkspaceDenoJSON(root) {
+	for (const name of ["deno.json", "deno.jsonc"]) {
+		const path = join(root, name);
+		if (!isFileReadable(path)) continue;
+		try {
+			if ((JSON.parse(fs.readFileSync(path, "utf-8")) || {}).workspace) return true;
+		} catch {}
+	}
+	return false;
+}
+function hasRootFile(root) {
+	return ROOT_FILES.some((file) => fs.existsSync(join(root, file)));
+}
+function hasPackageJSON(root) {
+	const path = join(root, "package.json");
+	return fs.existsSync(path);
+}
+/**
+* Search up for the nearest `package.json`
+*/
+function searchForPackageRoot(current, root = current) {
+	if (hasPackageJSON(current)) return current;
+	const dir = dirname(current);
+	if (!dir || dir === current) return root;
+	return searchForPackageRoot(dir, root);
+}
+/**
+* Search up for the nearest workspace root
+*/
+function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
+	if (hasRootFile(current)) return current;
+	if (hasWorkspacePackageJSON(current)) return current;
+	if (hasWorkspaceDenoJSON(current)) return current;
+	const dir = dirname(current);
+	if (!dir || dir === current) return root;
+	return searchForWorkspaceRoot(dir, root);
+}
+//#endregion
+//#region src/node/plugins/manifest.ts
+const endsWithJSRE = /\.[cm]?js$/;
+function manifestPlugin() {
+	const getState = perEnvironmentState(() => {
+		return {
+			manifest: {},
+			outputCount: 0,
+			reset() {
+				this.manifest = {};
+				this.outputCount = 0;
+			}
+		};
+	});
+	return perEnvironmentPlugin("native:manifest", (environment) => {
+		if (!environment.config.build.manifest) return false;
+		const root = environment.config.root;
+		const outPath = environment.config.build.manifest === true ? ".vite/manifest.json" : environment.config.build.manifest;
+		const envs = {};
+		function getChunkName(chunk) {
+			return getChunkOriginalFileName(chunk, root, false) ?? `_${path.basename(chunk.fileName)}`;
+		}
+		return [
+			{
+				name: "native:manifest-envs",
+				buildStart() {
+					envs[environment.name] = this.environment;
+				}
+			},
+			viteManifestPlugin({
+				root,
+				outPath,
+				isOutputOptionsForLegacyChunks: environment.config.isOutputOptionsForLegacyChunks,
+				cssEntries() {
+					return Object.fromEntries([...cssEntriesMap.get(envs[environment.name]).values()].map(({ name, referenceId }) => {
+						return [referenceId, name];
+					}));
+				}
+			}),
+			{
+				name: "native:manifest-compatible",
+				generateBundle(_, bundle) {
+					const asset = bundle[outPath];
+					if (asset.type === "asset") {
+						let manifest;
+						for (const output of Object.values(bundle)) {
+							const importedCss = output.viteMetadata?.importedCss;
+							const importedAssets = output.viteMetadata?.importedAssets;
+							if (!importedCss?.size && !importedAssets?.size) continue;
+							manifest ??= JSON.parse(asset.source.toString());
+							if (output.type === "chunk") {
+								const item = manifest[getChunkName(output)];
+								if (!item) continue;
+								if (importedCss?.size) item.css = [...importedCss];
+								if (importedAssets?.size) item.assets = [...importedAssets];
+							} else if (output.type === "asset" && output.names.length > 0) {
+								const keys = output.originalFileNames.length > 0 ? output.originalFileNames : [`_${path.basename(output.fileName)}`];
+								for (const key of keys) {
+									const item = manifest[key];
+									if (!item) continue;
+									if (!(item.file && endsWithJSRE.test(item.file))) {
+										if (importedCss?.size) item.css = [...importedCss];
+										if (importedAssets?.size) item.assets = [...importedAssets];
+									}
+								}
+							}
+						}
+						const output = this.environment.config.build.rolldownOptions.output;
+						const outputLength = Array.isArray(output) ? output.length : 1;
+						if (manifest && outputLength === 1) {
+							asset.source = JSON.stringify(manifest, void 0, 2);
+							return;
+						}
+						const state = getState(this);
+						state.outputCount++;
+						state.manifest = Object.assign(state.manifest, manifest ?? JSON.parse(asset.source.toString()));
+						if (state.outputCount >= outputLength) {
+							asset.source = JSON.stringify(state.manifest, void 0, 2);
+							state.reset();
+						} else delete bundle[outPath];
+					}
+				}
+			}
+		];
+	});
+}
+function getChunkOriginalFileName(chunk, root, isLegacy) {
+	if (chunk.facadeModuleId) {
+		let name = normalizePath(path.relative(root, chunk.facadeModuleId));
+		if (isLegacy && !chunk.name.includes("-legacy")) {
+			const ext = path.extname(name);
+			const endPos = ext.length !== 0 ? -ext.length : void 0;
+			name = `${name.slice(0, endPos)}-legacy${ext}`;
+		}
+		return name.replace(/\0/g, "");
+	}
+}
+//#endregion
+//#region src/node/plugins/css.ts
+var import_src = /* @__PURE__ */ __toESM(require_src(), 1);
+const decoder = new TextDecoder();
+const _cssConfigDefaults = Object.freeze({
+	/** @experimental */
+	transformer: "postcss",
+	preprocessorMaxWorkers: true,
+	/** @experimental */
+	devSourcemap: false
+});
+const cssConfigDefaults = _cssConfigDefaults;
+function resolveCSSOptions(options) {
+	const resolved = mergeWithDefaults(_cssConfigDefaults, options ?? {});
+	if (resolved.transformer === "lightningcss") {
+		resolved.lightningcss ??= {};
+		resolved.lightningcss.targets ??= convertTargets(ESBUILD_BASELINE_WIDELY_AVAILABLE_TARGET);
+	}
+	return resolved;
+}
+const cssModuleRE = new RegExp(`\\.module${CSS_LANGS_RE.source}`);
+const directRequestRE = /[?&]direct\b/;
+const htmlProxyRE$1 = /[?&]html-proxy\b/;
+const htmlProxyIndexRE = /&index=(\d+)/;
+const commonjsProxyRE = /[?&]commonjs-proxy/;
+const inlineRE$2 = /[?&]inline\b/;
+const inlineCSSRE$1 = /[?&]inline-css\b/;
+const styleAttrRE = /[?&]style-attr\b/;
+const functionCallRE = /^[A-Z_][.\w-]*\(/i;
+const transformOnlyRE = /[?&]transform-only\b/;
+const nonEscapedDoubleQuoteRe = /(?<!\\)"/g;
+const defaultCssBundleName = "style.css";
+const isModuleCSSRequest = (request) => cssModuleRE.test(request);
+const isDirectCSSRequest = (request) => CSS_LANGS_RE.test(request) && directRequestRE.test(request);
+const isDirectRequest = (request) => directRequestRE.test(request);
+const cssModulesCache = /* @__PURE__ */ new WeakMap();
+const removedPureCssFilesCache = /* @__PURE__ */ new WeakMap();
+const cssBundleNameCache = /* @__PURE__ */ new WeakMap();
+const postcssConfigCache = /* @__PURE__ */ new WeakMap();
+function encodePublicUrlsInCSS(config) {
+	return config.command === "build";
+}
+const cssUrlAssetRE = /__VITE_CSS_URL__([\da-f]+)__/g;
+/**
+* Plugin applied before user plugins
+*/
+function cssPlugin(config) {
+	const isBuild = config.command === "build";
+	let moduleCache;
+	const idResolver = createBackCompatIdResolver(config, {
+		preferRelative: true,
+		tryIndex: false,
+		extensions: []
+	});
+	let preprocessorWorkerController;
+	if (config.css.transformer !== "lightningcss") resolvePostcssConfig(config).catch(() => {});
+	return {
+		name: "vite:css",
+		buildStart() {
+			moduleCache = /* @__PURE__ */ new Map();
+			cssModulesCache.set(config, moduleCache);
+			removedPureCssFilesCache.set(config, /* @__PURE__ */ new Map());
+			preprocessorWorkerController = createPreprocessorWorkerController(normalizeMaxWorkers(config.css.preprocessorMaxWorkers));
+			preprocessorWorkerControllerCache.set(config, preprocessorWorkerController);
+		},
+		async buildEnd() {
+			await preprocessorWorkerController?.close();
+		},
+		load: {
+			filter: { id: CSS_LANGS_RE },
+			handler(id) {
+				if (urlRE$1.test(id)) {
+					if (isModuleCSSRequest(id)) throw new Error(`?url is not supported with CSS modules. (tried to import ${JSON.stringify(id)})`);
+					if (isBuild) {
+						id = injectQuery(removeUrlQuery(id), "transform-only");
+						return `import ${JSON.stringify(id)};export default "__VITE_CSS_URL__${Buffer.from(id).toString("hex")}__"`;
+					}
+				}
+			}
+		},
+		transform: {
+			filter: { id: {
+				include: CSS_LANGS_RE,
+				exclude: [commonjsProxyRE, SPECIAL_QUERY_RE]
+			} },
+			async handler(raw, id) {
+				const { environment } = this;
+				const resolveUrl = (url, importer) => idResolver(environment, url, importer);
+				const urlResolver = async (url, importer) => {
+					const decodedUrl = decodeURI(url);
+					if (checkPublicFile(decodedUrl, config)) if (encodePublicUrlsInCSS(config)) return [publicFileToBuiltUrl(decodedUrl, config), void 0];
+					else return [joinUrlSegments(joinUrlSegments(config.server.origin ?? "", config.base), decodedUrl), void 0];
+					const [id, fragment] = decodedUrl.split("#");
+					let resolved = await resolveUrl(id, importer);
+					if (resolved) {
+						if (fragment) resolved += "#" + fragment;
+						let url = await fileToUrl$1(this, resolved);
+						if (!url.startsWith("data:") && this.environment.mode === "dev") {
+							const mod = [...this.environment.moduleGraph.getModulesByFile(resolved) ?? []].find((mod) => mod.type === "asset");
+							if (mod?.lastHMRTimestamp) url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
+						}
+						return [url, cleanUrl(resolved)];
+					}
+					if (config.command === "build") {
+						if (!(config.build.rollupOptions.external ? resolveUserExternal(config.build.rollupOptions.external, decodedUrl, id, false) : false)) config.logger.warnOnce(`\n${decodedUrl} referenced in ${id} didn't resolve at build time, it will remain unchanged to be resolved at runtime`);
+					}
+					return [url, void 0];
+				};
+				const { code: css, modules, deps, map } = await compileCSS(environment, id, raw, preprocessorWorkerController, urlResolver);
+				if (modules) moduleCache.set(id, modules);
+				if (deps) for (const file of deps) this.addWatchFile(file);
+				return {
+					code: css,
+					map
+				};
+			}
+		}
+	};
+}
+/**
+* Plugin applied after user plugins
+*/
+function cssPostPlugin(config) {
+	const styles = /* @__PURE__ */ new Map();
+	let codeSplitEmitQueue = createSerialPromiseQueue();
+	const urlEmitQueue = createSerialPromiseQueue();
+	let pureCssChunks;
+	let hasEmitted = false;
+	let chunkCSSMap;
+	const rollupOptionsOutput = config.build.rollupOptions.output;
+	const assetFileNames = (Array.isArray(rollupOptionsOutput) ? rollupOptionsOutput[0] : rollupOptionsOutput)?.assetFileNames;
+	const getCssAssetDirname = (cssAssetName, originalFileName) => {
+		const cssAssetNameDir = path.dirname(cssAssetName);
+		if (!assetFileNames) return path.join(config.build.assetsDir, cssAssetNameDir);
+		else if (typeof assetFileNames === "string") return path.join(path.dirname(assetFileNames), cssAssetNameDir);
+		else return path.dirname(assetFileNames({
+			type: "asset",
+			name: cssAssetName,
+			names: [cssAssetName],
+			originalFileName,
+			originalFileNames: originalFileName ? [originalFileName] : [],
+			source: "/* vite internal call, ignore */"
+		}));
+	};
+	function getCssBundleName() {
+		const cached = cssBundleNameCache.get(config);
+		if (cached) return cached;
+		const cssBundleName = config.build.lib ? resolveLibCssFilename(config.build.lib, config.root, config.packageCache) : defaultCssBundleName;
+		cssBundleNameCache.set(config, cssBundleName);
+		return cssBundleName;
+	}
+	return {
+		name: "vite:css-post",
+		renderStart() {
+			pureCssChunks = /* @__PURE__ */ new Set();
+			hasEmitted = false;
+			chunkCSSMap = /* @__PURE__ */ new Map();
+			codeSplitEmitQueue = createSerialPromiseQueue();
+		},
+		transform: {
+			filter: { id: {
+				include: CSS_LANGS_RE,
+				exclude: [commonjsProxyRE, SPECIAL_QUERY_RE]
+			} },
+			async handler(css, id) {
+				css = stripBomTag(css);
+				const inlineCSS = inlineCSSRE$1.test(id);
+				const isHTMLProxy = htmlProxyRE$1.test(id);
+				if (inlineCSS && isHTMLProxy) {
+					if (styleAttrRE.test(id)) css = css.replace(/"/g, "&quot;");
+					const index = htmlProxyIndexRE.exec(id)?.[1];
+					if (index == null) throw new Error(`HTML proxy index in "${id}" not found`);
+					addToHTMLProxyTransformResult(`${getHash(cleanUrl(id))}_${Number.parseInt(index)}`, css);
+					return `export default ''`;
+				}
+				const inlined = inlineRE$2.test(id);
+				const modules = cssModulesCache.get(config).get(id);
+				const modulesCode = modules && !inlined && dataToEsm(modules, {
+					namedExports: true,
+					preferConst: true
+				});
+				if (config.command === "serve") {
+					const getContentWithSourcemap = async (content) => {
+						if (config.css.devSourcemap) {
+							const sourcemap = this.getCombinedSourcemap();
+							if (sourcemap.mappings) await injectSourcesContent(sourcemap, cleanUrl(id), config.logger);
+							return getCodeWithSourcemap("css", content, sourcemap);
+						}
+						return content;
+					};
+					if (isDirectCSSRequest(id)) return null;
+					if (inlined) return `export default ${JSON.stringify(css)}`;
+					if (this.environment.config.consumer === "server") return modulesCode || "export {}";
+					const cssContent = await getContentWithSourcemap(css);
+					return {
+						code: [
+							this.environment.config.isBundled ? `const { updateStyle: __vite__updateStyle, removeStyle: __vite__removeStyle } = import.meta.hot._internal` : `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(path.posix.join(config.base, CLIENT_PUBLIC_PATH))}`,
+							`const __vite__id = ${JSON.stringify(id)}`,
+							`const __vite__css = ${JSON.stringify(cssContent)}`,
+							`__vite__updateStyle(__vite__id, __vite__css)`,
+							`${modulesCode || "import.meta.hot.accept()"}`,
+							`import.meta.hot.prune(() => __vite__removeStyle(__vite__id))`
+						].join("\n"),
+						map: { mappings: "" },
+						moduleType: "js"
+					};
+				}
+				if (!inlined) styles.set(id, css);
+				let code;
+				if (modulesCode) code = modulesCode;
+				else if (inlined) {
+					let content = css;
+					if (config.build.cssMinify) content = await minifyCSS(content, config, true, id);
+					code = `export default ${JSON.stringify(content)}`;
+				} else code = "";
+				return {
+					code,
+					map: { mappings: "" },
+					moduleSideEffects: modulesCode || inlined ? false : "no-treeshake",
+					moduleType: "js"
+				};
+			}
+		},
+		...config.command === "build" ? {
+			async renderChunk(code, chunk, opts, meta) {
+				let chunkCSS;
+				const renderedModules = new Proxy({}, { get(_target, p) {
+					for (const name in meta.chunks) {
+						const module = meta.chunks[name].modules[p];
+						if (module) return module;
+					}
+				} });
+				const isJsChunkEmpty = code === "" && !chunk.isEntry;
+				let isPureCssChunk = chunk.exports.length === 0;
+				const ids = Object.keys(chunk.modules);
+				for (const id of ids) if (styles.has(id)) {
+					if (transformOnlyRE.test(id)) continue;
+					const cssScopeTo = this.getModuleInfo(id)?.meta?.vite?.cssScopeTo;
+					if (cssScopeTo && !isCssScopeToRendered(cssScopeTo, renderedModules)) continue;
+					if (cssModuleRE.test(id)) isPureCssChunk = false;
+					chunkCSS = (chunkCSS || "") + styles.get(id);
+				} else if (!isJsChunkEmpty) isPureCssChunk = false;
+				const publicAssetUrlMap = publicAssetUrlCache.get(config);
+				const resolveAssetUrlsInCss = (chunkCSS, cssAssetName, originalFileName) => {
+					const encodedPublicUrls = encodePublicUrlsInCSS(config);
+					const cssAssetDirname = encodedPublicUrls || config.base === "./" || config.base === "" ? slash(getCssAssetDirname(cssAssetName, originalFileName)) : void 0;
+					const toRelative = (filename) => {
+						const relativePath = normalizePath(path.relative(cssAssetDirname, filename));
+						return relativePath[0] === "." ? relativePath : "./" + relativePath;
+					};
+					chunkCSS = chunkCSS.replace(assetUrlRE, (_, fileHash, postfix = "") => {
+						const filename = this.getFileName(fileHash) + postfix;
+						chunk.viteMetadata.importedAssets.add(cleanUrl(filename));
+						return encodeURIPath(toOutputFilePathInCss(filename, "asset", cssAssetName, "css", config, toRelative));
+					});
+					if (encodedPublicUrls) {
+						const relativePathToPublicFromCSS = normalizePath(path.relative(cssAssetDirname, ""));
+						chunkCSS = chunkCSS.replace(publicAssetUrlRE, (_, hash) => {
+							const publicUrl = publicAssetUrlMap.get(hash).slice(1);
+							return encodeURIPath(toOutputFilePathInCss(publicUrl, "public", cssAssetName, "css", config, () => `${relativePathToPublicFromCSS}/${publicUrl}`));
+						});
+					}
+					return chunkCSS;
+				};
+				function ensureFileExt(name, ext) {
+					return normalizePath(path.format({
+						...path.parse(name),
+						base: void 0,
+						ext
+					}));
+				}
+				let s;
+				const urlEmitTasks = [];
+				if (code.includes("__VITE_CSS_URL__")) {
+					let match;
+					cssUrlAssetRE.lastIndex = 0;
+					while (match = cssUrlAssetRE.exec(code)) {
+						const [full, idHex] = match;
+						const id = Buffer.from(idHex, "hex").toString();
+						const originalFileName = cleanUrl(id);
+						const cssAssetName = ensureFileExt(path.basename(originalFileName), ".css");
+						if (!styles.has(id)) throw new Error(`css content for ${JSON.stringify(id)} was not found`);
+						let cssContent = styles.get(id);
+						cssContent = resolveAssetUrlsInCss(cssContent, cssAssetName, originalFileName);
+						urlEmitTasks.push({
+							cssAssetName,
+							originalFileName,
+							content: cssContent,
+							start: match.index,
+							end: match.index + full.length
+						});
+					}
+				}
+				await urlEmitQueue.run(async () => Promise.all(urlEmitTasks.map(async (info) => {
+					info.content = await finalizeCss(info.content, config);
+				})));
+				if (urlEmitTasks.length > 0) {
+					const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(opts.format, config.isWorker);
+					s ||= new MagicString(code);
+					for (const { cssAssetName, originalFileName, content, start, end } of urlEmitTasks) {
+						const referenceId = this.emitFile({
+							type: "asset",
+							name: cssAssetName,
+							originalFileName,
+							source: content
+						});
+						const filename = this.getFileName(referenceId);
+						chunk.viteMetadata.importedAssets.add(cleanUrl(filename));
+						const replacement = toOutputFilePathInJS(this.environment, filename, "asset", chunk.fileName, "js", toRelativeRuntime);
+						const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`;
+						s.update(start, end, replacementString);
+					}
+				}
+				if (chunkCSS !== void 0) {
+					if (isPureCssChunk && (opts.format === "es" || opts.format === "cjs")) pureCssChunks.add(chunk);
+					if (this.environment.config.build.cssCodeSplit) {
+						if ((opts.format === "es" || opts.format === "cjs") && !chunk.fileName.includes("-legacy")) {
+							const isEntry = chunk.isEntry && isPureCssChunk;
+							const cssFullAssetName = ensureFileExt(chunk.name, ".css");
+							const cssAssetName = chunk.isEntry && (!chunk.facadeModuleId || !isCSSRequest(chunk.facadeModuleId)) ? path.basename(cssFullAssetName) : cssFullAssetName;
+							const originalFileName = getChunkOriginalFileName(chunk, config.root, this.environment.config.isOutputOptionsForLegacyChunks?.(opts) ?? false);
+							chunkCSS = resolveAssetUrlsInCss(chunkCSS, cssAssetName, originalFileName);
+							chunkCSS = await codeSplitEmitQueue.run(async () => {
+								return finalizeCss(chunkCSS, config);
+							});
+							const referenceId = this.emitFile({
+								type: "asset",
+								name: cssAssetName,
+								originalFileName,
+								source: chunkCSS
+							});
+							if (isEntry) cssEntriesMap.get(this.environment).set(chunk.fileName, {
+								referenceId,
+								name: chunk.name
+							});
+							chunk.viteMetadata.importedCss.add(this.getFileName(referenceId));
+						} else if (this.environment.config.consumer === "client") {
+							chunkCSS = await finalizeCss(chunkCSS, config);
+							let cssString = JSON.stringify(chunkCSS);
+							cssString = renderAssetUrlInJS(this, chunk, opts, cssString)?.toString() || cssString;
+							const style = `__vite_style__`;
+							const injectCode = `var ${style} = document.createElement('style');${style}.textContent = ${cssString};document.head.appendChild(${style});`;
+							s ||= new MagicString(code);
+							injectInlinedCSS(s, this, code, opts.format, injectCode);
+						}
+					} else {
+						chunkCSS = resolveAssetUrlsInCss(chunkCSS, getCssBundleName(), defaultCssBundleName);
+						chunkCSSMap.set(chunk.fileName, chunkCSS);
+					}
+				}
+				if (s) if (config.build.sourcemap) return {
+					code: s.toString(),
+					map: s.generateMap({ hires: "boundary" })
+				};
+				else return { code: s.toString() };
+				return null;
+			},
+			augmentChunkHash(chunk) {
+				if (chunk.viteMetadata?.importedCss.size) {
+					let hash = "";
+					for (const id of chunk.viteMetadata.importedCss) hash += id;
+					return hash;
+				}
+			}
+		} : {},
+		async generateBundle(opts, bundle) {
+			if (this.environment.config.isOutputOptionsForLegacyChunks?.(opts)) return;
+			if ((config.command !== "build" || this.environment.config.build.emitAssets) && !this.environment.config.build.cssCodeSplit && !hasEmitted) {
+				let extractedCss = "";
+				const collected = /* @__PURE__ */ new Set();
+				const dynamicImports = /* @__PURE__ */ new Set();
+				function collect(chunk) {
+					if (!chunk || chunk.type !== "chunk" || collected.has(chunk)) return;
+					collected.add(chunk);
+					chunk.imports.forEach((importName) => collect(bundle[importName]));
+					chunk.dynamicImports.forEach((importName) => dynamicImports.add(importName));
+					extractedCss += chunkCSSMap.get(chunk.preliminaryFileName) ?? "";
+				}
+				for (const chunk of Object.values(bundle)) if (chunk.type === "chunk" && chunk.isEntry) collect(chunk);
+				for (const chunkName of dynamicImports) collect(bundle[chunkName]);
+				if (extractedCss) {
+					hasEmitted = true;
+					extractedCss = await finalizeCss(extractedCss, config);
+					this.emitFile({
+						name: getCssBundleName(),
+						type: "asset",
+						source: extractedCss,
+						originalFileName: defaultCssBundleName
+					});
+				}
+			}
+			if (pureCssChunks.size) {
+				const prelimaryNameToChunkMap = Object.fromEntries(Object.values(bundle).filter((chunk) => chunk.type === "chunk").map((chunk) => [chunk.preliminaryFileName, chunk.fileName]));
+				const pureCssChunkNames = [...pureCssChunks].map((pureCssChunk) => prelimaryNameToChunkMap[pureCssChunk.fileName]).filter(Boolean);
+				const replaceEmptyChunk = getEmptyChunkReplacer(pureCssChunkNames, opts.format);
+				for (const file in bundle) {
+					const chunk = bundle[file];
+					if (chunk.type === "chunk") {
+						let chunkImportsPureCssChunk = false;
+						chunk.imports = chunk.imports.filter((file) => {
+							if (pureCssChunkNames.includes(file)) {
+								const { importedCss, importedAssets } = bundle[file].viteMetadata;
+								importedCss.forEach((file) => chunk.viteMetadata.importedCss.add(file));
+								importedAssets.forEach((file) => chunk.viteMetadata.importedAssets.add(file));
+								chunkImportsPureCssChunk = true;
+								return false;
+							}
+							return true;
+						});
+						if (chunkImportsPureCssChunk) chunk.code = replaceEmptyChunk(chunk.code);
+					}
+				}
+				const removedPureCssFiles = removedPureCssFilesCache.get(config);
+				pureCssChunkNames.forEach((fileName) => {
+					const emptyJsPlaceholder = bundle[fileName];
+					if (emptyJsPlaceholder.isEntry) {
+						const { importedAssets, importedCss } = emptyJsPlaceholder.viteMetadata;
+						const cssReferenceId = cssEntriesMap.get(this.environment).get(emptyJsPlaceholder.preliminaryFileName).referenceId;
+						const realCssEntryName = this.getFileName(cssReferenceId);
+						const realCssEntry = bundle[realCssEntryName];
+						importedCss.delete(realCssEntryName);
+						if (importedAssets.size) realCssEntry.viteMetadata.importedAssets = importedAssets;
+						if (importedCss.size) realCssEntry.viteMetadata.importedCss = importedCss;
+					}
+					removedPureCssFiles.set(fileName, emptyJsPlaceholder);
+					delete bundle[fileName];
+					delete bundle[`${fileName}.map`];
+				});
+			}
+			const cssAssets = Object.values(bundle).filter((asset) => asset.type === "asset" && asset.fileName.endsWith(".css"));
+			for (const cssAsset of cssAssets) if (typeof cssAsset.source === "string") cssAsset.source = cssAsset.source.replace(viteHashUpdateMarkerRE, "");
+		}
+	};
+}
+function injectInlinedCSS(s, ctx, code, format, injectCode) {
+	let injectionPoint;
+	if (format === "iife" || format === "umd") {
+		const m = (format === "iife" ? IIFE_BEGIN_RE : UMD_BEGIN_RE).exec(code);
+		if (!m) ctx.error("Injection point for inlined CSS not found");
+		injectionPoint = m.index + m[0].length;
+	} else if (format === "es") if (code.startsWith("#!")) {
+		let secondLinePos = code.indexOf("\n");
+		if (secondLinePos === -1) secondLinePos = 0;
+		injectionPoint = secondLinePos;
+	} else injectionPoint = 0;
+	else ctx.error("Non supported format");
+	s.appendRight(injectionPoint, injectCode);
+}
+function cssAnalysisPlugin(config) {
+	return {
+		name: "vite:css-analysis",
+		applyToEnvironment(environment) {
+			return !environment.config.isBundled;
+		},
+		transform: {
+			filter: { id: {
+				include: CSS_LANGS_RE,
+				exclude: [commonjsProxyRE, SPECIAL_QUERY_RE]
+			} },
+			handler(_, id) {
+				const { moduleGraph } = this.environment;
+				const thisModule = moduleGraph.getModuleById(id);
+				if (thisModule) {
+					const isSelfAccepting = !cssModulesCache.get(config)?.get(id) && !inlineRE$2.test(id) && !htmlProxyRE$1.test(id);
+					const pluginImports = this._addedImports;
+					if (pluginImports) {
+						const depModules = /* @__PURE__ */ new Set();
+						for (const file of pluginImports) depModules.add(moduleGraph.createFileOnlyEntry(file));
+						moduleGraph.updateModuleInfo(thisModule, depModules, null, /* @__PURE__ */ new Set(), null, isSelfAccepting);
+					} else thisModule.isSelfAccepting = isSelfAccepting;
+				}
+			}
+		}
+	};
+}
+function isCssScopeToRendered(cssScopeTo, renderedModules) {
+	const [importerId, exp] = cssScopeTo;
+	const importer = renderedModules[importerId];
+	return importer && (exp === void 0 || importer.renderedExports.includes(exp));
+}
+/**
+* Create a replacer function that takes code and replaces given pure CSS chunk imports
+* @param pureCssChunkNames The chunks that only contain pure CSS and should be replaced
+* @param outputFormat The module output format to decide whether to replace `import` or `require`
+*/
+function getEmptyChunkReplacer(pureCssChunkNames, outputFormat) {
+	const emptyChunkFiles = pureCssChunkNames.map((file) => escapeRegex(path.basename(file))).join("|");
+	const emptyChunkRE = new RegExp(outputFormat === "es" ? `\\bimport\\s*["'][^"']*(?:${emptyChunkFiles})["'];` : `(\\b|,\\s*)require\\(\\s*["'\`][^"'\`]*(?:${emptyChunkFiles})["'\`]\\)(;|,)`, "g");
+	return (code) => code.replace(emptyChunkRE, (m, p1, p2) => {
+		if (outputFormat === "es") return `/* empty css ${"".padEnd(m.length - 15)}*/`;
+		if (p2 === ";") return `${p2}/* empty css ${"".padEnd(m.length - 16)}*/`;
+		return `${p1}/* empty css ${"".padEnd(m.length - 15 - p1.length)}*/`;
+	});
+}
+const fileURLWithWindowsDriveRE = /^file:\/\/\/[a-zA-Z]:\//;
+function createCSSResolvers(config) {
+	let cssResolve;
+	let sassResolve;
+	let lessResolve;
+	return {
+		get css() {
+			return cssResolve ??= createBackCompatIdResolver(config, {
+				extensions: [".css"],
+				mainFields: ["style"],
+				conditions: ["style", DEV_PROD_CONDITION],
+				tryIndex: false,
+				preferRelative: true
+			});
+		},
+		get sass() {
+			if (!sassResolve) {
+				const resolver = createBackCompatIdResolver(config, {
+					extensions: [
+						".scss",
+						".sass",
+						".css"
+					],
+					mainFields: ["sass", "style"],
+					conditions: [
+						"sass",
+						"style",
+						DEV_PROD_CONDITION
+					],
+					tryIndex: true,
+					tryPrefix: "_",
+					preferRelative: true,
+					skipMainField: true
+				});
+				sassResolve = async (...args) => {
+					if (args[1].startsWith("file://")) args[1] = fileURLToPath(args[1], { windows: isWindows && !fileURLWithWindowsDriveRE.test(args[1]) ? false : void 0 });
+					return resolver(...args);
+				};
+			}
+			return sassResolve;
+		},
+		get less() {
+			return lessResolve ??= createBackCompatIdResolver(config, {
+				extensions: [".less", ".css"],
+				mainFields: ["less", "style"],
+				conditions: [
+					"less",
+					"style",
+					DEV_PROD_CONDITION
+				],
+				tryIndex: false,
+				preferRelative: true
+			});
+		}
+	};
+}
+function getCssResolversKeys(resolvers) {
+	return Object.keys(resolvers);
+}
+async function compileCSSPreprocessors(environment, id, lang, code, workerController) {
+	const { config } = environment;
+	const { preprocessorOptions, devSourcemap } = config.css;
+	const atImportResolvers = getAtImportResolvers(environment.getTopLevelConfig());
+	const opts = {
+		...preprocessorOptions && preprocessorOptions[lang] || {},
+		filename: cleanUrl(id),
+		enableSourcemap: devSourcemap ?? false
+	};
+	const preProcessor = workerController[lang];
+	const preprocessResult = await preProcessor(environment, code, config.root, opts, atImportResolvers);
+	if (preprocessResult.error) throw preprocessResult.error;
+	let deps;
+	if (preprocessResult.deps.length > 0) {
+		const normalizedFilename = normalizePath(opts.filename);
+		deps = new Set([...preprocessResult.deps].filter((dep) => normalizePath(dep) !== normalizedFilename));
+	}
+	return {
+		code: preprocessResult.code,
+		map: combineSourcemapsIfExists(opts.filename, preprocessResult.map, preprocessResult.additionalMap),
+		deps
+	};
+}
+const configToAtImportResolvers = /* @__PURE__ */ new WeakMap();
+function getAtImportResolvers(config) {
+	let atImportResolvers = configToAtImportResolvers.get(config);
+	if (!atImportResolvers) {
+		atImportResolvers = createCSSResolvers(config);
+		configToAtImportResolvers.set(config, atImportResolvers);
+	}
+	return atImportResolvers;
+}
+async function compileCSS(environment, id, code, workerController, urlResolver) {
+	const { config } = environment;
+	const lang = CSS_LANGS_RE.exec(id)?.[1];
+	const deps = /* @__PURE__ */ new Set();
+	let preprocessorMap;
+	if (isPreProcessor(lang)) {
+		const preprocessorResult = await compileCSSPreprocessors(environment, id, lang, code, workerController);
+		code = preprocessorResult.code;
+		preprocessorMap = preprocessorResult.map;
+		preprocessorResult.deps?.forEach((dep) => deps.add(dep));
+	} else if (lang === "sss" && config.css.transformer === "lightningcss") {
+		const sssResult = await transformSugarSS(environment, id, code);
+		code = sssResult.code;
+		preprocessorMap = sssResult.map;
+	}
+	const transformResult = await (config.css.transformer === "lightningcss" ? compileLightningCSS(environment, id, code, deps, workerController, urlResolver) : compilePostCSS(environment, id, code, deps, lang, workerController, urlResolver));
+	if (!transformResult) return {
+		code,
+		map: config.css.devSourcemap ? preprocessorMap : { mappings: "" },
+		deps
+	};
+	return {
+		...transformResult,
+		map: config.css.devSourcemap ? combineSourcemapsIfExists(cleanUrl(id), typeof transformResult.map === "string" ? JSON.parse(transformResult.map) : transformResult.map, preprocessorMap) : { mappings: "" },
+		deps
+	};
+}
+async function compilePostCSS(environment, id, code, deps, lang, workerController, urlResolver) {
+	const { config } = environment;
+	const { modules: modulesOptions, devSourcemap } = config.css;
+	const isModule = modulesOptions !== false && cssModuleRE.test(id);
+	const needInlineImport = code.includes("@import");
+	const hasUrl = cssUrlRE.test(code) || cssImageSetRE.test(code);
+	const postcssConfig = await resolvePostcssConfig(environment.getTopLevelConfig());
+	if (lang !== "sss" && !postcssConfig && !isModule && !needInlineImport && !hasUrl) return;
+	const atImportResolvers = getAtImportResolvers(environment.getTopLevelConfig());
+	const postcssPlugins = postcssConfig?.plugins.slice() ?? [];
+	if (needInlineImport) postcssPlugins.unshift((await importPostcssImport()).default({
+		async resolve(id, basedir) {
+			const publicFile = checkPublicFile(id, environment.getTopLevelConfig());
+			if (publicFile) return publicFile;
+			const resolved = await atImportResolvers.css(environment, id, path.join(basedir, "*"));
+			if (resolved) return path.resolve(resolved);
+			if (!path.isAbsolute(id)) environment.logger.error(import_picocolors.default.red(`Unable to resolve \`@import "${id}"\` from ${basedir}`));
+			return id;
+		},
+		async load(id) {
+			const code = await fs.promises.readFile(id, "utf-8");
+			const lang = CSS_LANGS_RE.exec(id)?.[1];
+			if (isPreProcessor(lang)) {
+				const result = await compileCSSPreprocessors(environment, id, lang, code, workerController);
+				result.deps?.forEach((dep) => deps.add(dep));
+				return result.code;
+			}
+			return code;
+		},
+		nameLayer(index) {
+			return `vite--anon-layer-${getHash(id)}-${index}`;
+		}
+	}));
+	if (urlResolver && (postcssPlugins.length > 0 || isModule || hasUrl)) postcssPlugins.push(UrlRewritePostcssPlugin({
+		resolver: urlResolver,
+		deps,
+		logger: environment.logger
+	}));
+	let modules;
+	if (isModule) postcssPlugins.unshift((await importPostcssModules()).default({
+		...modulesOptions,
+		localsConvention: modulesOptions?.localsConvention,
+		getJSON(cssFileName, _modules, outputFileName) {
+			modules = _modules;
+			if (modulesOptions && typeof modulesOptions.getJSON === "function") modulesOptions.getJSON(cssFileName, _modules, outputFileName);
+		},
+		async resolve(id, importer) {
+			for (const key of getCssResolversKeys(atImportResolvers)) {
+				const resolved = await atImportResolvers[key](environment, id, importer);
+				if (resolved) return path.resolve(resolved);
+			}
+			return id;
+		}
+	}));
+	const postcssOptions = postcssConfig?.options ?? {};
+	const postcssParser = lang === "sss" ? await loadSss(config.root) : postcssOptions.parser;
+	if (!postcssPlugins.length && !postcssParser) return;
+	return {
+		...await runPostCSS(id, code, postcssPlugins, {
+			...postcssOptions,
+			parser: postcssParser
+		}, deps, environment.logger, devSourcemap),
+		modules
+	};
+}
+async function transformSugarSS(environment, id, code) {
+	const { config } = environment;
+	const { devSourcemap } = config.css;
+	return await runPostCSS(id, code, [], { parser: await loadSss(config.root) }, void 0, environment.logger, devSourcemap);
+}
+async function runPostCSS(id, code, plugins, options, deps, logger, enableSourcemap) {
+	let postcssResult;
+	try {
+		const source = removeDirectQuery(id);
+		postcssResult = await (await importPostcss()).default(plugins).process(code, {
+			...options,
+			to: source,
+			from: source,
+			...enableSourcemap ? { map: {
+				inline: false,
+				annotation: false,
+				sourcesContent: true
+			} } : {}
+		});
+		for (const message of postcssResult.messages) if (message.type === "dependency") deps?.add(normalizePath(message.file));
+		else if (message.type === "dir-dependency") {
+			const { dir, glob: globPattern = "**" } = message;
+			const files = globSync(globPattern, {
+				absolute: true,
+				cwd: path.resolve(path.dirname(id), dir),
+				expandDirectories: false,
+				ignore: ["**/node_modules/**"]
+			});
+			for (let i = 0; i < files.length; i++) deps?.add(files[i]);
+		} else if (message.type === "warning") {
+			const warning = message;
+			let msg = `[vite:css][postcss] ${warning.text}`;
+			msg += `\n${generateCodeFrame(code, {
+				line: warning.line,
+				column: warning.column - 1
+			}, warning.endLine !== void 0 && warning.endColumn !== void 0 ? {
+				line: warning.endLine,
+				column: warning.endColumn - 1
+			} : void 0)}`;
+			logger.warn(import_picocolors.default.yellow(msg));
+		}
+	} catch (e) {
+		e.message = `[postcss] ${e.message}`;
+		e.code = code;
+		e.loc = {
+			file: e.file,
+			line: e.line,
+			column: e.column - 1
+		};
+		throw e;
+	}
+	if (!enableSourcemap) return {
+		code: postcssResult.css,
+		map: { mappings: "" }
+	};
+	const postcssMap = await formatPostcssSourceMap(postcssResult.map.toJSON(), cleanUrl(id));
+	return {
+		code: postcssResult.css,
+		map: postcssMap
+	};
+}
+function createCachedImport(imp) {
+	let cached;
+	return () => {
+		if (!cached) cached = imp().then((module) => {
+			cached = module;
+			return module;
+		});
+		return cached;
+	};
+}
+const importPostcssImport = createCachedImport(() => import("./postcss-import.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1)));
+const importPostcssModules = createCachedImport(() => import("./build.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1)));
+const importPostcss = createCachedImport(() => import("postcss"));
+const preprocessorWorkerControllerCache = /* @__PURE__ */ new WeakMap();
+let alwaysFakeWorkerWorkerControllerCache;
+/**
+* @experimental
+*/
+async function preprocessCSS(code, filename, config) {
+	let workerController = preprocessorWorkerControllerCache.get(config);
+	if (!workerController) {
+		alwaysFakeWorkerWorkerControllerCache ||= createPreprocessorWorkerController(0);
+		workerController = alwaysFakeWorkerWorkerControllerCache;
+	}
+	return await compileCSS(new PartialEnvironment("client", config), filename, code, workerController);
+}
+async function formatPostcssSourceMap(rawMap, file) {
+	const inputFileDir = path.dirname(file);
+	const sources = rawMap.sources.map((source) => {
+		const cleanSource = cleanUrl(decodeURIComponent(source));
+		if (cleanSource[0] === "<" && cleanSource.endsWith(">")) return `\0${cleanSource}`;
+		return normalizePath(path.resolve(inputFileDir, cleanSource));
+	});
+	return {
+		file,
+		mappings: rawMap.mappings,
+		names: rawMap.names,
+		sources,
+		sourcesContent: rawMap.sourcesContent,
+		version: rawMap.version
+	};
+}
+function combineSourcemapsIfExists(filename, map1, map2) {
+	if (!map1 || !map2) return map1;
+	if (map1.mappings === "" || map2.mappings === "") return { mappings: "" };
+	return combineSourcemaps(filename, [map1, map2]);
+}
+const viteHashUpdateMarker = "/*$vite$:1*/";
+const viteHashUpdateMarkerRE = /\/\*\$vite\$:\d+\*\//;
+async function finalizeCss(css, config) {
+	if (css.includes("@import") || css.includes("@charset")) css = hoistAtRules(css);
+	if (config.build.cssMinify) css = await minifyCSS(css, config, false);
+	css += viteHashUpdateMarker;
+	return css;
+}
+async function resolvePostcssConfig(config) {
+	let result = postcssConfigCache.get(config);
+	if (result !== void 0) return await result;
+	const inlineOptions = config.css.postcss;
+	if (isObject$1(inlineOptions)) {
+		const options = { ...inlineOptions };
+		delete options.plugins;
+		result = {
+			options,
+			plugins: inlineOptions.plugins || []
+		};
+	} else {
+		const searchPath = typeof inlineOptions === "string" ? inlineOptions : config.root;
+		result = (0, import_src.default)({}, searchPath, { stopDir: searchForWorkspaceRoot(config.root) }).catch((e) => {
+			if (!e.message.includes("No PostCSS Config found")) if (e instanceof Error) {
+				const { name, message, stack } = e;
+				e.name = "Failed to load PostCSS config";
+				e.message = `Failed to load PostCSS config (searchPath: ${searchPath}): [${name}] ${message}\n${stack}`;
+				e.stack = "";
+				throw e;
+			} else throw new Error(`Failed to load PostCSS config: ${e}`);
+			return null;
+		});
+		result.then((resolved) => {
+			postcssConfigCache.set(config, resolved);
+		}, () => {});
+	}
+	postcssConfigCache.set(config, result);
+	return result;
+}
+const cssUrlRE = /(?<!@import\s+)(?<=^|[^\w\-\u0080-\uffff])url\((\s*('[^']+'|"[^"]+")\s*|(?:\\.|[^'")\\])+)\)/;
+const cssDataUriRE = /(?<=^|[^\w\-\u0080-\uffff])data-uri\((\s*('[^']+'|"[^"]+")\s*|[^'")]+)\)/;
+const importCssRE = /@import\s+(?:url\()?('[^']+\.css'|"[^"]+\.css"|[^'"\s)]+\.css)/;
+const cssImageSetRE = /(?<=image-set\()((?:[\w-]{1,256}\([^)]*\)|[^)])*)(?=\))/;
+const UrlRewritePostcssPlugin = (opts) => {
+	if (!opts) throw new Error("base or replace is required");
+	return {
+		postcssPlugin: "vite-url-rewrite",
+		Once(root) {
+			const promises = [];
+			root.walkDecls((declaration) => {
+				const importer = declaration.source?.input.file;
+				if (!importer) opts.logger.warnOnce("\nA PostCSS plugin did not pass the `from` option to `postcss.parse`. This may cause imported assets to be incorrectly transformed. If you've recently added a PostCSS plugin that raised this warning, please contact the package author to fix the issue.");
+				const isCssUrl = cssUrlRE.test(declaration.value);
+				const isCssImageSet = cssImageSetRE.test(declaration.value);
+				if (isCssUrl || isCssImageSet) {
+					const replacerForDeclaration = async (rawUrl) => {
+						const [newUrl, resolvedId] = await opts.resolver(rawUrl, importer);
+						if (resolvedId) opts.deps.add(resolvedId);
+						return newUrl;
+					};
+					if (isCssUrl && isCssImageSet) promises.push(rewriteCssUrls(declaration.value, replacerForDeclaration).then((url) => rewriteCssImageSet(url, replacerForDeclaration)).then((url) => {
+						declaration.value = url;
+					}));
+					else promises.push((isCssImageSet ? rewriteCssImageSet : rewriteCssUrls)(declaration.value, replacerForDeclaration).then((url) => {
+						declaration.value = url;
+					}));
+				}
+			});
+			if (promises.length) return Promise.all(promises);
+		}
+	};
+};
+UrlRewritePostcssPlugin.postcss = true;
+function rewriteCssUrls(css, replacer) {
+	return asyncReplace(css, cssUrlRE, async (match) => {
+		const [matched, rawUrl] = match;
+		return await doUrlReplace(rawUrl.trim(), matched, replacer);
+	});
+}
+function rewriteCssDataUris(css, replacer) {
+	return asyncReplace(css, cssDataUriRE, async (match) => {
+		const [matched, rawUrl] = match;
+		return await doUrlReplace(rawUrl.trim(), matched, replacer, "data-uri");
+	});
+}
+function rewriteImportCss(css, replacer) {
+	return asyncReplace(css, importCssRE, async (match) => {
+		const [matched, rawUrl] = match;
+		return await doImportCSSReplace(rawUrl, matched, replacer);
+	});
+}
+const cssNotProcessedRE = /(?:gradient|element|cross-fade|image)\(/;
+async function rewriteCssImageSet(css, replacer) {
+	return await asyncReplace(css, cssImageSetRE, async (match) => {
+		const [, rawUrl] = match;
+		return await processSrcSet(rawUrl, async ({ url }) => {
+			if (cssUrlRE.test(url)) return await rewriteCssUrls(url, replacer);
+			if (!cssNotProcessedRE.test(url)) return await doUrlReplace(url, url, replacer);
+			return url;
+		});
+	});
+}
+function skipUrlReplacer(unquotedUrl) {
+	return isExternalUrl(unquotedUrl) || isDataUrl(unquotedUrl) || unquotedUrl[0] === "#" || functionCallRE.test(unquotedUrl) || unquotedUrl.startsWith("__VITE_ASSET__") || unquotedUrl.startsWith("__VITE_PUBLIC_ASSET__");
+}
+async function doUrlReplace(rawUrl, matched, replacer, funcName = "url") {
+	let wrap = "";
+	const first = rawUrl[0];
+	let unquotedUrl = rawUrl;
+	if (first === `"` || first === `'`) {
+		wrap = first;
+		unquotedUrl = rawUrl.slice(1, -1);
+	}
+	if (skipUrlReplacer(unquotedUrl)) return matched;
+	unquotedUrl = unquotedUrl.replace(/\\(\W)/g, "$1");
+	let newUrl = await replacer(unquotedUrl, rawUrl);
+	if (newUrl === false) return matched;
+	if (wrap === "" && (newUrl !== encodeURI(newUrl) || newUrl.includes(")"))) wrap = "\"";
+	if (wrap === "'" && newUrl.includes("'")) wrap = "\"";
+	if (wrap === "\"" && newUrl.includes("\"")) newUrl = newUrl.replace(nonEscapedDoubleQuoteRe, "\\\"");
+	return `${funcName}(${wrap}${newUrl}${wrap})`;
+}
+async function doImportCSSReplace(rawUrl, matched, replacer) {
+	let wrap = "";
+	const first = rawUrl[0];
+	let unquotedUrl = rawUrl;
+	if (first === `"` || first === `'`) {
+		wrap = first;
+		unquotedUrl = rawUrl.slice(1, -1);
+	}
+	if (skipUrlReplacer(unquotedUrl)) return matched;
+	const newUrl = await replacer(unquotedUrl, rawUrl);
+	if (newUrl === false) return matched;
+	return `@import ${matched.includes("url(") ? "url(" : ""}${wrap}${newUrl}${wrap}`;
+}
+async function minifyCSS(css, config, inlined, filename = defaultCssBundleName) {
+	if (config.build.cssMinify === "esbuild") {
+		const { transform, formatMessages } = await importEsbuild();
+		try {
+			const { code, warnings } = await transform(css, {
+				loader: "css",
+				target: config.build.cssTarget || void 0,
+				sourcefile: filename,
+				...resolveMinifyCssEsbuildOptions(config.esbuild || {})
+			});
+			if (warnings.length) {
+				const msgs = await formatMessages(warnings, { kind: "warning" });
+				config.logger.warn(import_picocolors.default.yellow(`[esbuild css minify]\n${msgs.join("\n")}`));
+			}
+			return inlined ? code.trimEnd() : code;
+		} catch (e) {
+			if (e.errors) {
+				e.message = "[esbuild css minify] " + e.message;
+				e.frame = "\n" + (await formatMessages(e.errors, { kind: "error" })).join("\n");
+				e.loc = e.errors[0].location;
+			}
+			throw e;
+		}
+	}
+	try {
+		const { code, warnings } = (await importLightningCSS()).transform({
+			...config.css.lightningcss,
+			targets: convertTargets(config.build.cssTarget),
+			cssModules: void 0,
+			filename,
+			code: Buffer.from(css),
+			minify: true
+		});
+		for (const warning of warnings) {
+			let msg = `[lightningcss minify] ${warning.message}`;
+			msg += `\n${generateCodeFrame(css, {
+				line: warning.loc.line,
+				column: warning.loc.column - 1
+			})}`;
+			config.logger.warn(import_picocolors.default.yellow(msg));
+		}
+		return decoder.decode(code) + (inlined ? "" : "\n");
+	} catch (e) {
+		e.message = `[lightningcss minify] ${e.message}`;
+		const friendlyMessage = getLightningCssErrorMessageForIeSyntaxes(css);
+		if (friendlyMessage) e.message += friendlyMessage;
+		if (e.loc) {
+			e.loc = {
+				line: e.loc.line,
+				column: e.loc.column - 1
+			};
+			e.frame = generateCodeFrame(css, e.loc);
+		}
+		throw e;
+	}
+}
+function resolveMinifyCssEsbuildOptions(options) {
+	const base = {
+		charset: options.charset,
+		logLevel: options.logLevel,
+		logLimit: options.logLimit,
+		logOverride: options.logOverride,
+		legalComments: options.legalComments
+	};
+	if (options.minifyIdentifiers != null || options.minifySyntax != null || options.minifyWhitespace != null) return {
+		...base,
+		minifyIdentifiers: options.minifyIdentifiers ?? true,
+		minifySyntax: options.minifySyntax ?? true,
+		minifyWhitespace: options.minifyWhitespace ?? true
+	};
+	else return {
+		...base,
+		minify: true
+	};
+}
+const atImportRE = /@import(?:\s*(?:url\([^)]*\)|"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g;
+const atCharsetRE = /@charset(?:\s*(?:"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g;
+function hoistAtRules(css) {
+	const s = new MagicString(css);
+	const cleanCss = emptyCssComments(css);
+	let match;
+	atImportRE.lastIndex = 0;
+	while (match = atImportRE.exec(cleanCss)) {
+		s.remove(match.index, match.index + match[0].length);
+		s.appendLeft(0, match[0]);
+	}
+	atCharsetRE.lastIndex = 0;
+	let foundCharset = false;
+	while (match = atCharsetRE.exec(cleanCss)) {
+		s.remove(match.index, match.index + match[0].length);
+		if (!foundCharset) {
+			s.prepend(match[0]);
+			foundCharset = true;
+		}
+	}
+	return s.toString();
+}
+const loadedPreprocessorPath = {};
+function loadPreprocessorPath(lang, root) {
+	const cached = loadedPreprocessorPath[lang];
+	if (cached) return cached;
+	const resolved = nodeResolveWithVite(lang, void 0, { root }) ?? nodeResolveWithVite(lang, _dirname, { root });
+	if (resolved) return loadedPreprocessorPath[lang] = resolved;
+	const installCommand = getPackageManagerCommand("install");
+	throw new Error(`Preprocessor dependency "${lang}" not found. Did you install it? Try \`${installCommand} -D ${lang}\`.`);
+}
+function loadSassPackage(root, skipEmbedded = false) {
+	if (!skipEmbedded) try {
+		return {
+			name: "sass-embedded",
+			path: loadPreprocessorPath("sass-embedded", root)
+		};
+	} catch (e1) {
+		try {
+			return {
+				name: "sass",
+				path: loadPreprocessorPath("sass", root)
+			};
+		} catch {
+			throw e1;
+		}
+	}
+	return {
+		name: "sass",
+		path: loadPreprocessorPath("sass", root)
+	};
+}
+let cachedSss;
+async function loadSss(root) {
+	if (!cachedSss) cachedSss = (async () => {
+		return cachedSss = (await import(pathToFileURL(loadPreprocessorPath("sugarss", root)).href)).default;
+	})();
+	return cachedSss;
+}
+function cleanScssBugUrl(url) {
+	if (typeof window !== "undefined" && typeof location !== "undefined" && typeof location.href === "string") {
+		const prefix = location.href.replace(/\/$/, "");
+		return url.replace(prefix, "");
+	} else return url;
+}
+const makeScssWorker = (environment, resolvers, _maxWorkers) => {
+	let compilerPromise;
+	return {
+		async run(sassPath, data, options) {
+			const sass = await import(sassPath);
+			compilerPromise ??= sass.initAsyncCompiler();
+			const compiler = await compilerPromise;
+			const sassOptions = { ...options };
+			sassOptions.url = pathToFileURL(options.filename);
+			sassOptions.sourceMap = options.enableSourcemap;
+			const skipRebaseUrls = (unquotedUrl, rawUrl) => {
+				if (!(rawUrl[0] === "\"" || rawUrl[0] === "'") && unquotedUrl[0] === "$") return true;
+				return unquotedUrl.startsWith("#{");
+			};
+			const internalImporter = {
+				async canonicalize(url, context) {
+					const importer = context.containingUrl ? fileURLToPath(context.containingUrl) : options.filename;
+					const resolved = await resolvers.sass(environment, url, cleanScssBugUrl(importer));
+					if (resolved && (resolved.endsWith(".css") || resolved.endsWith(".scss") || resolved.endsWith(".sass"))) return pathToFileURL(resolved);
+					return null;
+				},
+				async load(canonicalUrl) {
+					const ext = path.extname(canonicalUrl.pathname);
+					let syntax = "scss";
+					if (ext === ".sass") syntax = "indented";
+					else if (ext === ".css") syntax = "css";
+					const result = await rebaseUrls(environment, fileURLToPath(canonicalUrl), options.filename, resolvers.sass, skipRebaseUrls);
+					return {
+						contents: result.contents ?? await fsp.readFile(result.file, "utf-8"),
+						syntax,
+						sourceMapUrl: canonicalUrl
+					};
+				}
+			};
+			sassOptions.importers = [...sassOptions.importers ?? [], internalImporter];
+			sassOptions.importer ??= internalImporter;
+			const result = await compiler.compileStringAsync(data, sassOptions);
+			return {
+				css: result.css,
+				map: result.sourceMap ? JSON.stringify(result.sourceMap) : void 0,
+				stats: { includedFiles: result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath(url)) }
+			};
+		},
+		async stop() {
+			await (await compilerPromise)?.dispose();
+			compilerPromise = void 0;
+		}
+	};
+};
+const scssProcessor = (maxWorkers) => {
+	let worker;
+	let failedSassEmbedded;
+	const normalizedErrors = /* @__PURE__ */ new WeakSet();
+	return {
+		async close() {
+			await worker?.stop();
+		},
+		async process(environment, source, root, options, resolvers) {
+			let sassPackage = loadSassPackage(root, failedSassEmbedded ?? false);
+			if (failedSassEmbedded === void 0) {
+				failedSassEmbedded = false;
+				try {
+					await import(sassPackage.path);
+				} catch (e) {
+					if (/sass-embedded-[a-z0-9]+-[a-z0-9]+/i.test(e.message)) {
+						failedSassEmbedded = true;
+						sassPackage = loadSassPackage(root, failedSassEmbedded);
+					}
+				}
+			}
+			worker ??= makeScssWorker(environment, resolvers, maxWorkers);
+			const { content: data, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap);
+			const optionsWithoutAdditionalData = {
+				...options,
+				additionalData: void 0
+			};
+			try {
+				const result = await worker.run(pathToFileURL(sassPackage.path).href, data, optionsWithoutAdditionalData);
+				const deps = result.stats.includedFiles.map((f) => cleanScssBugUrl(f));
+				const map = result.map ? JSON.parse(result.map.toString()) : void 0;
+				if (map) map.sources = map.sources.map((url) => url.startsWith("file://") ? normalizePath(fileURLToPath(url)) : url);
+				return {
+					code: result.css.toString(),
+					map,
+					additionalMap,
+					deps
+				};
+			} catch (e) {
+				if (!normalizedErrors.has(e)) {
+					e.message = `[sass] ${e.message}`;
+					e.id = e.file;
+					e.frame = e.formatted;
+					if (e.span?.start) {
+						e.line = e.span.start.line + 1;
+						e.column = e.span.start.column + 1;
+						e.frame = e.message;
+					}
+					normalizedErrors.add(e);
+				}
+				return {
+					code: "",
+					error: e,
+					deps: []
+				};
+			}
+		}
+	};
+};
+/**
+* relative url() inside \@imported sass and less files must be rebased to use
+* root file as base.
+*/
+async function rebaseUrls(environment, file, rootFile, resolver, ignoreUrl) {
+	file = path.resolve(file);
+	const fileDir = path.dirname(file);
+	const rootDir = path.dirname(rootFile);
+	if (fileDir === rootDir) return { file };
+	const content = await fsp.readFile(file, "utf-8");
+	const hasUrls = cssUrlRE.test(content);
+	const hasDataUris = cssDataUriRE.test(content);
+	const hasImportCss = importCssRE.test(content);
+	if (!hasUrls && !hasDataUris && !hasImportCss) return { file };
+	let rebased;
+	const rebaseFn = async (unquotedUrl, rawUrl) => {
+		if (ignoreUrl?.(unquotedUrl, rawUrl)) return false;
+		if (unquotedUrl[0] === "/") return unquotedUrl;
+		const absolute = await resolver(environment, unquotedUrl, file) || path.resolve(fileDir, unquotedUrl);
+		return normalizePath(path.relative(rootDir, absolute));
+	};
+	if (hasImportCss) rebased = await rewriteImportCss(content, rebaseFn);
+	if (hasUrls) rebased = await rewriteCssUrls(rebased || content, rebaseFn);
+	if (hasDataUris) rebased = await rewriteCssDataUris(rebased || content, rebaseFn);
+	return {
+		file,
+		contents: rebased
+	};
+}
+const makeLessWorker = (environment, resolvers, maxWorkers) => {
+	const skipRebaseUrls = (unquotedUrl, _rawUrl) => {
+		return unquotedUrl[0] === "@";
+	};
+	const viteLessResolve = async (filename, dir, rootFile, mime) => {
+		const resolved = await resolvers.less(environment, filename, path.join(dir, "*"));
+		if (!resolved) return void 0;
+		if (mime === "application/javascript") return { resolved: path.resolve(resolved) };
+		const result = await rebaseUrls(environment, resolved, rootFile, resolvers.less, skipRebaseUrls);
+		return {
+			resolved,
+			contents: "contents" in result ? result.contents : void 0
+		};
+	};
+	return new WorkerWithFallback(async () => {
+		const [fsp, path] = await Promise.all([import("node:fs/promises"), import("node:path")]);
+		let ViteLessManager;
+		const createViteLessPlugin = (less, rootFile) => {
+			const { FileManager } = less;
+			ViteLessManager ??= class ViteManager extends FileManager {
+				rootFile;
+				constructor(rootFile) {
+					super();
+					this.rootFile = rootFile;
+				}
+				supports(filename) {
+					return !/^(?:https?:)?\/\//.test(filename);
+				}
+				supportsSync() {
+					return false;
+				}
+				async loadFile(filename, dir, opts, env) {
+					const result = await viteLessResolve(filename, dir, this.rootFile, opts.mime);
+					if (result) return {
+						filename: path.resolve(result.resolved),
+						contents: result.contents ?? await fsp.readFile(result.resolved, "utf-8")
+					};
+					else return super.loadFile(filename, dir, opts, env);
+				}
+			};
+			return {
+				install(_, pluginManager) {
+					pluginManager.addFileManager(new ViteLessManager(rootFile));
+				},
+				minVersion: [
+					3,
+					0,
+					0
+				]
+			};
+		};
+		return async (lessPath, content, options) => {
+			const nodeLess = (await import(lessPath)).default;
+			const viteResolverPlugin = createViteLessPlugin(nodeLess, options.filename);
+			return await nodeLess.render(content, {
+				paths: ["node_modules"],
+				...options,
+				plugins: [viteResolverPlugin, ...options.plugins || []],
+				...options.enableSourcemap ? { sourceMap: {
+					outputSourceFiles: true,
+					disableSourcemapAnnotation: true,
+					sourceMapFileInline: false
+				} } : {}
+			});
+		};
+	}, {
+		parentFunctions: { viteLessResolve },
+		shouldUseFake(_lessPath, _content, options) {
+			return !!options.plugins && options.plugins.length > 0;
+		},
+		max: maxWorkers
+	});
+};
+const lessProcessor = (maxWorkers) => {
+	let worker;
+	return {
+		close() {
+			worker?.stop();
+		},
+		async process(environment, source, root, options, resolvers) {
+			const lessPath = loadPreprocessorPath("less", root);
+			worker ??= makeLessWorker(environment, resolvers, maxWorkers);
+			const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap);
+			let result;
+			const optionsWithoutAdditionalData = {
+				...options,
+				additionalData: void 0
+			};
+			try {
+				result = await worker.run(pathToFileURL(lessPath).href, content, optionsWithoutAdditionalData);
+			} catch (e) {
+				const error = e;
+				const normalizedError = /* @__PURE__ */ new Error(`[less] ${error.message || error.type}`);
+				normalizedError.loc = {
+					file: error.filename || options.filename,
+					line: error.line,
+					column: error.column
+				};
+				return {
+					code: "",
+					error: normalizedError,
+					deps: []
+				};
+			}
+			const map = result.map && JSON.parse(result.map);
+			if (map) delete map.sourcesContent;
+			return {
+				code: result.css.toString(),
+				map,
+				additionalMap,
+				deps: result.imports
+			};
+		}
+	};
+};
+const makeStylWorker = (maxWorkers) => {
+	return new WorkerWithFallback(() => {
+		return async (stylusPath, content, root, options) => {
+			const stylus = (await import(stylusPath)).default;
+			const ref = stylus(content, {
+				paths: ["node_modules"],
+				...options
+			});
+			if (options.define) for (const key in options.define) ref.define(key, options.define[key]);
+			if (options.enableSourcemap) ref.set("sourcemap", {
+				comment: false,
+				inline: false,
+				basePath: root
+			});
+			return {
+				code: ref.render(),
+				map: ref.sourcemap,
+				deps: ref.deps()
+			};
+		};
+	}, {
+		shouldUseFake(_stylusPath, _content, _root, options) {
+			return !!(options.define && Object.values(options.define).some((d) => typeof d === "function") || options.Evaluator);
+		},
+		max: maxWorkers
+	});
+};
+const stylProcessor = (maxWorkers) => {
+	let worker;
+	return {
+		close() {
+			worker?.stop();
+		},
+		async process(_environment, source, root, options, _resolvers) {
+			const stylusPath = loadPreprocessorPath("stylus", root);
+			worker ??= makeStylWorker(maxWorkers);
+			const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap, "\n");
+			const importsDeps = (options.imports ?? []).map((dep) => path.resolve(dep));
+			const optionsWithoutAdditionalData = {
+				...options,
+				additionalData: void 0
+			};
+			try {
+				const { code, map, deps } = await worker.run(pathToFileURL(stylusPath).href, content, root, optionsWithoutAdditionalData);
+				return {
+					code,
+					map: formatStylusSourceMap(map, root),
+					additionalMap,
+					deps: [...deps, ...importsDeps]
+				};
+			} catch (e) {
+				const wrapped = /* @__PURE__ */ new Error(`[stylus] ${e.message}`);
+				wrapped.name = e.name;
+				wrapped.stack = e.stack;
+				return {
+					code: "",
+					error: wrapped,
+					deps: []
+				};
+			}
+		}
+	};
+};
+function formatStylusSourceMap(mapBefore, root) {
+	if (!mapBefore) return void 0;
+	const map = { ...mapBefore };
+	const resolveFromRoot = (p) => normalizePath(path.resolve(root, p));
+	if (map.file) map.file = resolveFromRoot(map.file);
+	map.sources = map.sources.map(resolveFromRoot);
+	return map;
+}
+async function getSource(source, filename, additionalData, enableSourcemap, sep = "") {
+	if (!additionalData) return { content: source };
+	if (typeof additionalData === "function") {
+		const newContent = await additionalData(source, filename);
+		if (typeof newContent === "string") return { content: newContent };
+		return newContent;
+	}
+	if (!enableSourcemap) return { content: additionalData + sep + source };
+	const ms = new MagicString(source);
+	ms.appendLeft(0, sep);
+	ms.appendLeft(0, additionalData);
+	const map = ms.generateMap({ hires: "boundary" });
+	map.file = filename;
+	map.sources = [filename];
+	return {
+		content: ms.toString(),
+		map
+	};
+}
+const createPreprocessorWorkerController = (maxWorkers) => {
+	const scss = scssProcessor(maxWorkers);
+	const less = lessProcessor(maxWorkers);
+	const styl = stylProcessor(maxWorkers);
+	const sassProcess = (environment, source, root, options, resolvers) => {
+		const opts = { ...options };
+		opts.syntax = "indented";
+		return scss.process(environment, source, root, opts, resolvers);
+	};
+	const close = async () => {
+		await Promise.all([
+			less.close(),
+			scss.close(),
+			styl.close()
+		]);
+	};
+	return {
+		["less"]: less.process,
+		["scss"]: scss.process,
+		["sass"]: sassProcess,
+		["styl"]: styl.process,
+		["stylus"]: styl.process,
+		close
+	};
+};
+const normalizeMaxWorkers = (maxWorker) => {
+	if (maxWorker === void 0) return 0;
+	if (maxWorker === true) return void 0;
+	return maxWorker;
+};
+const preprocessorSet = new Set([
+	"less",
+	"sass",
+	"scss",
+	"styl",
+	"stylus"
+]);
+function isPreProcessor(lang) {
+	return lang && preprocessorSet.has(lang);
+}
+const importEsbuild = createCachedImport(() => import("esbuild"));
+const importLightningCSS = createCachedImport(() => import("lightningcss"));
+async function compileLightningCSS(environment, id, src, deps, workerController, urlResolver) {
+	const { config } = environment;
+	const filename = removeDirectQuery(id).replace("\0", NULL_BYTE_PLACEHOLDER);
+	let res;
+	try {
+		res = styleAttrRE.test(id) ? (await importLightningCSS()).transformStyleAttribute({
+			filename,
+			code: Buffer.from(src),
+			targets: config.css.lightningcss?.targets,
+			minify: config.isProduction && !!config.build.cssMinify,
+			analyzeDependencies: true
+		}) : await (await importLightningCSS()).bundleAsync({
+			...config.css.lightningcss,
+			filename,
+			projectRoot: config.root,
+			resolver: {
+				async read(filePath) {
+					if (filePath === filename) return src;
+					const code = fs.readFileSync(filePath, "utf-8");
+					const lang = CSS_LANGS_RE.exec(filePath)?.[1];
+					if (isPreProcessor(lang)) {
+						const result = await compileCSSPreprocessors(environment, id, lang, code, workerController);
+						result.deps?.forEach((dep) => deps.add(dep));
+						return result.code;
+					} else if (lang === "sss") return (await transformSugarSS(environment, id, code)).code;
+					return code;
+				},
+				async resolve(id, from) {
+					const publicFile = checkPublicFile(id, environment.getTopLevelConfig());
+					if (publicFile) return publicFile;
+					const atImportResolvers = getAtImportResolvers(environment.getTopLevelConfig());
+					const lang = CSS_LANGS_RE.exec(from)?.[1];
+					let resolver;
+					switch (lang) {
+						case "css":
+						case "sss":
+						case "styl":
+						case "stylus":
+						case void 0:
+							resolver = atImportResolvers.css;
+							break;
+						case "sass":
+						case "scss":
+							resolver = atImportResolvers.sass;
+							break;
+						case "less":
+							resolver = atImportResolvers.less;
+							break;
+						default: throw new Error(`Unknown lang: ${lang}`);
+					}
+					const resolved = await resolver(environment, id, from);
+					if (resolved) {
+						deps.add(resolved);
+						return resolved;
+					}
+					return id;
+				}
+			},
+			minify: config.isProduction && !!config.build.cssMinify,
+			sourceMap: config.command === "build" ? !!config.build.sourcemap : config.css.devSourcemap,
+			analyzeDependencies: true,
+			cssModules: cssModuleRE.test(id) ? config.css.lightningcss?.cssModules ?? true : void 0
+		});
+	} catch (e) {
+		e.message = `[lightningcss] ${e.message}`;
+		if (e.loc) {
+			e.loc = {
+				file: e.fileName.replace(NULL_BYTE_PLACEHOLDER, "\0"),
+				line: e.loc.line,
+				column: e.loc.column - 1
+			};
+			try {
+				const friendlyMessage = getLightningCssErrorMessageForIeSyntaxes(fs.readFileSync(e.fileName, "utf-8"));
+				if (friendlyMessage) e.message += friendlyMessage;
+			} catch {}
+		}
+		throw e;
+	}
+	for (const warning of res.warnings) {
+		let msg = `[vite:css][lightningcss] ${warning.message}`;
+		msg += `\n${generateCodeFrame(src, {
+			line: warning.loc.line,
+			column: warning.loc.column - 1
+		})}`;
+		environment.logger.warn(import_picocolors.default.yellow(msg));
+	}
+	let css = decoder.decode(res.code);
+	for (const dep of res.dependencies) switch (dep.type) {
+		case "url": {
+			let replaceUrl;
+			if (skipUrlReplacer(dep.url)) replaceUrl = dep.url;
+			else if (urlResolver) {
+				const [newUrl, resolvedId] = await urlResolver(dep.url, dep.loc.filePath.replace(NULL_BYTE_PLACEHOLDER, "\0"));
+				if (resolvedId) deps.add(resolvedId);
+				replaceUrl = newUrl;
+			} else replaceUrl = dep.url;
+			css = css.replace(dep.placeholder, () => replaceUrl.replaceAll("\"", "\\\""));
+			break;
+		}
+		default: throw new Error(`Unsupported dependency type: ${dep.type}`);
+	}
+	let modules;
+	if ("exports" in res && res.exports) {
+		modules = {};
+		const sortedEntries = Object.entries(res.exports).sort((a, b) => a[0].localeCompare(b[0]));
+		for (const [key, value] of sortedEntries) {
+			modules[key] = value.name;
+			for (const c of value.composes) modules[key] += " " + c.name;
+		}
+	}
+	return {
+		code: css,
+		map: "map" in res ? res.map?.toString() : void 0,
+		modules
+	};
+}
+function getLightningCssErrorMessageForIeSyntaxes(code) {
+	const commonIeMessage = ", which was used in the past to support old Internet Explorer versions. This is not a valid CSS syntax and will be ignored by modern browsers. \nWhile this is not supported by LightningCSS, you can set `css.lightningcss.errorRecovery: true` to strip these codes.";
+	if (/[\s;{]\*[a-zA-Z-][\w-]+\s*:/.test(code)) return ".\nThis file contains star property hack (e.g. `*zoom`)" + commonIeMessage;
+	if (/min-width:\s*0\\0/.test(code)) return ".\nThis file contains @media zero hack (e.g. `@media (min-width: 0\\0)`)" + commonIeMessage;
+}
+const map = {
+	chrome: "chrome",
+	edge: "edge",
+	firefox: "firefox",
+	hermes: false,
+	ie: "ie",
+	ios: "ios_saf",
+	node: false,
+	opera: "opera",
+	rhino: false,
+	safari: "safari"
+};
+const esMap = {
+	2015: [
+		"chrome49",
+		"edge13",
+		"safari10",
+		"ios10",
+		"firefox44",
+		"opera36"
+	],
+	2016: [
+		"chrome50",
+		"edge13",
+		"safari10",
+		"ios10",
+		"firefox43",
+		"opera37"
+	],
+	2017: [
+		"chrome58",
+		"edge15",
+		"safari11",
+		"ios11",
+		"firefox52",
+		"opera45"
+	],
+	2018: [
+		"chrome63",
+		"edge79",
+		"safari12",
+		"ios12",
+		"firefox58",
+		"opera50"
+	],
+	2019: [
+		"chrome73",
+		"edge79",
+		"safari12.1",
+		"ios12.1",
+		"firefox64",
+		"opera60"
+	],
+	2020: [
+		"chrome80",
+		"edge80",
+		"safari14.1",
+		"ios14.5",
+		"firefox80",
+		"opera67"
+	],
+	2021: [
+		"chrome85",
+		"edge85",
+		"safari14.1",
+		"ios14.5",
+		"firefox80",
+		"opera71"
+	],
+	2022: [
+		"chrome94",
+		"edge94",
+		"safari16.4",
+		"ios16.4",
+		"firefox93",
+		"opera80"
+	],
+	2023: [
+		"chrome110",
+		"edge110",
+		"safari16.4",
+		"ios16.4",
+		"firefox146",
+		"opera96"
+	],
+	2024: [
+		"chrome119",
+		"edge119",
+		"safari17.4",
+		"ios17.4",
+		"firefox145",
+		"opera105"
+	],
+	2025: [
+		"chrome136",
+		"edge136",
+		"safari26.0",
+		"ios26.0",
+		"firefox138",
+		"opera121"
+	]
+};
+const esRE = /es(6|\d{4})/;
+const versionRE = /\d/;
+const convertTargetsCache = /* @__PURE__ */ new Map();
+const convertTargets = (esbuildTarget) => {
+	if (!esbuildTarget) return {};
+	const cached = convertTargetsCache.get(esbuildTarget);
+	if (cached) return cached;
+	const targets = {};
+	const entriesWithoutES = arraify(esbuildTarget).flatMap((e) => {
+		const match = esRE.exec(e);
+		if (!match) return e;
+		const year = match[1] === "6" ? 2015 : Number(match[1]);
+		if (!esMap[year]) throw new Error(`Unsupported target "${e}"`);
+		return esMap[year];
+	});
+	for (const entry of entriesWithoutES) {
+		if (entry === "esnext") continue;
+		const index = entry.search(versionRE);
+		if (index >= 0) {
+			const browser = map[entry.slice(0, index)];
+			if (browser === false) continue;
+			if (browser) {
+				const [major, minor = 0] = entry.slice(index).split(".").map((v) => parseInt(v, 10));
+				if (!isNaN(major) && !isNaN(minor)) {
+					const version = major << 16 | minor << 8;
+					if (!targets[browser] || version < targets[browser]) targets[browser] = version;
+					continue;
+				}
+			}
+		}
+		throw new Error(`Unsupported target "${entry}"`);
+	}
+	convertTargetsCache.set(esbuildTarget, targets);
+	return targets;
+};
+function resolveLibCssFilename(libOptions, root, packageCache) {
+	if (typeof libOptions.cssFileName === "string") return `${libOptions.cssFileName}.css`;
+	else if (typeof libOptions.fileName === "string") return `${libOptions.fileName}.css`;
+	const packageJson = findNearestMainPackageData(root, packageCache)?.data;
+	const name = packageJson ? getPkgName(packageJson.name) : void 0;
+	if (!name) throw new Error("Name in package.json is required if option \"build.lib.cssFileName\" is not provided.");
+	return `${name}.css`;
+}
+//#endregion
+//#region src/node/plugins/modulePreloadPolyfill.ts
+const modulePreloadPolyfillId = "vite/modulepreload-polyfill";
+const resolvedModulePreloadPolyfillId = "\0" + modulePreloadPolyfillId + ".js";
+function modulePreloadPolyfillPlugin() {
+	return {
+		name: "vite:modulepreload-polyfill",
+		applyToEnvironment(environment) {
+			if (environment.config.isBundled) return viteModulePreloadPolyfillPlugin({ isServer: environment.config.consumer !== "client" });
+			return true;
+		},
+		resolveId: {
+			filter: { id: exactRegex(modulePreloadPolyfillId) },
+			handler(_id) {
+				return resolvedModulePreloadPolyfillId;
+			}
+		},
+		load: {
+			filter: { id: exactRegex(resolvedModulePreloadPolyfillId) },
+			handler(_id) {
+				return "";
+			}
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/html.ts
+var import_escape_html = /* @__PURE__ */ __toESM(require_escape_html(), 1);
+const htmlProxyRE = /[?&]html-proxy=?(?:&inline-css)?(?:&style-attr)?&index=(\d+)\.(?:js|css)$/;
+const isHtmlProxyRE = /[?&]html-proxy\b/;
+const inlineCSSRE = /__VITE_INLINE_CSS__([a-z\d]{8}_\d+)__/g;
+const inlineImportRE = /(?<!(?<!\.\.)\.)\bimport\s*\(("(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*')\)/dg;
+const htmlLangRE = /\.(?:html|htm)$/;
+const spaceRe = /[\t\n\f\r ]/;
+const importMapRE = /[ \t]*<script[^>]*type\s*=\s*(?:"importmap"|'importmap'|importmap)[^>]*>.*?<\/script>/is;
+const importMapAppendRE = new RegExp([/[ \t]*<script[^>]*type\s*=\s*(?:"module"|'module'|module)[^>]*>/i, /[ \t]*<link[^>]*rel\s*=\s*(?:"modulepreload"|'modulepreload'|modulepreload)[\s\S]*?\/>/i].map((r) => r.source).join("|"), "i");
+const isHTMLProxy = (id) => isHtmlProxyRE.test(id);
+const isHTMLRequest = (request) => htmlLangRE.test(request);
+const htmlProxyMap = /* @__PURE__ */ new WeakMap();
+const htmlProxyResult = /* @__PURE__ */ new Map();
+function htmlInlineProxyPlugin(config) {
+	htmlProxyMap.set(config, /* @__PURE__ */ new Map());
+	return {
+		name: "vite:html-inline-proxy",
+		resolveId: {
+			filter: { id: isHtmlProxyRE },
+			handler(id) {
+				return id;
+			}
+		},
+		load: {
+			filter: { id: isHtmlProxyRE },
+			handler(id) {
+				const proxyMatch = htmlProxyRE.exec(id);
+				if (proxyMatch) {
+					const index = Number(proxyMatch[1]);
+					const url = cleanUrl(id).replace(normalizePath(config.root), "");
+					const result = htmlProxyMap.get(config).get(url)?.[index];
+					if (result) return {
+						...result,
+						moduleSideEffects: true
+					};
+					else throw new Error(`No matching HTML proxy module found from ${id}`);
+				}
+			}
+		}
+	};
+}
+function addToHTMLProxyCache(config, filePath, index, result) {
+	if (!htmlProxyMap.get(config)) htmlProxyMap.set(config, /* @__PURE__ */ new Map());
+	if (!htmlProxyMap.get(config).get(filePath)) htmlProxyMap.get(config).set(filePath, []);
+	htmlProxyMap.get(config).get(filePath)[index] = result;
+}
+function addToHTMLProxyTransformResult(hash, code) {
+	htmlProxyResult.set(hash, code);
+}
+const noInlineLinkRels = new Set([
+	"icon",
+	"apple-touch-icon",
+	"apple-touch-startup-image",
+	"manifest"
+]);
+const isAsyncScriptMap = /* @__PURE__ */ new WeakMap();
+function nodeIsElement(node) {
+	return node.nodeName[0] !== "#";
+}
+function traverseNodes(node, visitor) {
+	if (node.nodeName === "template") node = node.content;
+	visitor(node);
+	if (nodeIsElement(node) || node.nodeName === "#document" || node.nodeName === "#document-fragment") node.childNodes.forEach((childNode) => traverseNodes(childNode, visitor));
+}
+async function traverseHtml(html, filePath, warn, visitor) {
+	const { parse, ErrorCodes } = await import("./dist.js");
+	const warnings = {};
+	traverseNodes(parse(html, {
+		scriptingEnabled: false,
+		sourceCodeLocationInfo: true,
+		onParseError: (e) => {
+			handleParseError(e, ErrorCodes, html, filePath, warnings);
+		}
+	}), visitor);
+	for (const message of Object.values(warnings)) warn(import_picocolors.default.yellow(`\n${message}`));
+}
+function getScriptInfo(node) {
+	let src;
+	let srcSourceCodeLocation;
+	let isModule = false;
+	let isAsync = false;
+	let isIgnored = false;
+	for (const p of node.attrs) {
+		if (p.prefix !== void 0) continue;
+		if (p.name === "src") {
+			if (!src) {
+				src = p;
+				srcSourceCodeLocation = node.sourceCodeLocation?.attrs.src;
+			}
+		} else if (p.name === "type" && p.value === "module") isModule = true;
+		else if (p.name === "async") isAsync = true;
+		else if (p.name === "vite-ignore") isIgnored = true;
+	}
+	return {
+		src,
+		srcSourceCodeLocation,
+		isModule,
+		isAsync,
+		isIgnored
+	};
+}
+const attrValueStartRE = /=\s*(.)/;
+function overwriteAttrValue(s, sourceCodeLocation, newValue) {
+	const srcString = s.slice(sourceCodeLocation.startOffset, sourceCodeLocation.endOffset);
+	const valueStart = attrValueStartRE.exec(srcString);
+	if (!valueStart) throw new Error(`[vite:html] internal error, failed to overwrite attribute value`);
+	const wrapOffset = valueStart[1] === "\"" || valueStart[1] === "'" ? 1 : 0;
+	const valueOffset = valueStart.index + valueStart[0].length - 1;
+	s.update(sourceCodeLocation.startOffset + valueOffset + wrapOffset, sourceCodeLocation.endOffset - wrapOffset, newValue);
+	return s;
+}
+function removeViteIgnoreAttr(s, sourceCodeLocation) {
+	const loc = sourceCodeLocation.attrs?.["vite-ignore"];
+	if (loc) s.remove(loc.startOffset, loc.endOffset);
+	return s;
+}
+/**
+* Format parse5 @type {ParserError} to @type {RollupError}
+*/
+function formatParseError(parserError, id, html) {
+	return {
+		code: parserError.code,
+		message: `parse5 error code ${parserError.code}`,
+		frame: generateCodeFrame(html, parserError.startOffset, parserError.endOffset),
+		loc: {
+			file: id,
+			line: parserError.startLine,
+			column: parserError.startCol
+		}
+	};
+}
+function handleParseError(parserError, errorCodes, html, filePath, warnings) {
+	switch (parserError.code) {
+		case errorCodes.missingDoctype: return;
+		case errorCodes.abandonedHeadElementChild: return;
+		case errorCodes.duplicateAttribute: return;
+		case errorCodes.nonVoidHtmlElementStartTagWithTrailingSolidus: return;
+		case errorCodes.unexpectedQuestionMarkInsteadOfTagName: return;
+	}
+	const parseError = formatParseError(parserError, filePath, html);
+	warnings[parseError.code] ??= `Unable to parse HTML; ${parseError.message}\n at ${parseError.loc.file}:${parseError.loc.line}:${parseError.loc.column}\n` + parseError.frame;
+}
+/**
+* Collects CSS files for a chunk by traversing its imports depth-first,
+* using a cache to avoid re-analyzing chunks while still returning the
+* correct files when the same chunk is reached via different entry points.
+*/
+function getCssFilesForChunk(chunk, bundle, analyzedImportedCssFiles, seenChunks = /* @__PURE__ */ new Set(), seenCss = /* @__PURE__ */ new Set()) {
+	if (seenChunks.has(chunk.fileName)) return [];
+	seenChunks.add(chunk.fileName);
+	if (analyzedImportedCssFiles.has(chunk)) {
+		const additionals = analyzedImportedCssFiles.get(chunk).filter((file) => !seenCss.has(file));
+		additionals.forEach((file) => seenCss.add(file));
+		return additionals;
+	}
+	const allFiles = [];
+	const filteredFiles = [];
+	chunk.imports.forEach((file) => {
+		const importee = bundle[file];
+		if (importee?.type === "chunk") {
+			const importeeCss = getCssFilesForChunk(importee, bundle, analyzedImportedCssFiles, seenChunks, seenCss);
+			filteredFiles.push(...importeeCss);
+			if (analyzedImportedCssFiles.has(importee)) allFiles.push(...analyzedImportedCssFiles.get(importee));
+			else allFiles.push(...importeeCss);
+		}
+	});
+	chunk.viteMetadata.importedCss.forEach((file) => {
+		allFiles.push(file);
+		if (!seenCss.has(file)) {
+			seenCss.add(file);
+			filteredFiles.push(file);
+		}
+	});
+	analyzedImportedCssFiles.set(chunk, unique(allFiles));
+	return filteredFiles;
+}
+/**
+* Compiles index.html into an entry js module
+*/
+function buildHtmlPlugin(config) {
+	const [preHooks, normalHooks, postHooks] = resolveHtmlTransforms(config.plugins);
+	preHooks.unshift(injectCspNonceMetaTagHook(config));
+	preHooks.unshift(preImportMapHook(config));
+	preHooks.push(htmlEnvHook(config));
+	postHooks.push(injectNonceAttributeTagHook(config));
+	postHooks.push(postImportMapHook());
+	const processedHtml = perEnvironmentState(() => /* @__PURE__ */ new Map());
+	const isExcludedUrl = (url) => url[0] === "#" || isExternalUrl(url) || isDataUrl(url);
+	isAsyncScriptMap.set(config, /* @__PURE__ */ new Map());
+	return {
+		name: "vite:build-html",
+		applyToEnvironment(environment) {
+			return environment.config.isBundled;
+		},
+		transform: {
+			filter: { id: /\.html$/ },
+			async handler(html, id) {
+				id = normalizePath(id);
+				const relativeUrlPath = normalizePath(path.relative(config.root, id));
+				const publicPath = `/${relativeUrlPath}`;
+				const publicBase = getBaseInHTML(relativeUrlPath, config);
+				const publicToRelative = (filename) => publicBase + filename;
+				const toOutputPublicFilePath = (url) => toOutputFilePathInHtml(url.slice(1), "public", relativeUrlPath, "html", config, publicToRelative);
+				const nodeStartWithLeadingWhitespace = (node) => {
+					const startOffset = node.sourceCodeLocation.startOffset;
+					if (startOffset === 0) return 0;
+					const lineStartOffset = startOffset - node.sourceCodeLocation.startCol;
+					let isLineEmpty = false;
+					try {
+						isLineEmpty = !s.slice(Math.max(0, lineStartOffset), startOffset).trim();
+					} catch {}
+					return isLineEmpty ? lineStartOffset : startOffset;
+				};
+				html = await applyHtmlTransforms(html, preHooks, this, {
+					path: publicPath,
+					filename: id
+				});
+				let js = "";
+				const s = new MagicString(html);
+				const scriptUrls = [];
+				const styleUrls = [];
+				let inlineModuleIndex = -1;
+				let everyScriptIsAsync = true;
+				let someScriptsAreAsync = false;
+				let someScriptsAreDefer = false;
+				const assetUrlsPromises = [];
+				const namedOutput = Object.keys(config.build.rollupOptions.input || {});
+				const processAssetUrl = async (url, shouldInline) => {
+					if (url !== "" && !namedOutput.includes(url) && !namedOutput.includes(removeLeadingSlash(url))) try {
+						return await urlToBuiltUrl(this, url, id, shouldInline);
+					} catch (e) {
+						if (e.code !== "ENOENT") throw e;
+					}
+					return url;
+				};
+				const setModuleSideEffectPromises = [];
+				await traverseHtml(html, id, config.logger.warn, (node) => {
+					if (!nodeIsElement(node)) return;
+					let shouldRemove = false;
+					if (node.nodeName === "script") {
+						const { src, srcSourceCodeLocation, isModule, isAsync, isIgnored } = getScriptInfo(node);
+						if (isIgnored) removeViteIgnoreAttr(s, node.sourceCodeLocation);
+						else {
+							const url = src && src.value;
+							const isPublicFile = !!(url && checkPublicFile(url, config));
+							if (isPublicFile) overwriteAttrValue(s, srcSourceCodeLocation, partialEncodeURIPath(toOutputPublicFilePath(url)));
+							if (isModule) {
+								inlineModuleIndex++;
+								if (url && !isExcludedUrl(url) && !isPublicFile) {
+									setModuleSideEffectPromises.push(this.resolve(url, id).then((resolved) => {
+										if (!resolved) return Promise.reject(/* @__PURE__ */ new Error(`Failed to resolve ${url} from ${id}`));
+										const moduleInfo = this.getModuleInfo(resolved.id);
+										if (moduleInfo) moduleInfo.moduleSideEffects = true;
+										else if (!resolved.external) return this.load({
+											...resolved,
+											moduleSideEffects: true
+										}).then(() => {});
+									}));
+									js += `\nimport ${JSON.stringify(url)}`;
+									shouldRemove = true;
+								} else if (node.childNodes.length) {
+									const contents = node.childNodes.pop().value;
+									addToHTMLProxyCache(config, id.replace(normalizePath(config.root), ""), inlineModuleIndex, { code: contents });
+									js += `\nimport "${id}?html-proxy&index=${inlineModuleIndex}.js"`;
+									shouldRemove = true;
+								}
+								everyScriptIsAsync &&= isAsync;
+								someScriptsAreAsync ||= isAsync;
+								someScriptsAreDefer ||= !isAsync;
+							} else if (url && !isPublicFile) {
+								if (!isExcludedUrl(url)) config.logger.warn(`<script src="${url}"> in "${publicPath}" can't be bundled without type="module" attribute`);
+							} else if (node.childNodes.length) {
+								const scriptNode = node.childNodes.pop();
+								scriptUrls.push(...extractImportExpressionFromClassicScript(scriptNode));
+							}
+						}
+					}
+					const assetAttributes = getNodeAssetAttributes(node);
+					for (const attr of assetAttributes) if (attr.type === "remove") {
+						s.remove(attr.location.startOffset, attr.location.endOffset);
+						continue;
+					} else if (attr.type === "srcset") assetUrlsPromises.push((async () => {
+						const processedEncodedUrl = await processSrcSet(attr.value, async ({ url }) => {
+							const decodedUrl = decodeURIIfPossible(url);
+							if (decodedUrl !== void 0 && !isExcludedUrl(decodedUrl)) {
+								const result = await processAssetUrl(url);
+								return result !== decodedUrl ? encodeURIPath(result) : url;
+							}
+							return url;
+						});
+						if (processedEncodedUrl !== attr.value) overwriteAttrValue(s, attr.location, processedEncodedUrl);
+					})());
+					else if (attr.type === "src") {
+						const url = decodeURIIfPossible(attr.value);
+						if (url === void 0) {} else if (checkPublicFile(url, config)) overwriteAttrValue(s, attr.location, partialEncodeURIPath(toOutputPublicFilePath(url)));
+						else if (!isExcludedUrl(url)) if (node.nodeName === "link" && isCSSRequest(url) && !("media" in attr.attributes || "disabled" in attr.attributes)) {
+							const importExpression = `\nimport ${JSON.stringify(url)}`;
+							styleUrls.push({
+								url,
+								start: nodeStartWithLeadingWhitespace(node),
+								end: node.sourceCodeLocation.endOffset
+							});
+							js += importExpression;
+						} else {
+							const shouldInline = node.nodeName === "link" && attr.attributes.rel && parseRelAttr(attr.attributes.rel).some((v) => noInlineLinkRels.has(v)) ? false : void 0;
+							assetUrlsPromises.push((async () => {
+								const processedUrl = await processAssetUrl(url, shouldInline);
+								if (processedUrl !== url) overwriteAttrValue(s, attr.location, partialEncodeURIPath(processedUrl));
+							})());
+						}
+					}
+					const inlineStyle = findNeedTransformStyleAttribute(node);
+					if (inlineStyle) {
+						inlineModuleIndex++;
+						const code = inlineStyle.attr.value;
+						addToHTMLProxyCache(config, id.replace(normalizePath(config.root), ""), inlineModuleIndex, { code });
+						js += `\nimport "${id}?html-proxy&inline-css&style-attr&index=${inlineModuleIndex}.css"`;
+						const hash = getHash(cleanUrl(id));
+						overwriteAttrValue(s, inlineStyle.location, `__VITE_INLINE_CSS__${hash}_${inlineModuleIndex}__`);
+					}
+					if (node.nodeName === "style" && node.childNodes.length) {
+						const styleNode = node.childNodes.pop();
+						const filePath = id.replace(normalizePath(config.root), "");
+						inlineModuleIndex++;
+						addToHTMLProxyCache(config, filePath, inlineModuleIndex, { code: styleNode.value });
+						js += `\nimport "${id}?html-proxy&inline-css&index=${inlineModuleIndex}.css"`;
+						const hash = getHash(cleanUrl(id));
+						s.update(styleNode.sourceCodeLocation.startOffset, styleNode.sourceCodeLocation.endOffset, `__VITE_INLINE_CSS__${hash}_${inlineModuleIndex}__`);
+					}
+					if (shouldRemove) s.remove(nodeStartWithLeadingWhitespace(node), node.sourceCodeLocation.endOffset);
+				});
+				isAsyncScriptMap.get(config).set(id, everyScriptIsAsync);
+				if (someScriptsAreAsync && someScriptsAreDefer) config.logger.warn(`\nMixed async and defer script modules in ${id}, output script will fallback to defer. Every script, including inline ones, need to be marked as async for your output script to be async.`);
+				await Promise.all(assetUrlsPromises);
+				for (const { start, end, url } of scriptUrls) if (checkPublicFile(url, config)) s.update(start, end, partialEncodeURIPath(toOutputPublicFilePath(url)));
+				else if (!isExcludedUrl(url)) s.update(start, end, partialEncodeURIPath(await urlToBuiltUrl(this, url, id)));
+				const resolvedStyleUrls = await Promise.all(styleUrls.map(async (styleUrl) => ({
+					...styleUrl,
+					resolved: await this.resolve(styleUrl.url, id)
+				})));
+				for (const { start, end, url, resolved } of resolvedStyleUrls) if (resolved == null) {
+					config.logger.warnOnce(`\n${url} doesn't exist at build time, it will remain unchanged to be resolved at runtime`);
+					const importExpression = `\nimport ${JSON.stringify(url)}`;
+					js = js.replace(importExpression, "");
+				} else s.remove(start, end);
+				processedHtml(this).set(id, s.toString());
+				const { modulePreload } = this.environment.config.build;
+				if (modulePreload !== false && modulePreload.polyfill && (someScriptsAreAsync || someScriptsAreDefer)) js = `import "${modulePreloadPolyfillId}";\n${js}`;
+				await Promise.all(setModuleSideEffectPromises);
+				return {
+					code: js,
+					moduleSideEffects: "no-treeshake"
+				};
+			}
+		},
+		async generateBundle(options, bundle) {
+			const analyzedImportedCssFiles = /* @__PURE__ */ new Map();
+			const inlineEntryChunk = /* @__PURE__ */ new Set();
+			const getImportedChunks = (chunk, seen = /* @__PURE__ */ new Set()) => {
+				const chunks = [];
+				chunk.imports.forEach((file) => {
+					const importee = bundle[file];
+					if (importee) {
+						if (importee.type === "chunk" && !seen.has(file)) {
+							seen.add(file);
+							chunks.push(...getImportedChunks(importee, seen));
+							chunks.push(importee);
+						}
+					} else chunks.push(file);
+				});
+				return chunks;
+			};
+			const toScriptTag = (chunkOrUrl, toOutputPath, isAsync) => ({
+				tag: "script",
+				attrs: {
+					...isAsync ? { async: true } : {},
+					type: "module",
+					crossorigin: true,
+					src: typeof chunkOrUrl === "string" ? chunkOrUrl : toOutputPath(chunkOrUrl.fileName)
+				}
+			});
+			const toPreloadTag = (filename, toOutputPath) => ({
+				tag: "link",
+				attrs: {
+					rel: "modulepreload",
+					crossorigin: true,
+					href: toOutputPath(filename)
+				}
+			});
+			const toStyleSheetLinkTag = (file, toOutputPath) => ({
+				tag: "link",
+				attrs: {
+					rel: "stylesheet",
+					crossorigin: true,
+					href: toOutputPath(file)
+				}
+			});
+			const getCssTagsForChunk = (chunk, toOutputPath) => getCssFilesForChunk(chunk, bundle, analyzedImportedCssFiles).map((file) => toStyleSheetLinkTag(file, toOutputPath));
+			for (const [normalizedId, html] of processedHtml(this)) {
+				const relativeUrlPath = normalizePath(path.relative(config.root, normalizedId));
+				const assetsBase = getBaseInHTML(relativeUrlPath, config);
+				const toOutputFilePath = (filename, type) => {
+					if (isExternalUrl(filename)) return filename;
+					else return toOutputFilePathInHtml(filename, type, relativeUrlPath, "html", config, (filename) => assetsBase + filename);
+				};
+				const toOutputAssetFilePath = (filename) => toOutputFilePath(filename, "asset");
+				const toOutputPublicAssetFilePath = (filename) => toOutputFilePath(filename, "public");
+				const isAsync = isAsyncScriptMap.get(config).get(normalizedId);
+				let result = html;
+				const chunk = Object.values(bundle).find((chunk) => chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId && normalizePath(chunk.facadeModuleId) === normalizedId);
+				let canInlineEntry = false;
+				if (chunk) {
+					if (options.format === "es" && isEntirelyImport(chunk.code)) canInlineEntry = true;
+					const imports = getImportedChunks(chunk);
+					let assetTags;
+					if (canInlineEntry) assetTags = imports.map((chunk) => toScriptTag(chunk, toOutputAssetFilePath, isAsync));
+					else {
+						const { modulePreload } = this.environment.config.build;
+						assetTags = [toScriptTag(chunk, toOutputAssetFilePath, isAsync)];
+						if (modulePreload !== false) {
+							const resolveDependencies = typeof modulePreload === "object" && modulePreload.resolveDependencies;
+							const importsFileNames = imports.filter((chunkOrUrl) => typeof chunkOrUrl !== "string").map((chunk) => chunk.fileName);
+							const resolvedDeps = resolveDependencies ? resolveDependencies(chunk.fileName, importsFileNames, {
+								hostId: relativeUrlPath,
+								hostType: "html"
+							}) : importsFileNames;
+							assetTags.push(...resolvedDeps.map((i) => toPreloadTag(i, toOutputAssetFilePath)));
+						}
+					}
+					assetTags.push(...getCssTagsForChunk(chunk, toOutputAssetFilePath));
+					result = injectToHead(result, assetTags);
+				}
+				if (!this.environment.config.build.cssCodeSplit) {
+					const cssBundleName = cssBundleNameCache.get(config);
+					const cssChunk = cssBundleName && Object.values(bundle).find((chunk) => chunk.type === "asset" && chunk.names.includes(cssBundleName));
+					if (cssChunk) result = injectToHead(result, [{
+						tag: "link",
+						attrs: {
+							rel: "stylesheet",
+							crossorigin: true,
+							href: toOutputAssetFilePath(cssChunk.fileName)
+						}
+					}]);
+				}
+				let match;
+				let s;
+				inlineCSSRE.lastIndex = 0;
+				while (match = inlineCSSRE.exec(result)) {
+					s ||= new MagicString(result);
+					const { 0: full, 1: scopedName } = match;
+					const cssTransformedCode = htmlProxyResult.get(scopedName);
+					s.update(match.index, match.index + full.length, cssTransformedCode);
+				}
+				if (s) result = s.toString();
+				result = await applyHtmlTransforms(result, [...normalHooks, ...postHooks], this, {
+					path: "/" + relativeUrlPath,
+					filename: normalizedId,
+					bundle,
+					chunk
+				});
+				result = result.replace(assetUrlRE, (_, fileHash, postfix = "") => {
+					const file = this.getFileName(fileHash);
+					if (chunk) chunk.viteMetadata.importedAssets.add(cleanUrl(file));
+					return encodeURIPath(toOutputAssetFilePath(file)) + postfix;
+				});
+				result = result.replace(publicAssetUrlRE, (_, fileHash) => {
+					const publicAssetPath = toOutputPublicAssetFilePath(getPublicAssetFilename(fileHash, config));
+					return encodeURIPath(URL$1.canParse(publicAssetPath) ? publicAssetPath : normalizePath(publicAssetPath));
+				});
+				if (chunk && canInlineEntry) inlineEntryChunk.add(chunk.fileName);
+				const shortEmitName = normalizePath(path.relative(config.root, normalizedId));
+				this.emitFile({
+					type: "asset",
+					originalFileName: normalizedId,
+					fileName: shortEmitName,
+					source: result
+				});
+			}
+			for (const fileName of inlineEntryChunk) delete bundle[fileName];
+		}
+	};
+}
+function parseRelAttr(attr) {
+	return attr.split(spaceRe).map((v) => v.toLowerCase());
+}
+function findNeedTransformStyleAttribute(node) {
+	const attr = node.attrs.find((prop) => prop.prefix === void 0 && prop.name === "style" && (prop.value.includes("url(") || prop.value.includes("image-set(")));
+	if (!attr) return void 0;
+	return {
+		attr,
+		location: node.sourceCodeLocation?.attrs?.style
+	};
+}
+function extractImportExpressionFromClassicScript(scriptTextNode) {
+	const startOffset = scriptTextNode.sourceCodeLocation.startOffset;
+	const cleanCode = stripLiteral(scriptTextNode.value);
+	const scriptUrls = [];
+	let match;
+	inlineImportRE.lastIndex = 0;
+	while (match = inlineImportRE.exec(cleanCode)) {
+		const [, [urlStart, urlEnd]] = match.indices;
+		const start = urlStart + 1;
+		const end = urlEnd - 1;
+		scriptUrls.push({
+			start: start + startOffset,
+			end: end + startOffset,
+			url: scriptTextNode.value.slice(start, end)
+		});
+	}
+	return scriptUrls;
+}
+function preImportMapHook(config) {
+	return (html, ctx) => {
+		const importMapIndex = html.search(importMapRE);
+		if (importMapIndex < 0) return;
+		const importMapAppendIndex = html.search(importMapAppendRE);
+		if (importMapAppendIndex < 0) return;
+		if (importMapAppendIndex < importMapIndex) {
+			const relativeHtml = normalizePath(path.relative(config.root, ctx.filename));
+			config.logger.warnOnce(import_picocolors.default.yellow(import_picocolors.default.bold(`(!) <script type="importmap"> should come before <script type="module"> and <link rel="modulepreload"> in /${relativeHtml}`)));
+		}
+	};
+}
+/**
+* Move importmap before the first module script and modulepreload link
+*/
+function postImportMapHook() {
+	return (html) => {
+		if (!importMapAppendRE.test(html)) return;
+		let importMap;
+		html = html.replace(importMapRE, (match) => {
+			importMap = match;
+			return "";
+		});
+		if (importMap) html = html.replace(importMapAppendRE, (match) => `${importMap}\n${match}`);
+		return html;
+	};
+}
+function injectCspNonceMetaTagHook(config) {
+	return () => {
+		if (!config.html?.cspNonce) return;
+		return [{
+			tag: "meta",
+			injectTo: "head",
+			attrs: {
+				property: "csp-nonce",
+				nonce: config.html.cspNonce
+			}
+		}];
+	};
+}
+/**
+* Support `%ENV_NAME%` syntax in html files
+*/
+function htmlEnvHook(config) {
+	const pattern = /%(\S+?)%/g;
+	const envPrefix = resolveEnvPrefix({ envPrefix: config.envPrefix });
+	const env = { ...config.env };
+	for (const key in config.define) if (key.startsWith(`import.meta.env.`)) {
+		const val = config.define[key];
+		if (typeof val === "string") try {
+			const parsed = JSON.parse(val);
+			env[key.slice(16)] = typeof parsed === "string" ? parsed : val;
+		} catch {
+			env[key.slice(16)] = val;
+		}
+		else env[key.slice(16)] = JSON.stringify(val);
+	}
+	return (html, ctx) => {
+		return html.replace(pattern, (text, key) => {
+			if (key in env) return env[key];
+			else {
+				if (envPrefix.some((prefix) => key.startsWith(prefix))) {
+					const relativeHtml = normalizePath(path.relative(config.root, ctx.filename));
+					config.logger.warn(import_picocolors.default.yellow(import_picocolors.default.bold(`(!) ${text} is not defined in env variables found in /${relativeHtml}. Is the variable mistyped?`)));
+				}
+				return text;
+			}
+		});
+	};
+}
+function injectNonceAttributeTagHook(config) {
+	const processRelType = new Set([
+		"stylesheet",
+		"modulepreload",
+		"preload"
+	]);
+	return async (html, { filename }) => {
+		const nonce = config.html?.cspNonce;
+		if (!nonce) return;
+		const s = new MagicString(html);
+		await traverseHtml(html, filename, config.logger.warn, (node) => {
+			if (!nodeIsElement(node)) return;
+			const { nodeName, attrs, sourceCodeLocation } = node;
+			if (nodeName === "script" || nodeName === "style" || nodeName === "link" && attrs.some((attr) => attr.name === "rel" && parseRelAttr(attr.value).some((a) => processRelType.has(a)))) {
+				if (attrs.some(({ name }) => name === "nonce")) return;
+				const startTagEndOffset = sourceCodeLocation.startTag.endOffset;
+				const appendOffset = html[startTagEndOffset - 2] === "/" ? 2 : 1;
+				s.appendRight(startTagEndOffset - appendOffset, ` nonce="${nonce}"`);
+			}
+		});
+		return s.toString();
+	};
+}
+function resolveHtmlTransforms(plugins) {
+	const preHooks = [];
+	const normalHooks = [];
+	const postHooks = [];
+	for (const plugin of plugins) {
+		const hook = plugin.transformIndexHtml;
+		if (!hook) continue;
+		if (typeof hook === "function") normalHooks.push(hook);
+		else {
+			const handler = hook.handler;
+			if (hook.order === "pre") preHooks.push(handler);
+			else if (hook.order === "post") postHooks.push(handler);
+			else normalHooks.push(handler);
+		}
+	}
+	return [
+		preHooks,
+		normalHooks,
+		postHooks
+	];
+}
+const elementsAllowedInHead = new Set([
+	"title",
+	"base",
+	"link",
+	"style",
+	"meta",
+	"script",
+	"noscript",
+	"template"
+]);
+function headTagInsertCheck(tags, ctx) {
+	if (!tags.length) return;
+	const { logger } = ctx.server?.config || {};
+	const disallowedTags = tags.filter((tagDescriptor) => !elementsAllowedInHead.has(tagDescriptor.tag));
+	if (disallowedTags.length) {
+		const dedupedTags = unique(disallowedTags.map((tagDescriptor) => `<${tagDescriptor.tag}>`));
+		logger?.warn(import_picocolors.default.yellow(import_picocolors.default.bold(`[${dedupedTags.join(",")}] can not be used inside the <head> Element, please check the 'injectTo' value`)));
+	}
+}
+async function applyHtmlTransforms(html, hooks, pluginContext, ctx) {
+	for (const hook of hooks) {
+		const res = await hook.call(pluginContext, html, ctx);
+		if (!res) continue;
+		if (typeof res === "string") html = res;
+		else {
+			let tags;
+			if (Array.isArray(res)) tags = res;
+			else {
+				html = res.html || html;
+				tags = res.tags;
+			}
+			let headTags;
+			let headPrependTags;
+			let bodyTags;
+			let bodyPrependTags;
+			for (const tag of tags) switch (tag.injectTo) {
+				case "body":
+					(bodyTags ??= []).push(tag);
+					break;
+				case "body-prepend":
+					(bodyPrependTags ??= []).push(tag);
+					break;
+				case "head":
+					(headTags ??= []).push(tag);
+					break;
+				default: (headPrependTags ??= []).push(tag);
+			}
+			headTagInsertCheck([...headTags || [], ...headPrependTags || []], ctx);
+			if (headPrependTags) html = injectToHead(html, headPrependTags, true);
+			if (headTags) html = injectToHead(html, headTags);
+			if (bodyPrependTags) html = injectToBody(html, bodyPrependTags, true);
+			if (bodyTags) html = injectToBody(html, bodyTags);
+		}
+	}
+	return html;
+}
+const entirelyImportRE = /^(?:import\s*(?:"[^"\n]*[^\\\n]"|'[^'\n]*[^\\\n]');*|\/\*[\s\S]*?\*\/|\/\/.*[$\n])*$/;
+function isEntirelyImport(code) {
+	return entirelyImportRE.test(code.trim());
+}
+function getBaseInHTML(urlRelativePath, config) {
+	return config.base === "./" || config.base === "" ? path.posix.join(path.posix.relative(urlRelativePath, "").slice(0, -2), "./") : config.base;
+}
+const headInjectRE = /([ \t]*)<\/head>/i;
+const headPrependInjectRE = /([ \t]*)<head[^>]*>/i;
+const htmlInjectRE = /<\/html>/i;
+const htmlPrependInjectRE = /([ \t]*)<html[^>]*>/i;
+const bodyInjectRE = /([ \t]*)<\/body>/i;
+const bodyPrependInjectRE = /([ \t]*)<body[^>]*>/i;
+const doctypePrependInjectRE = /<!doctype html>/i;
+function injectToHead(html, tags, prepend = false) {
+	if (tags.length === 0) return html;
+	if (prepend) {
+		if (headPrependInjectRE.test(html)) return html.replace(headPrependInjectRE, (match, p1) => `${match}\n${serializeTags(tags, incrementIndent(p1))}`);
+	} else {
+		if (headInjectRE.test(html)) return html.replace(headInjectRE, (match, p1) => `${serializeTags(tags, incrementIndent(p1))}${match}`);
+		if (bodyPrependInjectRE.test(html)) return html.replace(bodyPrependInjectRE, (match, p1) => `${serializeTags(tags, p1)}\n${match}`);
+	}
+	return prependInjectFallback(html, tags);
+}
+function injectToBody(html, tags, prepend = false) {
+	if (tags.length === 0) return html;
+	if (prepend) {
+		if (bodyPrependInjectRE.test(html)) return html.replace(bodyPrependInjectRE, (match, p1) => `${match}\n${serializeTags(tags, incrementIndent(p1))}`);
+		if (headInjectRE.test(html)) return html.replace(headInjectRE, (match, p1) => `${match}\n${serializeTags(tags, p1)}`);
+		return prependInjectFallback(html, tags);
+	} else {
+		if (bodyInjectRE.test(html)) return html.replace(bodyInjectRE, (match, p1) => `${serializeTags(tags, incrementIndent(p1))}${match}`);
+		if (htmlInjectRE.test(html)) return html.replace(htmlInjectRE, `${serializeTags(tags)}\n$&`);
+		return html + `\n` + serializeTags(tags);
+	}
+}
+function prependInjectFallback(html, tags) {
+	if (htmlPrependInjectRE.test(html)) return html.replace(htmlPrependInjectRE, `$&\n${serializeTags(tags)}`);
+	if (doctypePrependInjectRE.test(html)) return html.replace(doctypePrependInjectRE, `$&\n${serializeTags(tags)}`);
+	return serializeTags(tags) + html;
+}
+const unaryTags = new Set([
+	"link",
+	"meta",
+	"base"
+]);
+function serializeTag({ tag, attrs, children }, indent = "") {
+	if (unaryTags.has(tag)) return `<${tag}${serializeAttrs(attrs)}>`;
+	else return `<${tag}${serializeAttrs(attrs)}>${serializeTags(children, incrementIndent(indent))}</${tag}>`;
+}
+function serializeTags(tags, indent = "") {
+	if (typeof tags === "string") return tags;
+	else if (tags && tags.length) return tags.map((tag) => `${indent}${serializeTag(tag, indent)}\n`).join("");
+	return "";
+}
+function serializeAttrs(attrs) {
+	let res = "";
+	for (const key in attrs) if (typeof attrs[key] === "boolean") res += attrs[key] ? ` ${key}` : ``;
+	else res += ` ${key}="${(0, import_escape_html.default)(attrs[key])}"`;
+	return res;
+}
+function incrementIndent(indent = "") {
+	return `${indent}${indent[0] === "	" ? "	" : "  "}`;
+}
+//#endregion
+//#region src/node/plugins/define.ts
+const nonJsRe = /\.json(?:$|\?)/;
+const isNonJsRequest = (request) => nonJsRe.test(request);
+const escapedDotRE = /(?<!\\)\\./g;
+function definePlugin(config) {
+	const isBuild = config.command === "build";
+	const isBuildLib = isBuild && config.build.lib;
+	const processEnv = {};
+	if (!isBuildLib) {
+		const nodeEnv = process.env.NODE_ENV || config.mode;
+		Object.assign(processEnv, {
+			"process.env": `{}`,
+			"global.process.env": `{}`,
+			"globalThis.process.env": `{}`,
+			"process.env.NODE_ENV": JSON.stringify(nodeEnv),
+			"global.process.env.NODE_ENV": JSON.stringify(nodeEnv),
+			"globalThis.process.env.NODE_ENV": JSON.stringify(nodeEnv)
+		});
+	}
+	function generatePattern(environment) {
+		const isBundled = environment.config.isBundled;
+		const keepProcessEnv = environment.config.keepProcessEnv;
+		const importMetaKeys = {};
+		const importMetaEnvKeys = {};
+		const importMetaFallbackKeys = {};
+		if (isBuild) importMetaKeys["import.meta.hot"] = `undefined`;
+		if (isBundled) {
+			for (const key in config.env) {
+				const val = JSON.stringify(config.env[key]);
+				importMetaKeys[`import.meta.env.${key}`] = val;
+				importMetaEnvKeys[key] = val;
+			}
+			importMetaKeys["import.meta.env.SSR"] = `undefined`;
+			importMetaFallbackKeys["import.meta.env"] = `undefined`;
+		}
+		const userDefine = {};
+		const userDefineEnv = {};
+		for (const key in environment.config.define) {
+			userDefine[key] = handleDefineValue(environment.config.define[key]);
+			if (isBuild && key.startsWith("import.meta.env.")) userDefineEnv[key.slice(16)] = environment.config.define[key];
+		}
+		const define = {
+			...keepProcessEnv ? {} : processEnv,
+			...importMetaKeys,
+			...userDefine,
+			...importMetaFallbackKeys
+		};
+		const ssr = environment.config.consumer === "server";
+		if ("import.meta.env.SSR" in define) define["import.meta.env.SSR"] = ssr + "";
+		const importMetaEnvVal = serializeDefine({
+			...importMetaEnvKeys,
+			SSR: ssr + "",
+			...userDefineEnv
+		});
+		const patternKeys = Object.keys(userDefine);
+		if (!keepProcessEnv && Object.keys(processEnv).length) patternKeys.push("process.env");
+		if (Object.keys(importMetaKeys).length) patternKeys.push("import.meta.env", "import.meta.hot");
+		return [
+			define,
+			patternKeys.length ? new RegExp(patternKeys.map((key) => escapeRegex(key).replaceAll(escapedDotRE, "\\??\\.")).join("|")) : null,
+			importMetaEnvVal
+		];
+	}
+	const patternsCache = /* @__PURE__ */ new WeakMap();
+	function getPattern(environment) {
+		let pattern = patternsCache.get(environment);
+		if (!pattern) {
+			pattern = generatePattern(environment);
+			patternsCache.set(environment, pattern);
+		}
+		return pattern;
+	}
+	return {
+		name: "vite:define",
+		applyToEnvironment(environment) {
+			if (environment.config.isBundled) return {
+				name: "vite:define",
+				options(option) {
+					const [define, _pattern, importMetaEnvVal] = getPattern(this.environment);
+					define["import.meta.env"] = importMetaEnvVal;
+					define["import.meta.env.*"] = "undefined";
+					option.transform ??= {};
+					option.transform.define = {
+						...option.transform.define,
+						...define
+					};
+				}
+			};
+			return true;
+		},
+		transform: { handler(code, id) {
+			if (this.environment.config.consumer === "client") return;
+			if (isHTMLRequest(id) || isCSSRequest(id) || isNonJsRequest(id) || config.assetsInclude(id)) return;
+			const [define, pattern] = getPattern(this.environment);
+			if (!pattern) return;
+			pattern.lastIndex = 0;
+			if (!pattern.test(code)) return;
+			return replaceDefine(this.environment, code, id, define);
+		} }
+	};
+}
+function replaceDefine(environment, code, id, define) {
+	const result = transformSync(id, code, {
+		lang: "js",
+		sourceType: "module",
+		define,
+		sourcemap: environment.config.command === "build" ? !!environment.config.build.sourcemap : true,
+		tsconfig: false
+	});
+	if (result.errors.length > 0) throw new AggregateError(result.errors, "oxc transform error");
+	return {
+		code: result.code,
+		map: result.map || null
+	};
+}
+/**
+* Like `JSON.stringify` but keeps raw string values as a literal
+* in the generated code. For example: `"window"` would refer to
+* the global `window` object directly.
+*/
+function serializeDefine(define) {
+	let res = `{`;
+	const keys = Object.keys(define).sort();
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		const val = define[key];
+		res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`;
+		if (i !== keys.length - 1) res += `, `;
+	}
+	return res + `}`;
+}
+function handleDefineValue(value) {
+	if (typeof value === "undefined") return "undefined";
+	if (typeof value === "string") return value;
+	return JSON.stringify(value);
+}
+//#endregion
+//#region src/node/plugins/clientInjections.ts
+const normalizedClientEntry$1 = normalizePath(CLIENT_ENTRY);
+const normalizedEnvEntry$1 = normalizePath(ENV_ENTRY);
+/**
+* some values used by the client needs to be dynamically injected by the server
+* @server-only
+*/
+function clientInjectionsPlugin(config) {
+	let injectConfigValues;
+	const getDefineReplacer = perEnvironmentState((environment) => {
+		const userDefine = {};
+		for (const key in environment.config.define) if (!key.startsWith("import.meta.env.")) userDefine[key] = environment.config.define[key];
+		const serializedDefines = serializeDefine(userDefine);
+		const definesReplacement = () => serializedDefines;
+		return (code) => code.replace(`__DEFINES__`, definesReplacement);
+	});
+	return {
+		name: "vite:client-inject",
+		applyToEnvironment(environment) {
+			return !environment.config.isBundled;
+		},
+		async buildStart() {
+			injectConfigValues = await createClientConfigValueReplacer(config);
+		},
+		transform(code, id) {
+			const ssr = this.environment.config.consumer === "server";
+			const cleanId = cleanUrl(id);
+			if (cleanId === normalizedClientEntry$1 || cleanId === normalizedEnvEntry$1) return getDefineReplacer(this)(injectConfigValues(code));
+			else if (!ssr && code.includes("process.env.NODE_ENV")) {
+				const nodeEnv = this.environment.config.define?.["process.env.NODE_ENV"] || JSON.stringify(process.env.NODE_ENV || config.mode);
+				return replaceDefine(this.environment, code, id, {
+					"process.env.NODE_ENV": nodeEnv,
+					"global.process.env.NODE_ENV": nodeEnv,
+					"globalThis.process.env.NODE_ENV": nodeEnv
+				});
+			}
+		}
+	};
+}
+function escapeReplacement(value) {
+	const jsonValue = JSON.stringify(value);
+	return () => jsonValue;
+}
+async function createClientConfigValueReplacer(config) {
+	const resolvedServerHostname = (await resolveHostname(config.server.host)).name;
+	const resolvedServerPort = config.server.port;
+	const devBase = config.base;
+	const serverHost = `${resolvedServerHostname}:${resolvedServerPort}${devBase}`;
+	let hmrConfig = config.server.hmr;
+	hmrConfig = isObject$1(hmrConfig) ? hmrConfig : void 0;
+	const host = hmrConfig?.host || null;
+	const protocol = hmrConfig?.protocol || null;
+	const timeout = hmrConfig?.timeout || 3e4;
+	const overlay = hmrConfig?.overlay !== false;
+	const isHmrServerSpecified = !!hmrConfig?.server;
+	const hmrConfigName = path.basename(config.configFile || "vite.config.js");
+	let port = hmrConfig?.clientPort || hmrConfig?.port || null;
+	if (config.server.middlewareMode && !isHmrServerSpecified) port ||= 24678;
+	let directTarget = hmrConfig?.host || resolvedServerHostname;
+	directTarget += `:${hmrConfig?.port || resolvedServerPort}`;
+	directTarget += devBase;
+	let hmrBase = devBase;
+	if (hmrConfig?.path) hmrBase = path.posix.join(hmrBase, hmrConfig.path);
+	const modeReplacement = escapeReplacement(config.mode);
+	const baseReplacement = escapeReplacement(devBase);
+	const serverHostReplacement = escapeReplacement(serverHost);
+	const hmrProtocolReplacement = escapeReplacement(protocol);
+	const hmrHostnameReplacement = escapeReplacement(host);
+	const hmrPortReplacement = escapeReplacement(port);
+	const hmrDirectTargetReplacement = escapeReplacement(directTarget);
+	const hmrBaseReplacement = escapeReplacement(hmrBase);
+	const hmrTimeoutReplacement = escapeReplacement(timeout);
+	const hmrEnableOverlayReplacement = escapeReplacement(overlay);
+	const hmrConfigNameReplacement = escapeReplacement(hmrConfigName);
+	const wsTokenReplacement = escapeReplacement(config.webSocketToken);
+	const serverForwardConsoleReplacement = escapeReplacement(config.server.forwardConsole);
+	const bundleDevReplacement = escapeReplacement(config.experimental.bundledDev || false);
+	return (code) => code.replace(`__MODE__`, modeReplacement).replace(/__BASE__/g, baseReplacement).replace(`__SERVER_HOST__`, serverHostReplacement).replace(`__HMR_PROTOCOL__`, hmrProtocolReplacement).replace(`__HMR_HOSTNAME__`, hmrHostnameReplacement).replace(`__HMR_PORT__`, hmrPortReplacement).replace(`__HMR_DIRECT_TARGET__`, hmrDirectTargetReplacement).replace(`__HMR_BASE__`, hmrBaseReplacement).replace(`__HMR_TIMEOUT__`, hmrTimeoutReplacement).replace(`__HMR_ENABLE_OVERLAY__`, hmrEnableOverlayReplacement).replace(`__HMR_CONFIG_NAME__`, hmrConfigNameReplacement).replace(`__WS_TOKEN__`, wsTokenReplacement).replace(`__SERVER_FORWARD_CONSOLE__`, serverForwardConsoleReplacement).replaceAll(`__BUNDLED_DEV__`, bundleDevReplacement);
+}
+async function getHmrImplementation(config) {
+	const content = fs.readFileSync(normalizedClientEntry$1, "utf-8");
+	return (await createClientConfigValueReplacer(config))(content).replace(/import\s*['"]@vite\/env['"]/, "");
+}
+//#endregion
+//#region src/node/ssr/fetchModule.ts
+/**
+* Fetch module information for Vite module runner.
+* @experimental
+*/
+async function fetchModule(environment, url, importer, options = {}) {
+	if (url.startsWith("data:") || isBuiltin(environment.config.resolve.builtins, url)) return {
+		externalize: url,
+		type: "builtin"
+	};
+	const isFileUrl = url.startsWith("file://");
+	if (isExternalUrl(url) && !isFileUrl) return {
+		externalize: url,
+		type: "network"
+	};
+	if (!isFileUrl && importer && url[0] !== "." && url[0] !== "/") {
+		const { isProduction, root } = environment.config;
+		const { externalConditions, dedupe, preserveSymlinks } = environment.config.resolve;
+		const resolved = tryNodeResolve(url, importer, {
+			mainFields: ["main"],
+			conditions: externalConditions,
+			externalConditions,
+			external: [],
+			noExternal: [],
+			extensions: [
+				".js",
+				".cjs",
+				".json"
+			],
+			dedupe,
+			preserveSymlinks,
+			tsconfigPaths: false,
+			isBuild: false,
+			isProduction,
+			root,
+			packageCache: environment.config.packageCache,
+			builtins: environment.config.resolve.builtins
+		});
+		if (!resolved) {
+			const err = /* @__PURE__ */ new Error(`Cannot find module '${url}' imported from '${importer}'`);
+			err.code = "ERR_MODULE_NOT_FOUND";
+			throw err;
+		}
+		return {
+			externalize: pathToFileURL(resolved.id).toString(),
+			type: isFilePathESM(resolved.id, environment.config.packageCache) ? "module" : "commonjs"
+		};
+	}
+	url = unwrapId(url);
+	const mod = await environment.moduleGraph.ensureEntryFromUrl(url);
+	const cached = !!mod.transformResult;
+	if (options.cached && cached) return { cache: true };
+	let result = await environment.transformRequest(url);
+	if (!result) throw new Error(`[vite] transform failed for module '${url}'${importer ? ` imported from '${importer}'` : ""}.`);
+	if (options.inlineSourceMap !== false) result = inlineSourceMap(mod, result, options.startOffset);
+	if (result.code[0] === "#") result.code = result.code.replace(/^#!.*/, (s) => " ".repeat(s.length));
+	return {
+		code: result.code,
+		file: mod.file,
+		id: mod.id,
+		url: mod.url,
+		invalidate: !cached
+	};
+}
+const OTHER_SOURCE_MAP_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`, "gm");
+function inlineSourceMap(mod, result, startOffset) {
+	const map = result.map;
+	let code = result.code;
+	if (!map || !("version" in map) || code.includes("//# sourceMappingSource=vite-generated")) return result;
+	OTHER_SOURCE_MAP_REGEXP.lastIndex = 0;
+	if (OTHER_SOURCE_MAP_REGEXP.test(code)) code = code.replace(OTHER_SOURCE_MAP_REGEXP, "");
+	const sourceMap = startOffset ? Object.assign({}, map, { mappings: ";".repeat(startOffset) + map.mappings }) : map;
+	result.code = `${code.trimEnd()}\n//# sourceURL=${mod.id}\n${MODULE_RUNNER_SOURCEMAPPING_SOURCE}\n//# ${SOURCEMAPPING_URL}=${genSourceMapUrl(sourceMap)}\n`;
+	return result;
+}
+//#endregion
+//#region src/node/optimizer/optimizer.ts
+const debug$9 = createDebugger("vite:deps");
+/**
+* The amount to wait for requests to register newly found dependencies before triggering
+* a re-bundle + page reload
+*/
+const debounceMs = 100;
+function createDepsOptimizer(environment) {
+	const { logger } = environment;
+	const sessionTimestamp = Date.now().toString();
+	let debounceProcessingHandle;
+	let closed = false;
+	const options = environment.config.optimizeDeps;
+	const { noDiscovery, holdUntilCrawlEnd } = options;
+	let metadata = initDepsOptimizerMetadata(environment, sessionTimestamp);
+	const depsOptimizer = {
+		init,
+		metadata,
+		registerMissingImport,
+		run: () => debouncedProcessing(0),
+		isOptimizedDepFile: createIsOptimizedDepFile(environment),
+		isOptimizedDepUrl: createIsOptimizedDepUrl(environment),
+		getOptimizedDepId: (depInfo) => `${depInfo.file}?v=${depInfo.browserHash}`,
+		close,
+		options
+	};
+	let newDepsDiscovered = false;
+	let newDepsToLog = [];
+	let newDepsToLogHandle;
+	const logNewlyDiscoveredDeps = () => {
+		if (newDepsToLog.length) {
+			logger.info(import_picocolors.default.green(`✨ new dependencies optimized: ${depsLogString(newDepsToLog)}`), { timestamp: true });
+			newDepsToLog = [];
+		}
+	};
+	let discoveredDepsWhileScanning = [];
+	const logDiscoveredDepsWhileScanning = () => {
+		if (discoveredDepsWhileScanning.length) {
+			logger.info(import_picocolors.default.green(`✨ discovered while scanning: ${depsLogString(discoveredDepsWhileScanning)}`), { timestamp: true });
+			discoveredDepsWhileScanning = [];
+		}
+	};
+	let depOptimizationProcessing = promiseWithResolvers();
+	let depOptimizationProcessingQueue = [];
+	const resolveEnqueuedProcessingPromises = () => {
+		for (const processing of depOptimizationProcessingQueue) processing.resolve();
+		depOptimizationProcessingQueue = [];
+	};
+	let enqueuedRerun;
+	let currentlyProcessing = false;
+	let firstRunCalled = false;
+	let warnAboutMissedDependencies = false;
+	let waitingForCrawlEnd = false;
+	let optimizationResult;
+	let discover;
+	async function close() {
+		closed = true;
+		await Promise.allSettled([
+			discover?.cancel(),
+			depsOptimizer.scanProcessing,
+			optimizationResult?.cancel()
+		]);
+	}
+	let inited = false;
+	async function init() {
+		if (inited) return;
+		inited = true;
+		const cachedMetadata = await loadCachedDepOptimizationMetadata(environment);
+		firstRunCalled = !!cachedMetadata;
+		metadata = depsOptimizer.metadata = cachedMetadata || initDepsOptimizerMetadata(environment, sessionTimestamp);
+		if (!cachedMetadata) {
+			waitingForCrawlEnd = true;
+			currentlyProcessing = true;
+			const manuallyIncludedDeps = {};
+			await addManuallyIncludedOptimizeDeps(environment, manuallyIncludedDeps);
+			const manuallyIncludedDepsInfo = toDiscoveredDependencies(environment, manuallyIncludedDeps, sessionTimestamp);
+			for (const depInfo of Object.values(manuallyIncludedDepsInfo)) {
+				addOptimizedDepInfo(metadata, "discovered", {
+					...depInfo,
+					processing: depOptimizationProcessing.promise
+				});
+				newDepsDiscovered = true;
+			}
+			environment.waitForRequestsIdle().then(onCrawlEnd);
+			if (noDiscovery) runOptimizer();
+			else depsOptimizer.scanProcessing = new Promise((resolve) => {
+				(async () => {
+					try {
+						debug$9?.(import_picocolors.default.green(`scanning for dependencies...`));
+						const scanTimer = setTimeout(() => {
+							logger.info("[optimizer] scanning dependencies...", { timestamp: true });
+						}, 1e3);
+						let deps;
+						try {
+							discover = discoverProjectDependencies(devToScanEnvironment(environment));
+							deps = await discover.result;
+							discover = void 0;
+						} catch (e) {
+							environment.logger.error(import_picocolors.default.red("(!) Failed to run dependency scan. Skipping dependency pre-bundling. " + e.stack));
+							return;
+						} finally {
+							clearTimeout(scanTimer);
+						}
+						const manuallyIncluded = Object.keys(manuallyIncludedDepsInfo);
+						discoveredDepsWhileScanning.push(...Object.keys(metadata.discovered).filter((dep) => !deps[dep] && !manuallyIncluded.includes(dep)));
+						for (const id of Object.keys(deps)) if (!metadata.discovered[id]) addMissingDep(id, deps[id]);
+						const knownDeps = prepareKnownDeps();
+						startNextDiscoveredBatch();
+						optimizationResult = runOptimizeDeps(environment, knownDeps);
+						if (!holdUntilCrawlEnd) optimizationResult.result.then((result) => {
+							if (!waitingForCrawlEnd) return;
+							optimizationResult = void 0;
+							runOptimizer(result);
+						});
+					} catch (e) {
+						logger.error(e.stack || e.message);
+					} finally {
+						resolve();
+						depsOptimizer.scanProcessing = void 0;
+					}
+				})();
+			});
+		}
+	}
+	function startNextDiscoveredBatch() {
+		newDepsDiscovered = false;
+		depOptimizationProcessingQueue.push(depOptimizationProcessing);
+		depOptimizationProcessing = promiseWithResolvers();
+	}
+	function prepareKnownDeps() {
+		const knownDeps = {};
+		const metadata = depsOptimizer.metadata;
+		for (const dep of Object.keys(metadata.optimized)) knownDeps[dep] = { ...metadata.optimized[dep] };
+		for (const dep of Object.keys(metadata.discovered)) {
+			const { processing, ...info } = metadata.discovered[dep];
+			knownDeps[dep] = info;
+		}
+		return knownDeps;
+	}
+	async function runOptimizer(preRunResult) {
+		const isRerun = firstRunCalled;
+		firstRunCalled = true;
+		enqueuedRerun = void 0;
+		if (debounceProcessingHandle) clearTimeout(debounceProcessingHandle);
+		if (closed) {
+			currentlyProcessing = false;
+			depOptimizationProcessing.resolve();
+			resolveEnqueuedProcessingPromises();
+			return;
+		}
+		currentlyProcessing = true;
+		try {
+			let processingResult;
+			if (preRunResult) processingResult = preRunResult;
+			else {
+				const knownDeps = prepareKnownDeps();
+				startNextDiscoveredBatch();
+				optimizationResult = runOptimizeDeps(environment, knownDeps);
+				processingResult = await optimizationResult.result;
+				optimizationResult = void 0;
+			}
+			if (closed) {
+				currentlyProcessing = false;
+				processingResult.cancel();
+				resolveEnqueuedProcessingPromises();
+				return;
+			}
+			const newData = processingResult.metadata;
+			const needsInteropMismatch = findInteropMismatches(metadata.discovered, newData.optimized);
+			const needsReload = needsInteropMismatch.length > 0 || metadata.hash !== newData.hash || Object.keys(metadata.optimized).some((dep) => {
+				return metadata.optimized[dep].fileHash !== newData.optimized[dep].fileHash;
+			});
+			const commitProcessing = async () => {
+				await processingResult.commit();
+				for (const id in metadata.discovered) if (!newData.optimized[id]) addOptimizedDepInfo(newData, "discovered", metadata.discovered[id]);
+				if (!needsReload) {
+					newData.browserHash = metadata.browserHash;
+					for (const dep in newData.chunks) newData.chunks[dep].browserHash = metadata.browserHash;
+					for (const dep in newData.optimized) newData.optimized[dep].browserHash = (metadata.optimized[dep] || metadata.discovered[dep]).browserHash;
+				}
+				for (const o in newData.optimized) {
+					const discovered = metadata.discovered[o];
+					if (discovered) {
+						const optimized = newData.optimized[o];
+						discovered.browserHash = optimized.browserHash;
+						discovered.fileHash = optimized.fileHash;
+						discovered.needsInterop = optimized.needsInterop;
+						discovered.processing = void 0;
+					}
+				}
+				if (isRerun) newDepsToLog.push(...Object.keys(newData.optimized).filter((dep) => !metadata.optimized[dep]));
+				metadata = depsOptimizer.metadata = newData;
+				resolveEnqueuedProcessingPromises();
+			};
+			if (!needsReload) {
+				await commitProcessing();
+				if (!debug$9) {
+					if (newDepsToLogHandle) clearTimeout(newDepsToLogHandle);
+					newDepsToLogHandle = setTimeout(() => {
+						newDepsToLogHandle = void 0;
+						logNewlyDiscoveredDeps();
+						if (warnAboutMissedDependencies) {
+							logDiscoveredDepsWhileScanning();
+							logger.info(import_picocolors.default.magenta(`❗ add these dependencies to optimizeDeps.include to speed up cold start`), { timestamp: true });
+							warnAboutMissedDependencies = false;
+						}
+					}, 2 * debounceMs);
+				} else debug$9(import_picocolors.default.green(`✨ ${!isRerun ? `dependencies optimized` : `optimized dependencies unchanged`}`));
+			} else if (newDepsDiscovered) {
+				processingResult.cancel();
+				debug$9?.(import_picocolors.default.green(`✨ delaying reload as new dependencies have been found...`));
+			} else {
+				await commitProcessing();
+				if (!debug$9) {
+					if (newDepsToLogHandle) clearTimeout(newDepsToLogHandle);
+					newDepsToLogHandle = void 0;
+					logNewlyDiscoveredDeps();
+					if (warnAboutMissedDependencies) {
+						logDiscoveredDepsWhileScanning();
+						logger.info(import_picocolors.default.magenta(`❗ add these dependencies to optimizeDeps.include to avoid a full page reload during cold start`), { timestamp: true });
+						warnAboutMissedDependencies = false;
+					}
+				}
+				logger.info(import_picocolors.default.green(`✨ optimized dependencies changed. reloading`), { timestamp: true });
+				if (needsInteropMismatch.length > 0) logger.warn(`Mixed ESM and CJS detected in ${import_picocolors.default.yellow(needsInteropMismatch.join(", "))}, add ${needsInteropMismatch.length === 1 ? "it" : "them"} to optimizeDeps.needsInterop to speed up cold start`, { timestamp: true });
+				fullReload();
+			}
+		} catch (e) {
+			logger.error(import_picocolors.default.red(`error while updating dependencies:\n${e.stack}`), {
+				timestamp: true,
+				error: e
+			});
+			resolveEnqueuedProcessingPromises();
+			metadata.discovered = {};
+		}
+		currentlyProcessing = false;
+		enqueuedRerun?.();
+	}
+	function fullReload() {
+		environment.moduleGraph.invalidateAll();
+		environment.hot.send({
+			type: "full-reload",
+			path: "*"
+		});
+	}
+	function rerun() {
+		const depsString = depsLogString(Object.keys(metadata.discovered));
+		debug$9?.(import_picocolors.default.green(`new dependencies found: ${depsString}`));
+		runOptimizer();
+	}
+	function getDiscoveredBrowserHash(hash, deps, missing) {
+		return getHash(hash + JSON.stringify(deps) + JSON.stringify(missing) + sessionTimestamp);
+	}
+	function registerMissingImport(id, resolved) {
+		const optimized = metadata.optimized[id];
+		if (optimized) return optimized;
+		const chunk = metadata.chunks[id];
+		if (chunk) return chunk;
+		let missing = metadata.discovered[id];
+		if (missing) return missing;
+		missing = addMissingDep(id, resolved);
+		if (!waitingForCrawlEnd) debouncedProcessing();
+		return missing;
+	}
+	function addMissingDep(id, resolved) {
+		newDepsDiscovered = true;
+		return addOptimizedDepInfo(metadata, "discovered", {
+			id,
+			file: getOptimizedDepPath(environment, id),
+			src: resolved,
+			browserHash: getDiscoveredBrowserHash(metadata.hash, depsFromOptimizedDepInfo(metadata.optimized), depsFromOptimizedDepInfo(metadata.discovered)),
+			processing: depOptimizationProcessing.promise,
+			exportsData: extractExportsData(environment, resolved)
+		});
+	}
+	function debouncedProcessing(timeout = debounceMs) {
+		enqueuedRerun = void 0;
+		if (debounceProcessingHandle) clearTimeout(debounceProcessingHandle);
+		if (newDepsToLogHandle) clearTimeout(newDepsToLogHandle);
+		newDepsToLogHandle = void 0;
+		debounceProcessingHandle = setTimeout(() => {
+			debounceProcessingHandle = void 0;
+			enqueuedRerun = rerun;
+			if (!currentlyProcessing) enqueuedRerun();
+		}, timeout);
+	}
+	async function onCrawlEnd() {
+		waitingForCrawlEnd = false;
+		debug$9?.(import_picocolors.default.green(`✨ static imports crawl ended`));
+		if (closed) return;
+		await depsOptimizer.scanProcessing;
+		if (optimizationResult && !options.noDiscovery) {
+			const afterScanResult = optimizationResult.result;
+			optimizationResult = void 0;
+			const result = await afterScanResult;
+			currentlyProcessing = false;
+			const crawlDeps = Object.keys(metadata.discovered);
+			const scanDeps = Object.keys(result.metadata.optimized);
+			if (scanDeps.length === 0 && crawlDeps.length === 0) {
+				debug$9?.(import_picocolors.default.green(`✨ no dependencies found by the scanner or crawling static imports`));
+				startNextDiscoveredBatch();
+				runOptimizer(result);
+				return;
+			}
+			const needsInteropMismatch = findInteropMismatches(metadata.discovered, result.metadata.optimized);
+			const scannerMissedDeps = crawlDeps.some((dep) => !scanDeps.includes(dep));
+			if (needsInteropMismatch.length > 0 || scannerMissedDeps) {
+				result.cancel();
+				for (const dep of scanDeps) if (!crawlDeps.includes(dep)) addMissingDep(dep, result.metadata.optimized[dep].src);
+				if (scannerMissedDeps) debug$9?.(import_picocolors.default.yellow(`✨ new dependencies were found while crawling that weren't detected by the scanner`));
+				debug$9?.(import_picocolors.default.green(`✨ re-running optimizer`));
+				debouncedProcessing(0);
+			} else {
+				debug$9?.(import_picocolors.default.green(`✨ using post-scan optimizer result, the scanner found every used dependency`));
+				startNextDiscoveredBatch();
+				runOptimizer(result);
+			}
+		} else if (!holdUntilCrawlEnd) {
+			if (newDepsDiscovered) {
+				debug$9?.(import_picocolors.default.green(`✨ new dependencies were found while crawling static imports, re-running optimizer`));
+				warnAboutMissedDependencies = true;
+				debouncedProcessing(0);
+			}
+		} else {
+			const crawlDeps = Object.keys(metadata.discovered);
+			currentlyProcessing = false;
+			if (crawlDeps.length === 0) {
+				debug$9?.(import_picocolors.default.green(`✨ no dependencies found while crawling the static imports`));
+				firstRunCalled = true;
+			}
+			debouncedProcessing(0);
+		}
+	}
+	return depsOptimizer;
+}
+function createExplicitDepsOptimizer(environment) {
+	const depsOptimizer = {
+		metadata: initDepsOptimizerMetadata(environment),
+		isOptimizedDepFile: createIsOptimizedDepFile(environment),
+		isOptimizedDepUrl: createIsOptimizedDepUrl(environment),
+		getOptimizedDepId: (depInfo) => `${depInfo.file}?v=${depInfo.browserHash}`,
+		registerMissingImport: () => {
+			throw new Error(`Vite Internal Error: registerMissingImport is not supported in dev ${environment.name}`);
+		},
+		init,
+		run: () => {},
+		close: async () => {},
+		options: environment.config.optimizeDeps
+	};
+	let inited = false;
+	async function init() {
+		if (inited) return;
+		inited = true;
+		depsOptimizer.metadata = await optimizeExplicitEnvironmentDeps(environment);
+	}
+	return depsOptimizer;
+}
+function findInteropMismatches(discovered, optimized) {
+	const needsInteropMismatch = [];
+	for (const dep in discovered) {
+		const discoveredDepInfo = discovered[dep];
+		if (discoveredDepInfo.needsInterop === void 0) continue;
+		const depInfo = optimized[dep];
+		if (!depInfo) continue;
+		if (depInfo.needsInterop !== discoveredDepInfo.needsInterop) {
+			needsInteropMismatch.push(dep);
+			debug$9?.(import_picocolors.default.cyan(`✨ needsInterop mismatch detected for ${dep}`));
+		}
+	}
+	return needsInteropMismatch;
+}
+//#endregion
+//#region src/node/server/moduleGraph.ts
+var EnvironmentModuleNode = class {
+	environment;
+	/**
+	* Public served url path, starts with /
+	*/
+	url;
+	/**
+	* Resolved file system path + query
+	*/
+	id = null;
+	file = null;
+	type;
+	info;
+	meta;
+	importers = /* @__PURE__ */ new Set();
+	importedModules = /* @__PURE__ */ new Set();
+	acceptedHmrDeps = /* @__PURE__ */ new Set();
+	acceptedHmrExports = null;
+	importedBindings = null;
+	isSelfAccepting;
+	transformResult = null;
+	ssrModule = null;
+	ssrError = null;
+	lastHMRTimestamp = 0;
+	/**
+	* `import.meta.hot.invalidate` is called by the client.
+	* If there's multiple clients, multiple `invalidate` request is received.
+	* This property is used to dedupe those request to avoid multiple updates happening.
+	* @internal
+	*/
+	lastHMRInvalidationReceived = false;
+	lastInvalidationTimestamp = 0;
+	/**
+	* If the module only needs to update its imports timestamp (e.g. within an HMR chain),
+	* it is considered soft-invalidated. In this state, its `transformResult` should exist,
+	* and the next `transformRequest` for this module will replace the timestamps.
+	*
+	* By default the value is `undefined` if it's not soft/hard-invalidated. If it gets
+	* soft-invalidated, this will contain the previous `transformResult` value. If it gets
+	* hard-invalidated, this will be set to `'HARD_INVALIDATED'`.
+	* @internal
+	*/
+	invalidationState;
+	/**
+	* The module urls that are statically imported in the code. This information is separated
+	* out from `importedModules` as only importers that statically import the module can be
+	* soft invalidated. Other imports (e.g. watched files) needs the importer to be hard invalidated.
+	* @internal
+	*/
+	staticImportedUrls;
+	/**
+	* @param setIsSelfAccepting - set `false` to set `isSelfAccepting` later. e.g. #7870
+	*/
+	constructor(url, environment, setIsSelfAccepting = true) {
+		this.environment = environment;
+		this.url = url;
+		this.type = isDirectCSSRequest(url) ? "css" : "js";
+		if (setIsSelfAccepting) this.isSelfAccepting = false;
+	}
+};
+var EnvironmentModuleGraph = class {
+	environment;
+	urlToModuleMap = /* @__PURE__ */ new Map();
+	idToModuleMap = /* @__PURE__ */ new Map();
+	etagToModuleMap = /* @__PURE__ */ new Map();
+	fileToModulesMap = /* @__PURE__ */ new Map();
+	/**
+	* @internal
+	*/
+	_unresolvedUrlToModuleMap = /* @__PURE__ */ new Map();
+	/**
+	* @internal
+	*/
+	_resolveId;
+	/** @internal */
+	_hasResolveFailedErrorModules = /* @__PURE__ */ new Set();
+	constructor(environment, resolveId) {
+		this.environment = environment;
+		this._resolveId = resolveId;
+	}
+	async getModuleByUrl(rawUrl) {
+		rawUrl = removeImportQuery(removeTimestampQuery(rawUrl));
+		const mod = this._getUnresolvedUrlToModule(rawUrl);
+		if (mod) return mod;
+		const [url] = await this._resolveUrl(rawUrl);
+		return this.urlToModuleMap.get(url);
+	}
+	getModuleById(id) {
+		return this.idToModuleMap.get(removeTimestampQuery(id));
+	}
+	getModulesByFile(file) {
+		return this.fileToModulesMap.get(file);
+	}
+	onFileChange(file) {
+		const mods = this.getModulesByFile(file);
+		if (mods) {
+			const seen = /* @__PURE__ */ new Set();
+			mods.forEach((mod) => {
+				this.invalidateModule(mod, seen);
+			});
+		}
+	}
+	onFileDelete(file) {
+		const mods = this.getModulesByFile(file);
+		if (mods) mods.forEach((mod) => {
+			mod.importedModules.forEach((importedMod) => {
+				importedMod.importers.delete(mod);
+			});
+		});
+	}
+	invalidateModule(mod, seen = /* @__PURE__ */ new Set(), timestamp = monotonicDateNow(), isHmr = false, softInvalidate = false) {
+		const prevInvalidationState = mod.invalidationState;
+		if (softInvalidate) mod.invalidationState ??= mod.transformResult ?? "HARD_INVALIDATED";
+		else mod.invalidationState = "HARD_INVALIDATED";
+		if (seen.has(mod) && prevInvalidationState === mod.invalidationState) return;
+		seen.add(mod);
+		if (isHmr) {
+			mod.lastHMRTimestamp = timestamp;
+			mod.lastHMRInvalidationReceived = false;
+		} else mod.lastInvalidationTimestamp = timestamp;
+		const etag = mod.transformResult?.etag;
+		if (etag) this.etagToModuleMap.delete(etag);
+		mod.transformResult = null;
+		mod.ssrModule = null;
+		mod.ssrError = null;
+		mod.importers.forEach((importer) => {
+			if (!importer.acceptedHmrDeps.has(mod)) {
+				const shouldSoftInvalidateImporter = (importer.staticImportedUrls?.has(mod.url) || softInvalidate) && importer.type === "js";
+				this.invalidateModule(importer, seen, timestamp, isHmr, shouldSoftInvalidateImporter);
+			}
+		});
+		this._hasResolveFailedErrorModules.delete(mod);
+	}
+	invalidateAll() {
+		const timestamp = monotonicDateNow();
+		const seen = /* @__PURE__ */ new Set();
+		this.idToModuleMap.forEach((mod) => {
+			this.invalidateModule(mod, seen, timestamp);
+		});
+	}
+	/**
+	* Update the module graph based on a module's updated imports information
+	* If there are dependencies that no longer have any importers, they are
+	* returned as a Set.
+	*
+	* @param staticImportedUrls Subset of `importedModules` where they're statically imported in code.
+	*   This is only used for soft invalidations so `undefined` is fine but may cause more runtime processing.
+	*/
+	async updateModuleInfo(mod, importedModules, importedBindings, acceptedModules, acceptedExports, isSelfAccepting, staticImportedUrls) {
+		mod.isSelfAccepting = isSelfAccepting;
+		const prevImports = mod.importedModules;
+		let noLongerImported;
+		let resolvePromises = [];
+		let resolveResults = new Array(importedModules.size);
+		let index = 0;
+		for (const imported of importedModules) {
+			const nextIndex = index++;
+			if (typeof imported === "string") resolvePromises.push(this.ensureEntryFromUrl(imported).then((dep) => {
+				dep.importers.add(mod);
+				resolveResults[nextIndex] = dep;
+			}));
+			else {
+				imported.importers.add(mod);
+				resolveResults[nextIndex] = imported;
+			}
+		}
+		if (resolvePromises.length) await Promise.all(resolvePromises);
+		mod.importedModules = new Set(resolveResults);
+		prevImports.forEach((dep) => {
+			if (!mod.importedModules.has(dep)) {
+				dep.importers.delete(mod);
+				if (!dep.importers.size) (noLongerImported || (noLongerImported = /* @__PURE__ */ new Set())).add(dep);
+			}
+		});
+		resolvePromises = [];
+		resolveResults = new Array(acceptedModules.size);
+		index = 0;
+		for (const accepted of acceptedModules) {
+			const nextIndex = index++;
+			if (typeof accepted === "string") resolvePromises.push(this.ensureEntryFromUrl(accepted).then((dep) => {
+				resolveResults[nextIndex] = dep;
+			}));
+			else resolveResults[nextIndex] = accepted;
+		}
+		if (resolvePromises.length) await Promise.all(resolvePromises);
+		mod.acceptedHmrDeps = new Set(resolveResults);
+		mod.staticImportedUrls = staticImportedUrls;
+		mod.acceptedHmrExports = acceptedExports;
+		mod.importedBindings = importedBindings;
+		return noLongerImported;
+	}
+	async ensureEntryFromUrl(rawUrl, setIsSelfAccepting = true) {
+		return this._ensureEntryFromUrl(rawUrl, setIsSelfAccepting);
+	}
+	/**
+	* @internal
+	*/
+	async _ensureEntryFromUrl(rawUrl, setIsSelfAccepting = true, resolved) {
+		rawUrl = removeImportQuery(removeTimestampQuery(rawUrl));
+		let mod = this._getUnresolvedUrlToModule(rawUrl);
+		if (mod) return mod;
+		const modPromise = (async () => {
+			const [url, resolvedId, meta] = await this._resolveUrl(rawUrl, resolved);
+			mod = this.idToModuleMap.get(resolvedId);
+			if (!mod) {
+				mod = new EnvironmentModuleNode(url, this.environment, setIsSelfAccepting);
+				if (meta) mod.meta = meta;
+				this.urlToModuleMap.set(url, mod);
+				mod.id = resolvedId;
+				this.idToModuleMap.set(resolvedId, mod);
+				const file = mod.file = cleanUrl(resolvedId);
+				let fileMappedModules = this.fileToModulesMap.get(file);
+				if (!fileMappedModules) {
+					fileMappedModules = /* @__PURE__ */ new Set();
+					this.fileToModulesMap.set(file, fileMappedModules);
+				}
+				fileMappedModules.add(mod);
+			} else if (!this.urlToModuleMap.has(url)) this.urlToModuleMap.set(url, mod);
+			this._setUnresolvedUrlToModule(rawUrl, mod);
+			return mod;
+		})();
+		this._setUnresolvedUrlToModule(rawUrl, modPromise);
+		return modPromise;
+	}
+	createFileOnlyEntry(file) {
+		file = normalizePath(file);
+		let fileMappedModules = this.fileToModulesMap.get(file);
+		if (!fileMappedModules) {
+			fileMappedModules = /* @__PURE__ */ new Set();
+			this.fileToModulesMap.set(file, fileMappedModules);
+		}
+		const url = `${FS_PREFIX}${file}`;
+		for (const m of fileMappedModules) if ((m.url === url || m.id === file) && m.type === "asset") return m;
+		const mod = new EnvironmentModuleNode(url, this.environment);
+		mod.type = "asset";
+		mod.file = file;
+		fileMappedModules.add(mod);
+		return mod;
+	}
+	async resolveUrl(url) {
+		url = removeImportQuery(removeTimestampQuery(url));
+		const mod = await this._getUnresolvedUrlToModule(url);
+		if (mod?.id) return [
+			mod.url,
+			mod.id,
+			mod.meta
+		];
+		return this._resolveUrl(url);
+	}
+	updateModuleTransformResult(mod, result) {
+		if (this.environment === "client") {
+			const prevEtag = mod.transformResult?.etag;
+			if (prevEtag) this.etagToModuleMap.delete(prevEtag);
+			if (result?.etag) this.etagToModuleMap.set(result.etag, mod);
+		}
+		mod.transformResult = result;
+	}
+	getModuleByEtag(etag) {
+		return this.etagToModuleMap.get(etag);
+	}
+	/**
+	* @internal
+	*/
+	_getUnresolvedUrlToModule(url) {
+		return this._unresolvedUrlToModuleMap.get(url);
+	}
+	/**
+	* @internal
+	*/
+	_setUnresolvedUrlToModule(url, mod) {
+		this._unresolvedUrlToModuleMap.set(url, mod);
+	}
+	/**
+	* @internal
+	*/
+	async _resolveUrl(url, alreadyResolved) {
+		const resolved = alreadyResolved ?? await this._resolveId(url);
+		const resolvedId = resolved?.id || url;
+		if (url !== resolvedId && !url.includes("\0") && !url.startsWith(`virtual:`)) {
+			const ext = extname(cleanUrl(resolvedId));
+			if (ext) {
+				const pathname = cleanUrl(url);
+				if (!pathname.endsWith(ext)) url = pathname + ext + url.slice(pathname.length);
+			}
+		}
+		return [
+			url,
+			resolvedId,
+			resolved?.meta
+		];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/totalist@3.0.1/node_modules/totalist/sync/index.mjs
+function totalist(dir, callback, pre = "") {
+	dir = resolve$1(".", dir);
+	let arr = readdirSync(dir);
+	let i = 0, abs, stats;
+	for (; i < arr.length; i++) {
+		abs = join$1(dir, arr[i]);
+		stats = statSync(abs);
+		stats.isDirectory() ? totalist(abs, callback, join$1(pre, arr[i])) : callback(join$1(pre, arr[i]), abs, stats);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@polka+url@1.0.0-next.29/node_modules/@polka/url/build.mjs
+/**
+* @typedef ParsedURL
+* @type {import('.').ParsedURL}
+*/
+/**
+* @typedef Request
+* @property {string} url
+* @property {ParsedURL} _parsedUrl
+*/
+/**
+* @param {Request} req
+* @returns {ParsedURL|void}
+*/
+function parse$1(req) {
+	let raw = req.url;
+	if (raw == null) return;
+	let prev = req._parsedUrl;
+	if (prev && prev.raw === raw) return prev;
+	let pathname = raw, search = "", query, hash;
+	if (raw.length > 1) {
+		let idx = raw.indexOf("#", 1);
+		if (idx !== -1) {
+			hash = raw.substring(idx);
+			pathname = raw.substring(0, idx);
+		}
+		idx = pathname.indexOf("?", 1);
+		if (idx !== -1) {
+			search = pathname.substring(idx);
+			pathname = pathname.substring(0, idx);
+			if (search.length > 1) query = qs.parse(search.substring(1));
+		}
+	}
+	return req._parsedUrl = {
+		pathname,
+		search,
+		query,
+		hash,
+		raw
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/sirv@3.0.2_patch_hash=c07c56eb72faea34341d465cde2314e89db472106ed378181e3447893af6bf95/node_modules/sirv/build.mjs
+const noop = () => {};
+function isMatch(uri, arr) {
+	for (let i = 0; i < arr.length; i++) if (arr[i].test(uri)) return true;
+}
+function toAssume(uri, extns) {
+	let i = 0, x, len = uri.length - 1;
+	if (uri.charCodeAt(len) === 47) uri = uri.substring(0, len);
+	let arr = [], tmp = `${uri}/index`;
+	for (; i < extns.length; i++) {
+		x = extns[i] ? `.${extns[i]}` : "";
+		if (uri) arr.push(uri + x);
+		arr.push(tmp + x);
+	}
+	return arr;
+}
+function viaCache(cache, uri, extns) {
+	let i = 0, data, arr = toAssume(uri, extns);
+	for (; i < arr.length; i++) if (data = cache[arr[i]]) return data;
+}
+function viaLocal(dir, isEtag, uri, extns, shouldServe) {
+	let i = 0, arr = toAssume(uri, extns);
+	let abs, stats, name, headers;
+	for (; i < arr.length; i++) {
+		abs = normalize(join(dir, name = arr[i]));
+		if (abs.startsWith(dir) && fs$1.existsSync(abs)) {
+			stats = fs$1.statSync(abs);
+			if (stats.isDirectory()) continue;
+			if (shouldServe && !shouldServe(abs)) continue;
+			headers = toHeaders(name, stats, isEtag);
+			headers["Cache-Control"] = isEtag ? "no-cache" : "no-store";
+			return {
+				abs,
+				stats,
+				headers
+			};
+		}
+	}
+}
+function is404(req, res) {
+	return res.statusCode = 404, res.end();
+}
+function send$1(req, res, file, stats, headers) {
+	let code = 200, tmp, opts = {};
+	headers = { ...headers };
+	for (let key in headers) {
+		tmp = res.getHeader(key);
+		if (tmp) headers[key] = tmp;
+	}
+	if (tmp = res.getHeader("content-type")) headers["Content-Type"] = tmp;
+	if (req.headers.range) {
+		code = 206;
+		let [x, y] = req.headers.range.replace("bytes=", "").split("-");
+		let end = opts.end = parseInt(y, 10) || stats.size - 1;
+		let start = opts.start = parseInt(x, 10) || 0;
+		if (end >= stats.size) end = stats.size - 1;
+		if (start >= stats.size) {
+			res.setHeader("Content-Range", `bytes */${stats.size}`);
+			res.statusCode = 416;
+			return res.end();
+		}
+		headers["Content-Range"] = `bytes ${start}-${end}/${stats.size}`;
+		headers["Content-Length"] = end - start + 1;
+		headers["Accept-Ranges"] = "bytes";
+	}
+	res.writeHead(code, headers);
+	fs$1.createReadStream(file, opts).pipe(res);
+}
+const ENCODING = {
+	".br": "br",
+	".gz": "gzip"
+};
+function toHeaders(name, stats, isEtag) {
+	let enc = ENCODING[name.slice(-3)];
+	let ctype = lookup(name.slice(0, enc && -3)) || "";
+	if (ctype === "text/html") ctype += ";charset=utf-8";
+	let headers = {
+		"Content-Length": stats.size,
+		"Content-Type": ctype,
+		"Last-Modified": stats.mtime.toUTCString()
+	};
+	if (enc) headers["Content-Encoding"] = enc;
+	if (isEtag) headers["ETag"] = `W/"${stats.size}-${stats.mtime.getTime()}"`;
+	return headers;
+}
+function build_default$1(dir, opts = {}) {
+	dir = resolve(dir || ".");
+	let isNotFound = opts.onNoMatch || is404;
+	let setHeaders = opts.setHeaders || noop;
+	let extensions = opts.extensions || ["html", "htm"];
+	let gzips = opts.gzip && extensions.map((x) => `${x}.gz`).concat("gz");
+	let brots = opts.brotli && extensions.map((x) => `${x}.br`).concat("br");
+	const FILES = {};
+	let fallback = "/";
+	let isEtag = !!opts.etag;
+	let isSPA = !!opts.single;
+	if (typeof opts.single === "string") {
+		let idx = opts.single.lastIndexOf(".");
+		fallback += !!~idx ? opts.single.substring(0, idx) : opts.single;
+	}
+	let ignores = [];
+	if (opts.ignores !== false) {
+		ignores.push(/[/]([A-Za-z\s\d~$._-]+\.\w+){1,}$/);
+		if (opts.dotfiles) ignores.push(/\/\.\w/);
+		else ignores.push(/\/\.well-known/);
+		[].concat(opts.ignores || []).forEach((x) => {
+			ignores.push(new RegExp(x, "i"));
+		});
+	}
+	let cc = opts.maxAge != null && `public,max-age=${opts.maxAge}`;
+	if (cc && opts.immutable) cc += ",immutable";
+	else if (cc && opts.maxAge === 0) cc += ",must-revalidate";
+	if (!opts.dev) totalist(dir, (name, abs, stats) => {
+		if (/\.well-known[\\+\/]/.test(name)) {} else if (!opts.dotfiles && /(^\.|[\\+|\/+]\.)/.test(name)) return;
+		let headers = toHeaders(name, stats, isEtag);
+		if (cc) headers["Cache-Control"] = cc;
+		FILES["/" + name.normalize().replace(/\\+/g, "/")] = {
+			abs,
+			stats,
+			headers
+		};
+	});
+	let lookup = opts.dev ? viaLocal.bind(0, dir.endsWith(sep) ? dir : dir + sep, isEtag) : viaCache.bind(0, FILES);
+	return function(req, res, next) {
+		let extns = [""];
+		let pathname = parse$1(req).pathname;
+		let val = req.headers["accept-encoding"] || "";
+		if (gzips && val.includes("gzip")) extns.unshift(...gzips);
+		if (brots && /(br|brotli)/i.test(val)) extns.unshift(...brots);
+		extns.push(...extensions);
+		if (pathname.indexOf("%") !== -1) try {
+			pathname = decodeURI(pathname);
+		} catch (err) {}
+		let data = lookup(pathname, extns, opts.shouldServe) || isSPA && !isMatch(pathname, ignores) && lookup(fallback, extns, opts.shouldServe);
+		if (!data) return next ? next() : isNotFound(req, res);
+		if (isEtag && req.headers["if-none-match"] === data.headers["ETag"]) {
+			res.writeHead(304);
+			return res.end();
+		}
+		if (gzips || brots) res.setHeader("Vary", "Accept-Encoding");
+		setHeaders(res, pathname, data.stats);
+		send$1(req, res, data.abs, data.stats, data.headers);
+	};
+}
+//#endregion
+//#region src/node/server/middlewares/static.ts
+const knownJavascriptExtensionRE = /\.(?:[tj]sx?|[cm][tj]s)$/;
+const ERR_DENIED_FILE = "ERR_DENIED_FILE";
+const sirvOptions = ({ config, getHeaders, disableFsServeCheck }) => {
+	return {
+		dev: true,
+		etag: true,
+		extensions: [],
+		setHeaders(res, pathname) {
+			if (knownJavascriptExtensionRE.test(pathname)) res.setHeader("Content-Type", "text/javascript");
+			const headers = getHeaders();
+			if (headers) for (const name in headers) res.setHeader(name, headers[name]);
+		},
+		shouldServe: disableFsServeCheck ? void 0 : (filePath) => {
+			const servingAccessResult = checkLoadingAccess(config, filePath);
+			if (servingAccessResult === "denied") {
+				const error = /* @__PURE__ */ new Error("denied access");
+				error.code = ERR_DENIED_FILE;
+				error.path = filePath;
+				throw error;
+			}
+			if (servingAccessResult === "fallback") return false;
+			return true;
+		}
+	};
+};
+function servePublicMiddleware(server, publicFiles) {
+	const dir = server.config.publicDir;
+	const serve = build_default$1(dir, sirvOptions({
+		config: server.config,
+		getHeaders: () => server.config.server.headers,
+		disableFsServeCheck: true
+	}));
+	const toFilePath = (url) => {
+		let filePath = cleanUrl(url);
+		if (filePath.includes("%")) try {
+			filePath = decodeURI(filePath);
+		} catch {}
+		return normalizePath(filePath);
+	};
+	return function viteServePublicMiddleware(req, res, next) {
+		if (publicFiles && !publicFiles.has(toFilePath(req.url)) || isImportRequest(req.url) || isInternalRequest(req.url) || urlRE$1.test(req.url)) return next();
+		serve(req, res, next);
+	};
+}
+function serveStaticMiddleware(server) {
+	const dir = server.config.root;
+	const serve = build_default$1(dir, sirvOptions({
+		config: server.config,
+		getHeaders: () => server.config.server.headers
+	}));
+	return function viteServeStaticMiddleware(req, res, next) {
+		const cleanedUrl = cleanUrl(req.url);
+		if (cleanedUrl.endsWith("/") || path.extname(cleanedUrl) === ".html" || isInternalRequest(req.url) || req.url?.startsWith("//")) return next();
+		const url = new URL(req.url, "http://example.com");
+		const pathname = decodeURIIfPossible(url.pathname);
+		if (pathname === void 0) return next();
+		let redirectedPathname;
+		for (const { find, replacement } of server.config.resolve.alias) if (typeof find === "string" ? pathname.startsWith(find) : find.test(pathname)) {
+			redirectedPathname = pathname.replace(find, replacement);
+			break;
+		}
+		if (redirectedPathname) {
+			if (redirectedPathname.startsWith(withTrailingSlash(dir))) redirectedPathname = redirectedPathname.slice(dir.length);
+		}
+		const resolvedPathname = redirectedPathname || pathname;
+		let fileUrl = path.resolve(dir, removeLeadingSlash(resolvedPathname));
+		if (resolvedPathname.endsWith("/") && fileUrl[fileUrl.length - 1] !== "/") fileUrl = withTrailingSlash(fileUrl);
+		if (redirectedPathname) {
+			url.pathname = encodeURI(redirectedPathname);
+			req.url = url.href.slice(url.origin.length);
+		}
+		try {
+			serve(req, res, next);
+		} catch (e) {
+			if (e && "code" in e && e.code === ERR_DENIED_FILE) {
+				respondWithAccessDenied(e.path, server, res);
+				return;
+			}
+			throw e;
+		}
+	};
+}
+function serveRawFsMiddleware(server) {
+	const serveFromRoot = build_default$1("/", sirvOptions({
+		config: server.config,
+		getHeaders: () => server.config.server.headers
+	}));
+	return function viteServeRawFsMiddleware(req, res, next) {
+		if (req.url.startsWith(FS_PREFIX)) {
+			const url = new URL(req.url, "http://example.com");
+			const pathname = decodeURIIfPossible(url.pathname);
+			if (pathname === void 0) return next();
+			let newPathname = pathname.slice(FS_PREFIX.length);
+			if (isWindows) newPathname = newPathname.replace(/^[A-Z]:/i, "");
+			url.pathname = encodeURI(newPathname);
+			req.url = url.href.slice(url.origin.length);
+			try {
+				serveFromRoot(req, res, next);
+			} catch (e) {
+				if (e && "code" in e && e.code === ERR_DENIED_FILE) {
+					respondWithAccessDenied(e.path, server, res);
+					return;
+				}
+				throw e;
+			}
+		} else next();
+	};
+}
+function isFileServingAllowed(configOrUrl, urlOrServer) {
+	const config = typeof urlOrServer === "string" ? configOrUrl : urlOrServer.config;
+	const url = typeof urlOrServer === "string" ? urlOrServer : configOrUrl;
+	if (!config.server.fs.strict) return true;
+	return isFileLoadingAllowed(config, fsPathFromUrl(url));
+}
+/**
+* Warning: parameters are not validated, only works with normalized absolute paths
+*
+* @param targetPath - normalized absolute path
+* @param filePath - normalized absolute path
+*/
+function isFileInTargetPath(targetPath, filePath) {
+	return isSameFilePath(targetPath, filePath) || isParentDirectory(targetPath, filePath);
+}
+/**
+* Warning: parameters are not validated, only works with normalized absolute paths
+*/
+function isFileLoadingAllowed(config, filePath) {
+	const { fs } = config.server;
+	if (!fs.strict) return true;
+	const filePathWithoutTrailingSlash = filePath.endsWith("/") ? filePath.slice(0, -1) : filePath;
+	if (config.fsDenyGlob(filePathWithoutTrailingSlash)) return false;
+	if (config.safeModulePaths.has(filePath)) return true;
+	if (fs.allow.some((uri) => isFileInTargetPath(uri, filePath))) return true;
+	return false;
+}
+function checkLoadingAccess(config, path) {
+	if (isFileLoadingAllowed(config, slash(path))) return "allowed";
+	if (isFileReadable(path)) return "denied";
+	return "fallback";
+}
+function respondWithAccessDenied(id, server, res) {
+	const urlMessage = `The request id "${id}" is outside of Vite serving allow list.`;
+	const hintMessage = `
+${server.config.server.fs.allow.map((i) => `- ${i}`).join("\n")}
+
+Refer to docs https://vite.dev/config/server-options.html#server-fs-allow for configurations and more details.`;
+	server.config.logger.error(urlMessage);
+	server.config.logger.warnOnce(hintMessage + "\n");
+	res.statusCode = 403;
+	res.write(renderRestrictedErrorHTML(urlMessage + "\n" + hintMessage));
+	res.end();
+}
+function renderRestrictedErrorHTML(msg) {
+	return String.raw`
+    <body>
+      <h1>403 Restricted</h1>
+      <p>${(0, import_escape_html.default)(msg).replace(/\n/g, "<br/>")}</p>
+      <style>
+        body {
+          padding: 1em 2em;
+        }
+      </style>
+    </body>
+  `;
+}
+//#endregion
+//#region src/node/server/send.ts
+var import_etag = /* @__PURE__ */ __toESM(require_etag(), 1);
+const debug$8 = createDebugger("vite:send", { onlyWhenFocused: true });
+const alias = {
+	js: "text/javascript",
+	css: "text/css",
+	html: "text/html",
+	json: "application/json"
+};
+function send(req, res, content, type, options) {
+	const { etag = (0, import_etag.default)(content, { weak: true }), cacheControl = "no-cache", headers, map } = options;
+	if (res.writableEnded) return;
+	if (req.headers["if-none-match"] === etag) {
+		res.statusCode = 304;
+		res.end();
+		return;
+	}
+	res.setHeader("Content-Type", alias[type] || type);
+	res.setHeader("Cache-Control", cacheControl);
+	res.setHeader("Etag", etag);
+	if (headers) for (const name in headers) res.setHeader(name, headers[name]);
+	if (map && "version" in map && map.mappings) {
+		if (type === "js" || type === "css") content = getCodeWithSourcemap(type, content.toString(), map);
+	} else if (type === "js" && (!map || map.mappings !== "")) {
+		const code = content.toString();
+		if (import_convert_source_map.default.mapFileCommentRegex.test(code)) debug$8?.(`Skipped injecting fallback sourcemap for ${req.url}`);
+		else {
+			const urlWithoutTimestamp = removeTimestampQuery(req.url);
+			content = getCodeWithSourcemap(type, code, new MagicString(code).generateMap({
+				source: path.basename(urlWithoutTimestamp),
+				hires: "boundary",
+				includeContent: true
+			}));
+		}
+	}
+	res.statusCode = 200;
+	if (req.method === "HEAD") res.end();
+	else res.end(content);
+}
+//#endregion
+//#region src/node/server/middlewares/transform.ts
+const debugCache$1 = createDebugger("vite:cache");
+const knownIgnoreList = new Set(["/", "/favicon.ico"]);
+const documentFetchDests = new Set([
+	"document",
+	"iframe",
+	"frame",
+	"fencedframe"
+]);
+function isDocumentFetchDest(req) {
+	const fetchDest = req.headers["sec-fetch-dest"];
+	return fetchDest !== void 0 && documentFetchDests.has(fetchDest);
+}
+const urlRE = /[?&]url\b/;
+const rawRE = /[?&]raw\b/;
+const inlineRE$1 = /[?&]inline\b/;
+const svgRE = /\.svg\b/;
+function isServerAccessDeniedForTransform(config, id) {
+	if (rawRE.test(id) || urlRE.test(id) || inlineRE$1.test(id) || svgRE.test(id)) return checkLoadingAccess(config, cleanUrl(id)) !== "allowed" || checkLoadingAccess(config, id) !== "allowed";
+	return false;
+}
+/**
+* A middleware that short-circuits the middleware chain to serve cached transformed modules
+*/
+function cachedTransformMiddleware(server) {
+	return function viteCachedTransformMiddleware(req, res, next) {
+		const environment = server.environments.client;
+		if (isDocumentFetchDest(req)) {
+			res.appendHeader("Vary", "Sec-Fetch-Dest");
+			return next();
+		}
+		const ifNoneMatch = req.headers["if-none-match"];
+		if (ifNoneMatch) {
+			const moduleByEtag = environment.moduleGraph.getModuleByEtag(ifNoneMatch);
+			if (moduleByEtag?.transformResult?.etag === ifNoneMatch && moduleByEtag.url === req.url) {
+				if (!isCSSRequest(req.url)) {
+					debugCache$1?.(`[304] ${prettifyUrl(req.url, server.config.root)}`);
+					res.statusCode = 304;
+					return res.end();
+				}
+			}
+		}
+		next();
+	};
+}
+function transformMiddleware(server) {
+	const { root, publicDir } = server.config;
+	const publicDirInRoot = publicDir.startsWith(withTrailingSlash(root));
+	const publicPath = `${publicDir.slice(root.length)}/`;
+	return async function viteTransformMiddleware(req, res, next) {
+		const environment = server.environments.client;
+		if (req.method !== "GET" && req.method !== "HEAD" || knownIgnoreList.has(req.url) || isDocumentFetchDest(req)) return next();
+		let url;
+		try {
+			url = decodeURI(removeTimestampQuery(req.url)).replace(NULL_BYTE_PLACEHOLDER, "\0");
+		} catch (e) {
+			if (e instanceof URIError) {
+				server.config.logger.warn(import_picocolors.default.yellow(`Malformed URI sequence in request URL: ${removeTimestampQuery(req.url)}`));
+				return next();
+			}
+			return next(e);
+		}
+		const withoutQuery = cleanUrl(url);
+		try {
+			if (withoutQuery.endsWith(".map")) {
+				const depsOptimizer = environment.depsOptimizer;
+				if (depsOptimizer?.isOptimizedDepUrl(url)) {
+					const sourcemapPath = url.startsWith(FS_PREFIX) ? fsPathFromId(url) : normalizePath(path.resolve(server.config.root, url.slice(1)));
+					if (!depsOptimizer.isOptimizedDepFile(sourcemapPath)) return next();
+					try {
+						const map = JSON.parse(await fsp.readFile(sourcemapPath, "utf-8"));
+						applySourcemapIgnoreList(map, sourcemapPath, server.config.server.sourcemapIgnoreList, server.config.logger);
+						return send(req, res, JSON.stringify(map), "json", { headers: server.config.server.headers });
+					} catch {
+						const dummySourceMap = {
+							version: 3,
+							file: sourcemapPath.replace(/\.map$/, ""),
+							sources: [],
+							sourcesContent: [],
+							names: [],
+							mappings: ";;;;;;;;;"
+						};
+						return send(req, res, JSON.stringify(dummySourceMap), "json", {
+							cacheControl: "no-cache",
+							headers: server.config.server.headers
+						});
+					}
+				} else {
+					const originalUrl = url.replace(/\.map($|\?)/, "$1");
+					const map = (await environment.moduleGraph.getModuleByUrl(originalUrl))?.transformResult?.map;
+					if (map) return send(req, res, JSON.stringify(map), "json", { headers: server.config.server.headers });
+					else return next();
+				}
+			}
+			if (publicDirInRoot && url.startsWith(publicPath)) warnAboutExplicitPublicPathInUrl(url);
+			if (req.headers["sec-fetch-dest"] === "script" || isJSRequest(url) || isImportRequest(url) || isCSSRequest(url) || isHTMLProxy(url)) {
+				url = removeImportQuery(url);
+				url = unwrapId(url);
+				if (isCSSRequest(url)) {
+					if (req.headers.accept?.includes("text/css") && !isDirectRequest(url)) url = injectQuery(url, "direct");
+					const ifNoneMatch = req.headers["if-none-match"];
+					if (ifNoneMatch && (await environment.moduleGraph.getModuleByUrl(url))?.transformResult?.etag === ifNoneMatch) {
+						debugCache$1?.(`[304] ${prettifyUrl(url, server.config.root)}`);
+						res.statusCode = 304;
+						return res.end();
+					}
+				}
+				const result = await environment.transformRequest(url);
+				if (result) {
+					const depsOptimizer = environment.depsOptimizer;
+					const type = isDirectCSSRequest(url) ? "css" : "js";
+					const isDep = DEP_VERSION_RE.test(url) || depsOptimizer?.isOptimizedDepUrl(url);
+					return send(req, res, result.code, type, {
+						etag: result.etag,
+						cacheControl: isDep ? "max-age=31536000,immutable" : "no-cache",
+						headers: server.config.server.headers,
+						map: result.map
+					});
+				}
+			}
+		} catch (e) {
+			if (e?.code === "ERR_OPTIMIZE_DEPS_PROCESSING_ERROR") {
+				if (!res.writableEnded) {
+					res.statusCode = 504;
+					res.statusMessage = "Optimize Deps Processing Error";
+					res.end();
+				}
+				server.config.logger.error(e.message);
+				return;
+			}
+			if (e?.code === "ERR_OUTDATED_OPTIMIZED_DEP") {
+				if (!res.writableEnded) {
+					res.statusCode = 504;
+					res.statusMessage = "Outdated Optimize Dep";
+					res.end();
+				}
+				return;
+			}
+			if (e?.code === "ERR_CLOSED_SERVER") {
+				if (!res.writableEnded) {
+					res.statusCode = 504;
+					res.statusMessage = "Outdated Request";
+					res.end();
+				}
+				return;
+			}
+			if (e?.code === "ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR") {
+				if (!res.writableEnded) {
+					res.statusCode = 404;
+					res.end();
+				}
+				server.config.logger.warn(import_picocolors.default.yellow(e.message));
+				return;
+			}
+			if (e?.code === "ERR_LOAD_URL") return next();
+			if (e?.code === "ERR_DENIED_ID") {
+				const id = e.id;
+				let servingAccessResult = checkLoadingAccess(server.config, cleanUrl(id));
+				if (servingAccessResult === "allowed") servingAccessResult = checkLoadingAccess(server.config, id);
+				if (servingAccessResult === "denied") {
+					respondWithAccessDenied(id, server, res);
+					return true;
+				}
+				if (servingAccessResult === "fallback") {
+					next();
+					return true;
+				}
+				throw new Error(`Unexpected access result for id ${id}`);
+			}
+			return next(e);
+		}
+		next();
+	};
+	function warnAboutExplicitPublicPathInUrl(url) {
+		let warning;
+		if (isImportRequest(url)) {
+			const rawUrl = removeImportQuery(url);
+			if (urlRE.test(url)) warning = `Assets in the public directory are served at the root path.\nInstead of ${import_picocolors.default.cyan(rawUrl)}, use ${import_picocolors.default.cyan(rawUrl.replace(publicPath, "/"))}.`;
+			else warning = `Assets in public directory cannot be imported from JavaScript.
+If you intend to import that asset, put the file in the src directory, and use ${import_picocolors.default.cyan(rawUrl.replace(publicPath, "/src/"))} instead of ${import_picocolors.default.cyan(rawUrl)}.\nIf you intend to use the URL of that asset, use ${import_picocolors.default.cyan(injectQuery(rawUrl.replace(publicPath, "/"), "url"))}.`;
+		} else warning = `Files in the public directory are served at the root path.\nInstead of ${import_picocolors.default.cyan(url)}, use ${import_picocolors.default.cyan(url.replace(publicPath, "/"))}.`;
+		server.config.logger.warn(import_picocolors.default.yellow(warning));
+	}
+}
+//#endregion
+//#region src/node/server/transformRequest.ts
+const ERR_LOAD_URL = "ERR_LOAD_URL";
+const ERR_LOAD_PUBLIC_URL = "ERR_LOAD_PUBLIC_URL";
+const ERR_DENIED_ID = "ERR_DENIED_ID";
+const debugLoad = createDebugger("vite:load");
+const debugTransform = createDebugger("vite:transform");
+const debugCache = createDebugger("vite:cache");
+function transformRequest(environment, url, options) {
+	if (environment._closing && environment.config.dev.recoverable) throwClosedServerError();
+	const timestamp = monotonicDateNow();
+	url = removeTimestampQuery(url);
+	const pending = environment._pendingRequests.get(url);
+	if (pending) return environment.moduleGraph.getModuleByUrl(url).then((module) => {
+		if (!module || pending.timestamp > module.lastInvalidationTimestamp) return pending.request;
+		else {
+			pending.abort();
+			return transformRequest(environment, url, options);
+		}
+	});
+	const request = doTransform(environment, url, options, timestamp);
+	let cleared = false;
+	const clearCache = () => {
+		if (!cleared) {
+			environment._pendingRequests.delete(url);
+			cleared = true;
+		}
+	};
+	environment._pendingRequests.set(url, {
+		request,
+		timestamp,
+		abort: clearCache
+	});
+	return request.finally(clearCache);
+}
+async function doTransform(environment, url, options, timestamp) {
+	const { pluginContainer } = environment;
+	let module = await environment.moduleGraph.getModuleByUrl(url);
+	if (module) {
+		const cached = await getCachedTransformResult(environment, url, module, timestamp);
+		if (cached) return cached;
+	}
+	const resolved = module ? void 0 : await pluginContainer.resolveId(url, void 0) ?? void 0;
+	const id = module?.id ?? resolved?.id ?? url;
+	module ??= environment.moduleGraph.getModuleById(id);
+	if (module) {
+		await environment.moduleGraph._ensureEntryFromUrl(url, void 0, resolved);
+		const cached = await getCachedTransformResult(environment, url, module, timestamp);
+		if (cached) return cached;
+	}
+	const result = loadAndTransform(environment, id, url, options, timestamp, module, resolved);
+	const { depsOptimizer } = environment;
+	if (!depsOptimizer?.isOptimizedDepFile(id)) environment._registerRequestProcessing(id, () => result);
+	return result;
+}
+async function getCachedTransformResult(environment, url, module, timestamp) {
+	const prettyUrl = debugCache ? prettifyUrl(url, environment.config.root) : "";
+	const softInvalidatedTransformResult = await handleModuleSoftInvalidation(environment, module, timestamp);
+	if (softInvalidatedTransformResult) {
+		debugCache?.(`[memory-hmr] ${prettyUrl}`);
+		return softInvalidatedTransformResult;
+	}
+	const cached = module.transformResult;
+	if (cached) {
+		debugCache?.(`[memory] ${prettyUrl}`);
+		return cached;
+	}
+}
+async function loadAndTransform(environment, id, url, options, timestamp, mod, resolved) {
+	const { config, pluginContainer, logger } = environment;
+	const prettyUrl = debugLoad || debugTransform ? prettifyUrl(url, config.root) : "";
+	const moduleGraph = environment.moduleGraph;
+	if (!options.skipFsCheck && id[0] !== "\0" && isServerAccessDeniedForTransform(config, id)) {
+		const err = /* @__PURE__ */ new Error(`Denied ID ${id}`);
+		err.code = ERR_DENIED_ID;
+		err.id = id;
+		throw err;
+	}
+	let code = null;
+	let map = null;
+	let moduleType;
+	const loadStart = debugLoad ? performance$1.now() : 0;
+	const loadResult = await pluginContainer.load(id);
+	if (loadResult == null) {
+		const file = cleanUrl(id);
+		if (options.skipFsCheck || isFileLoadingAllowed(environment.getTopLevelConfig(), slash(file))) {
+			try {
+				code = await fsp.readFile(file, "utf-8");
+				debugLoad?.(`${timeFrom(loadStart)} [fs] ${prettyUrl}`);
+			} catch (e) {
+				if (e.code !== "ENOENT" && e.code !== "EISDIR") throw e;
+			}
+			if (code != null && environment.pluginContainer.watcher) ensureWatchedFile(environment.pluginContainer.watcher, file, config.root);
+		}
+		if (code) try {
+			const extracted = extractSourcemapFromFile(code, file, logger);
+			if (extracted) {
+				code = extracted.code;
+				map = extracted.map;
+			}
+		} catch (e) {
+			logger.warn(`Failed to load source map for ${file}.\n${e}`, { timestamp: true });
+		}
+	} else {
+		debugLoad?.(`${timeFrom(loadStart)} [plugin] ${prettyUrl}`);
+		if (isObject$1(loadResult)) {
+			code = loadResult.code;
+			map = loadResult.map;
+			moduleType = loadResult.moduleType;
+		} else code = loadResult;
+	}
+	if (code == null) {
+		const isPublicFile = checkPublicFile(url, environment.getTopLevelConfig());
+		let publicDirName = path.relative(config.root, config.publicDir);
+		if (publicDirName[0] !== ".") publicDirName = "/" + publicDirName;
+		const msg = isPublicFile ? `This file is in ${publicDirName} and will be copied as-is during build without going through the plugin transforms, and therefore should not be imported from source code. It can only be referenced via HTML tags.` : `Does the file exist?`;
+		const importerMod = moduleGraph.idToModuleMap.get(id)?.importers.values().next().value;
+		const importer = importerMod?.file || importerMod?.url;
+		const err = /* @__PURE__ */ new Error(`Failed to load url ${url} (resolved id: ${id})${importer ? ` in ${importer}` : ""}. ${msg}`);
+		err.code = isPublicFile ? ERR_LOAD_PUBLIC_URL : ERR_LOAD_URL;
+		throw err;
+	}
+	if (moduleType === void 0) {
+		const guessedModuleType = getModuleTypeFromId(id);
+		if (guessedModuleType && guessedModuleType !== "js") moduleType = guessedModuleType;
+	}
+	if (environment._closing && environment.config.dev.recoverable) throwClosedServerError();
+	mod ??= await moduleGraph._ensureEntryFromUrl(url, void 0, resolved);
+	const transformStart = debugTransform ? performance$1.now() : 0;
+	const transformResult = await pluginContainer.transform(code, id, {
+		inMap: map,
+		moduleType
+	});
+	const originalCode = code;
+	if (transformResult.code === originalCode) debugTransform?.(timeFrom(transformStart) + import_picocolors.default.dim(` [skipped] ${prettyUrl}`));
+	else {
+		debugTransform?.(`${timeFrom(transformStart)} ${prettyUrl}`);
+		code = transformResult.code;
+		map = transformResult.map;
+	}
+	let normalizedMap;
+	if (typeof map === "string") normalizedMap = JSON.parse(map);
+	else if (map) normalizedMap = map;
+	else normalizedMap = null;
+	if (normalizedMap && "version" in normalizedMap && mod.file) {
+		if (normalizedMap.mappings) await injectSourcesContent(normalizedMap, mod.file, logger);
+		const sourcemapPath = `${mod.file}.map`;
+		applySourcemapIgnoreList(normalizedMap, sourcemapPath, config.server.sourcemapIgnoreList, logger);
+		if (path.isAbsolute(mod.file)) {
+			let modDirname;
+			for (let sourcesIndex = 0; sourcesIndex < normalizedMap.sources.length; ++sourcesIndex) {
+				const sourcePath = normalizedMap.sources[sourcesIndex];
+				if (sourcePath) {
+					if (path.isAbsolute(sourcePath)) {
+						modDirname ??= path.dirname(mod.file);
+						normalizedMap.sources[sourcesIndex] = path.relative(modDirname, sourcePath);
+					}
+				}
+			}
+		}
+	}
+	if (environment._closing && environment.config.dev.recoverable) throwClosedServerError();
+	const topLevelConfig = environment.getTopLevelConfig();
+	const result = environment.config.dev.moduleRunnerTransform ? await ssrTransform(code, normalizedMap, url, originalCode, { json: { stringify: topLevelConfig.json.stringify === true && topLevelConfig.json.namedExports !== true } }) : {
+		code,
+		map: normalizedMap,
+		etag: (0, import_etag.default)(code, { weak: true })
+	};
+	if (timestamp > mod.lastInvalidationTimestamp) moduleGraph.updateModuleTransformResult(mod, result);
+	return result;
+}
+/**
+* When a module is soft-invalidated, we can preserve its previous `transformResult` and
+* return similar code to before:
+*
+* - Client: We need to transform the import specifiers with new timestamps
+* - SSR: We don't need to change anything as `ssrLoadModule` controls it
+*/
+async function handleModuleSoftInvalidation(environment, mod, timestamp) {
+	const transformResult = mod.invalidationState;
+	mod.invalidationState = void 0;
+	if (!transformResult || transformResult === "HARD_INVALIDATED") return;
+	if (mod.transformResult) throw new Error(`Internal server error: Soft-invalidated module "${mod.url}" should not have existing transform result`);
+	let result;
+	if (transformResult.ssr) result = transformResult;
+	else {
+		await init;
+		const source = transformResult.code;
+		const s = new MagicString(source);
+		const [imports] = parse$2(source, mod.id || void 0);
+		for (const imp of imports) {
+			let rawUrl = source.slice(imp.s, imp.e);
+			if (rawUrl === "import.meta") continue;
+			const hasQuotes = rawUrl[0] === "\"" || rawUrl[0] === "'";
+			if (hasQuotes) rawUrl = rawUrl.slice(1, -1);
+			const urlWithoutTimestamp = removeTimestampQuery(rawUrl);
+			const hmrUrl = unwrapId(stripBase(removeImportQuery(urlWithoutTimestamp), environment.config.base));
+			for (const importedMod of mod.importedModules) {
+				if (importedMod.url !== hmrUrl) continue;
+				if (importedMod.lastHMRTimestamp > 0) {
+					const replacedUrl = injectQuery(urlWithoutTimestamp, `t=${importedMod.lastHMRTimestamp}`);
+					const start = hasQuotes ? imp.s + 1 : imp.s;
+					const end = hasQuotes ? imp.e - 1 : imp.e;
+					s.overwrite(start, end, replacedUrl);
+				}
+				if (imp.d === -1 && environment.config.dev.preTransformRequests) environment.warmupRequest(hmrUrl);
+				break;
+			}
+		}
+		const code = s.toString();
+		result = {
+			...transformResult,
+			code,
+			etag: (0, import_etag.default)(code, { weak: true })
+		};
+	}
+	if (timestamp > mod.lastInvalidationTimestamp) environment.moduleGraph.updateModuleTransformResult(mod, result);
+	return result;
+}
+const defaultModuleTypes = {
+	js: "js",
+	mjs: "js",
+	cjs: "js",
+	jsx: "jsx",
+	ts: "ts",
+	mts: "ts",
+	cts: "ts",
+	tsx: "tsx",
+	json: "json",
+	txt: "text",
+	css: "css"
+};
+function getModuleTypeFromId(id) {
+	let pos = -1;
+	while ((pos = id.indexOf(".", pos + 1)) >= 0) {
+		const moduleType = defaultModuleTypes[id.slice(pos + 1)];
+		if (moduleType) return moduleType;
+	}
+}
+//#endregion
+//#region src/node/server/warmup.ts
+function warmupFiles(server, environment) {
+	const { root } = server.config;
+	mapFiles(environment.config.dev.warmup, root).then((files) => {
+		for (const file of files) warmupFile(server, environment, file);
+	});
+}
+async function warmupFile(server, environment, file) {
+	if (file.endsWith(".html")) {
+		const url = htmlFileToUrl(file, server.config.root);
+		if (url) try {
+			const html = await fsp.readFile(file, "utf-8");
+			await server.transformIndexHtml(url, html);
+		} catch (e) {
+			environment.logger.error(`Pre-transform error (${import_picocolors.default.cyan(file)}): ${e.message}`, {
+				error: e,
+				timestamp: true
+			});
+		}
+	} else {
+		const url = fileToUrl(file, server.config.root);
+		await environment.warmupRequest(url);
+	}
+}
+function htmlFileToUrl(file, root) {
+	const url = path.relative(root, file);
+	if (url[0] === ".") return;
+	return "/" + normalizePath(url);
+}
+function fileToUrl(file, root) {
+	const url = path.relative(root, file);
+	if (url[0] === ".") return path.posix.join(FS_PREFIX, normalizePath(file));
+	return "/" + normalizePath(url);
+}
+async function mapFiles(files, root) {
+	if (!files.length) return [];
+	const result = [];
+	const globs = [];
+	for (const file of files) if (isDynamicPattern(file)) globs.push(file);
+	else if (path.isAbsolute(file)) result.push(file);
+	else result.push(path.resolve(root, file));
+	if (globs.length) result.push(...await glob(globs, {
+		absolute: true,
+		cwd: root,
+		expandDirectories: false,
+		ignore: ["**/.git/**", "**/node_modules/**"]
+	}));
+	return result;
+}
+//#endregion
+//#region src/node/server/environment.ts
+var DevEnvironment = class extends BaseEnvironment {
+	mode = "dev";
+	moduleGraph;
+	depsOptimizer;
+	/**
+	* @internal
+	*/
+	_remoteRunnerOptions;
+	/**
+	* @internal
+	*/
+	_skipFsCheck;
+	get pluginContainer() {
+		if (!this._pluginContainer) throw new Error(`${this.name} environment.pluginContainer called before initialized`);
+		return this._pluginContainer;
+	}
+	/**
+	* @internal
+	*/
+	_pluginContainer;
+	/**
+	* @internal
+	*/
+	_closing = false;
+	/**
+	* @internal
+	*/
+	_pendingRequests;
+	/**
+	* @internal
+	*/
+	_crawlEndFinder;
+	/**
+	* Hot channel for this environment. If not provided or disabled,
+	* it will be a noop channel that does nothing.
+	*
+	* @example
+	* environment.hot.send({ type: 'full-reload' })
+	*/
+	hot;
+	constructor(name, config, context) {
+		let options = config.environments[name];
+		if (!options) throw new Error(`Environment "${name}" is not defined in the config.`);
+		if (context.options) options = mergeConfig(options, context.options);
+		super(name, config, options);
+		this._pendingRequests = /* @__PURE__ */ new Map();
+		this.moduleGraph = new EnvironmentModuleGraph(name, (url) => this.pluginContainer.resolveId(url, void 0));
+		this._crawlEndFinder = setupOnCrawlEnd();
+		this._remoteRunnerOptions = context.remoteRunner ?? {};
+		this._skipFsCheck = !!(context.transport && !(isWebSocketServer in context.transport) && context.transport.skipFsCheck);
+		this.hot = context.transport ? isWebSocketServer in context.transport ? context.transport : normalizeHotChannel(context.transport, context.hot) : normalizeHotChannel({}, context.hot);
+		this.hot.setInvokeHandler({
+			fetchModule: (id, importer, options) => {
+				if (context.disableFetchModule) throw new Error("fetchModule is disabled in this environment");
+				return this.fetchModule(id, importer, options);
+			},
+			getBuiltins: async () => {
+				return this.config.resolve.builtins.map((builtin) => typeof builtin === "string" ? {
+					type: "string",
+					value: builtin
+				} : {
+					type: "RegExp",
+					source: builtin.source,
+					flags: builtin.flags
+				});
+			}
+		});
+		this.hot.on("vite:invalidate", ({ path, message, firstInvalidatedBy }, client) => {
+			this.invalidateModule({
+				path,
+				message,
+				firstInvalidatedBy
+			}, client);
+		});
+		if (!context.disableDepsOptimizer) {
+			const { optimizeDeps } = this.config;
+			if (context.depsOptimizer) this.depsOptimizer = context.depsOptimizer;
+			else if (isDepOptimizationDisabled(optimizeDeps)) this.depsOptimizer = void 0;
+			else this.depsOptimizer = (optimizeDeps.noDiscovery ? createExplicitDepsOptimizer : createDepsOptimizer)(this);
+		}
+	}
+	async init(options) {
+		if (this._initiated) return;
+		this._initiated = true;
+		this._pluginContainer = await createEnvironmentPluginContainer(this, this.config.plugins, options?.watcher);
+	}
+	/**
+	* When the dev server is restarted, the methods are called in the following order:
+	* - new instance `init`
+	* - previous instance `close`
+	* - new instance `listen`
+	*/
+	async listen(server) {
+		this.hot.listen();
+		await this.depsOptimizer?.init();
+		warmupFiles(server, this);
+	}
+	/**
+	* Called by the module runner to retrieve information about the specified
+	* module. Internally calls `transformRequest` and wraps the result in the
+	* format that the module runner understands.
+	* This method is not meant to be called manually.
+	*/
+	fetchModule(id, importer, options) {
+		return fetchModule(this, id, importer, {
+			...this._remoteRunnerOptions,
+			...options
+		});
+	}
+	async reloadModule(module) {
+		if (this.config.server.hmr !== false && module.file) updateModules(this, module.file, [module], monotonicDateNow());
+	}
+	transformRequest(url) {
+		return transformRequest(this, url, { skipFsCheck: this._skipFsCheck });
+	}
+	async warmupRequest(url) {
+		try {
+			await transformRequest(this, url, { skipFsCheck: true });
+		} catch (e) {
+			if (e?.code === "ERR_OUTDATED_OPTIMIZED_DEP" || e?.code === "ERR_CLOSED_SERVER") return;
+			this.logger.error(buildErrorMessage(e, [`Pre-transform error: ${e.message}`], false), {
+				error: e,
+				timestamp: true
+			});
+		}
+	}
+	invalidateModule(m, _client) {
+		const mod = this.moduleGraph.urlToModuleMap.get(m.path);
+		if (mod && mod.isSelfAccepting && mod.lastHMRTimestamp > 0 && !mod.lastHMRInvalidationReceived) {
+			mod.lastHMRInvalidationReceived = true;
+			this.logger.info(import_picocolors.default.yellow(`hmr invalidate `) + import_picocolors.default.dim(m.path) + (m.message ? ` ${m.message}` : ""), { timestamp: true });
+			const file = getShortName(mod.file, this.config.root);
+			updateModules(this, file, [...mod.importers].filter((imp) => imp !== mod), mod.lastHMRTimestamp, m.firstInvalidatedBy);
+		}
+	}
+	async close() {
+		this._closing = true;
+		this._crawlEndFinder.cancel();
+		await Promise.allSettled([
+			this.pluginContainer.close(),
+			this.depsOptimizer?.close(),
+			isWebSocketServer in this.hot ? Promise.resolve() : this.hot.close(),
+			(async () => {
+				while (this._pendingRequests.size > 0) await Promise.allSettled([...this._pendingRequests.values()].map((pending) => pending.request));
+			})()
+		]);
+	}
+	/**
+	* Calling `await environment.waitForRequestsIdle(id)` will wait until all static imports
+	* are processed after the first transformRequest call. If called from a load or transform
+	* plugin hook, the id needs to be passed as a parameter to avoid deadlocks.
+	* Calling this function after the first static imports section of the module graph has been
+	* processed will resolve immediately.
+	* @experimental
+	*/
+	waitForRequestsIdle(ignoredId) {
+		return this._crawlEndFinder.waitForRequestsIdle(ignoredId);
+	}
+	/**
+	* @internal
+	*/
+	_registerRequestProcessing(id, done) {
+		this._crawlEndFinder.registerRequestProcessing(id, done);
+	}
+};
+const callCrawlEndIfIdleAfterMs = 50;
+function setupOnCrawlEnd() {
+	const registeredIds = /* @__PURE__ */ new Set();
+	const seenIds = /* @__PURE__ */ new Set();
+	const onCrawlEndPromiseWithResolvers = promiseWithResolvers();
+	let timeoutHandle;
+	let cancelled = false;
+	function cancel() {
+		cancelled = true;
+	}
+	function registerRequestProcessing(id, done) {
+		if (!seenIds.has(id)) {
+			seenIds.add(id);
+			registeredIds.add(id);
+			done().catch(() => {}).finally(() => markIdAsDone(id));
+		}
+	}
+	function waitForRequestsIdle(ignoredId) {
+		if (ignoredId) {
+			seenIds.add(ignoredId);
+			markIdAsDone(ignoredId);
+		} else checkIfCrawlEndAfterTimeout();
+		return onCrawlEndPromiseWithResolvers.promise;
+	}
+	function markIdAsDone(id) {
+		registeredIds.delete(id);
+		checkIfCrawlEndAfterTimeout();
+	}
+	function checkIfCrawlEndAfterTimeout() {
+		if (cancelled || registeredIds.size > 0) return;
+		if (timeoutHandle) clearTimeout(timeoutHandle);
+		timeoutHandle = setTimeout(callOnCrawlEndWhenIdle, callCrawlEndIfIdleAfterMs);
+	}
+	function callOnCrawlEndWhenIdle() {
+		if (cancelled || registeredIds.size > 0) return;
+		onCrawlEndPromiseWithResolvers.resolve();
+	}
+	return {
+		registerRequestProcessing,
+		waitForRequestsIdle,
+		cancel
+	};
+}
+//#endregion
+//#region src/node/server/environments/fullBundleEnvironment.ts
+const debug$7 = createDebugger("vite:full-bundle-mode");
+var MemoryFiles = class {
+	files = /* @__PURE__ */ new Map();
+	get size() {
+		return this.files.size;
+	}
+	get(file) {
+		const result = this.files.get(file);
+		if (result === void 0) return;
+		if (typeof result === "function") {
+			const content = result();
+			this.files.set(file, content);
+			return content;
+		}
+		return result;
+	}
+	set(file, content) {
+		this.files.set(file, content);
+	}
+	has(file) {
+		return this.files.has(file);
+	}
+	clear() {
+		this.files.clear();
+	}
+};
+var FullBundleDevEnvironment = class extends DevEnvironment {
+	devEngine;
+	initialBuildCompleted = false;
+	clients = new Clients();
+	invalidateCalledModules = /* @__PURE__ */ new Map();
+	debouncedFullReload = debounce(20, () => {
+		this.hot.send({
+			type: "full-reload",
+			path: "*"
+		});
+		this.logger.info(import_picocolors.default.green(`page reload`), { timestamp: true });
+	});
+	memoryFiles = new MemoryFiles();
+	constructor(name, config, context) {
+		if (name !== "client") throw new Error("currently full bundle mode is only available for client environment");
+		super(name, config, {
+			...context,
+			disableDepsOptimizer: true
+		});
+	}
+	async listen(_server) {
+		this.hot.listen();
+		debug$7?.("INITIAL: setup bundle options");
+		const rollupOptions = await this.getRolldownOptions();
+		if (Array.isArray(rollupOptions.output) && rollupOptions.output.length > 1) throw new Error("multiple output options are not supported in dev mode");
+		const outputOptions = Array.isArray(rollupOptions.output) ? rollupOptions.output[0] : rollupOptions.output;
+		this.hot.on("vite:module-loaded", (payload, client) => {
+			this.clients.setupIfNeeded(client, payload.clientId);
+			this.devEngine.registerModules(payload.clientId, payload.modules);
+		});
+		this.hot.on("vite:client:disconnect", (_payload, client) => {
+			const clientId = this.clients.delete(client);
+			if (clientId) this.devEngine.removeClient(clientId);
+		});
+		this.devEngine = await dev(rollupOptions, outputOptions, {
+			onHmrUpdates: (result) => {
+				if (result instanceof Error) {
+					for (const client of this.clients.getAll()) client.send({
+						type: "error",
+						err: prepareError(result)
+					});
+					return;
+				}
+				const { updates, changedFiles } = result;
+				if (changedFiles.length === 0) return;
+				if (updates.every((update) => update.update.type === "Noop")) {
+					debug$7?.(`ignored file change for ${changedFiles.join(", ")}`);
+					return;
+				}
+				for (const { clientId, update } of updates) {
+					const client = this.clients.get(clientId);
+					if (client) {
+						this.invalidateCalledModules.get(client)?.clear();
+						this.handleHmrOutput(client, changedFiles, update);
+					}
+				}
+			},
+			onOutput: (result) => {
+				if (result instanceof Error) {
+					this.logger.error(import_picocolors.default.red(`✘ Build error: ${result.message}`), { error: result });
+					this.hot.send({
+						type: "error",
+						err: prepareError(result)
+					});
+					return;
+				}
+				for (const outputFile of result.output) this.memoryFiles.set(outputFile.fileName, () => {
+					const source = outputFile.type === "chunk" ? outputFile.code : outputFile.source;
+					return {
+						source,
+						etag: (0, import_etag.default)(Buffer.from(source), { weak: true })
+					};
+				});
+			},
+			watch: { skipWrite: true }
+		});
+		debug$7?.("INITIAL: setup dev engine");
+		this.devEngine.run().then(() => {
+			debug$7?.("INITIAL: run done");
+		}, (e) => {
+			debug$7?.("INITIAL: run error", e);
+		});
+		this.waitForInitialBuildFinish().then(() => {
+			debug$7?.("INITIAL: build done");
+			this.hot.send({
+				type: "full-reload",
+				path: "*"
+			});
+			this.initialBuildCompleted = true;
+		});
+	}
+	async waitForInitialBuildFinish() {
+		await this.devEngine.ensureCurrentBuildFinish();
+		while (this.memoryFiles.size === 0) {
+			await setTimeout$1(10);
+			await this.devEngine.ensureCurrentBuildFinish();
+		}
+	}
+	async warmupRequest(_url) {}
+	invalidateModule(m, client) {
+		(async () => {
+			const invalidateCalledModules = this.invalidateCalledModules.get(client);
+			if (invalidateCalledModules?.has(m.path)) {
+				debug$7?.(`INVALIDATE: invalidate received from ${m.path}, but ignored because it was already invalidated`);
+				return;
+			}
+			debug$7?.(`INVALIDATE: invalidate received from ${m.path}, re-triggering HMR`);
+			if (!invalidateCalledModules) this.invalidateCalledModules.set(client, /* @__PURE__ */ new Set([]));
+			this.invalidateCalledModules.get(client).add(m.path);
+			let update;
+			try {
+				update = (await this.devEngine.invalidate(m.path, m.firstInvalidatedBy)).find((u) => this.clients.get(u.clientId) === client)?.update;
+			} catch (e) {
+				client.send({
+					type: "error",
+					err: prepareError(e)
+				});
+				return;
+			}
+			if (!update) return;
+			if (update.type === "Patch") this.logger.info(import_picocolors.default.yellow(`hmr invalidate `) + import_picocolors.default.dim(m.path) + (m.message ? ` ${m.message}` : ""), { timestamp: true });
+			this.handleHmrOutput(client, [m.path], update, { firstInvalidatedBy: m.firstInvalidatedBy });
+		})();
+	}
+	async triggerBundleRegenerationIfStale() {
+		const bundleState = await this.devEngine.getBundleState();
+		const shouldTrigger = bundleState.hasStaleOutput && !bundleState.lastFullBuildFailed && this.initialBuildCompleted;
+		if (shouldTrigger) {
+			this.devEngine.ensureLatestBuildOutput().then(() => {
+				this.debouncedFullReload();
+			});
+			debug$7?.(`TRIGGER: access to stale bundle, triggered bundle re-generation`);
+		}
+		return shouldTrigger;
+	}
+	async triggerLazyBundling(moduleId, clientId) {
+		if (!moduleId || !clientId) return;
+		debug$7?.(`TRIGGER-LAZY: trigger lazy bundling for module ${moduleId} for client ${clientId}`);
+		return await this.devEngine.compileEntry(moduleId, clientId);
+	}
+	async close() {
+		this.memoryFiles.clear();
+		await Promise.all([super.close(), this.devEngine.close()]);
+		this.initialBuildCompleted = false;
+	}
+	async getRolldownOptions() {
+		const chunkMetadataMap = new ChunkMetadataMap();
+		const rolldownOptions = resolveRolldownOptions(this, chunkMetadataMap);
+		rolldownOptions.experimental ??= {};
+		rolldownOptions.experimental.devMode = {
+			lazy: true,
+			...typeof rolldownOptions.experimental.devMode === "object" ? rolldownOptions.experimental.devMode : {},
+			implement: await getHmrImplementation(this.getTopLevelConfig())
+		};
+		rolldownOptions.optimization ??= {};
+		rolldownOptions.optimization.inlineConst = false;
+		if (Array.isArray(rolldownOptions.output)) for (const output of rolldownOptions.output) {
+			output.entryFileNames = "assets/[name].js";
+			output.chunkFileNames = "assets/[name]-[hash].js";
+			output.assetFileNames = "assets/[name]-[hash][extname]";
+			output.minify = false;
+			output.sourcemap = true;
+		}
+		else {
+			rolldownOptions.output ??= {};
+			rolldownOptions.output.entryFileNames = "assets/[name].js";
+			rolldownOptions.output.chunkFileNames = "assets/[name]-[hash].js";
+			rolldownOptions.output.assetFileNames = "assets/[name]-[hash][extname]";
+			rolldownOptions.output.minify = false;
+			rolldownOptions.output.sourcemap = true;
+		}
+		return rolldownOptions;
+	}
+	handleHmrOutput(client, files, hmrOutput, invalidateInformation) {
+		if (hmrOutput.type === "Noop") return;
+		const shortFile = files.map((file) => getShortName(file, this.config.root)).join(", ");
+		if (hmrOutput.type === "FullReload") {
+			const reason = hmrOutput.reason ? import_picocolors.default.dim(` (${hmrOutput.reason})`) : "";
+			this.logger.info(import_picocolors.default.green(`trigger page reload `) + import_picocolors.default.dim(shortFile) + reason, {
+				clear: !invalidateInformation,
+				timestamp: true
+			});
+			this.devEngine.ensureLatestBuildOutput().then(() => {
+				this.debouncedFullReload();
+			});
+			return;
+		}
+		debug$7?.(`handle hmr output for ${shortFile}`, {
+			...hmrOutput,
+			code: typeof hmrOutput.code === "string" ? "[code]" : hmrOutput.code
+		});
+		this.memoryFiles.set(hmrOutput.filename, { source: hmrOutput.code + "\n; export {}" });
+		if (hmrOutput.sourcemapFilename && hmrOutput.sourcemap) this.memoryFiles.set(hmrOutput.sourcemapFilename, { source: hmrOutput.sourcemap });
+		const updates = hmrOutput.hmrBoundaries.map((boundary) => {
+			return {
+				type: "js-update",
+				url: hmrOutput.filename,
+				path: boundary.boundary,
+				acceptedPath: boundary.acceptedVia,
+				firstInvalidatedBy: invalidateInformation?.firstInvalidatedBy,
+				timestamp: Date.now()
+			};
+		});
+		client.send({
+			type: "update",
+			updates
+		});
+		const filePaths = [...new Set(updates.map((u) => u.path))];
+		const { formatted, truncated } = formatAndTruncateFileList(filePaths);
+		if (truncated) debugHmr?.(`hmr update ${filePaths.join(", ")}`);
+		this.logger.info(import_picocolors.default.green(`hmr update `) + import_picocolors.default.dim(formatted), {
+			clear: !invalidateInformation,
+			timestamp: true
+		});
+	}
+};
+var Clients = class {
+	clientToId = /* @__PURE__ */ new Map();
+	idToClient = /* @__PURE__ */ new Map();
+	setupIfNeeded(client, clientId) {
+		const id = this.clientToId.get(client);
+		if (id && id !== clientId) throw new Error("client ID conflict detected. Please restart the dev server.");
+		this.clientToId.set(client, clientId);
+		this.idToClient.set(clientId, client);
+	}
+	get(id) {
+		return this.idToClient.get(id);
+	}
+	getAll() {
+		return Array.from(this.idToClient.values());
+	}
+	delete(client) {
+		const id = this.clientToId.get(client);
+		if (id) {
+			this.clientToId.delete(client);
+			this.idToClient.delete(id);
+			return id;
+		}
+	}
+};
+function debounce(time, cb) {
+	let timer;
+	return () => {
+		if (timer) {
+			globalThis.clearTimeout(timer);
+			timer = null;
+		}
+		timer = globalThis.setTimeout(cb, time);
+	};
+}
+//#endregion
+//#region src/node/server/middlewares/htmlFallback.ts
+const debug$6 = createDebugger("vite:html-fallback");
+function htmlFallbackMiddleware(root, spaFallback, clientEnvironment) {
+	const memoryFiles = clientEnvironment instanceof FullBundleDevEnvironment ? clientEnvironment.memoryFiles : void 0;
+	function checkFileExists(relativePath) {
+		return memoryFiles?.has(relativePath.slice(1)) ?? fs.existsSync(path.join(root, relativePath));
+	}
+	return function viteHtmlFallbackMiddleware(req, _res, next) {
+		if (req.method !== "GET" && req.method !== "HEAD" || req.url === "/favicon.ico" || !(req.headers.accept === void 0 || req.headers.accept === "" || req.headers.accept.includes("text/html") || req.headers.accept.includes("*/*"))) return next();
+		const url = cleanUrl(req.url);
+		let pathname;
+		try {
+			pathname = decodeURIComponent(url);
+		} catch {
+			return next();
+		}
+		if (pathname.endsWith(".html")) {
+			if (checkFileExists(pathname)) {
+				debug$6?.(`Rewriting ${req.method} ${req.url} to ${url}`);
+				req.url = url;
+				return next();
+			}
+		} else if (pathname.endsWith("/")) {
+			if (checkFileExists(joinUrlSegments(pathname, "index.html"))) {
+				const newUrl = url + "index.html";
+				debug$6?.(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
+				req.url = newUrl;
+				return next();
+			}
+		} else if (checkFileExists(pathname + ".html")) {
+			const newUrl = url + ".html";
+			debug$6?.(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
+			req.url = newUrl;
+			return next();
+		}
+		if (spaFallback) {
+			debug$6?.(`Rewriting ${req.method} ${req.url} to /index.html`);
+			req.url = "/index.html";
+		}
+		next();
+	};
+}
+//#endregion
+//#region src/node/server/middlewares/indexHtml.ts
+function createDevHtmlTransformFn(config) {
+	const [preHooks, normalHooks, postHooks] = resolveHtmlTransforms(config.plugins);
+	const transformHooks = [
+		preImportMapHook(config),
+		injectCspNonceMetaTagHook(config),
+		...preHooks,
+		htmlEnvHook(config),
+		devHtmlHook,
+		...normalHooks,
+		...postHooks,
+		injectNonceAttributeTagHook(config),
+		postImportMapHook()
+	];
+	const pluginContext = new BasicMinimalPluginContext({
+		...basePluginContextMeta,
+		watchMode: true
+	}, config.logger);
+	return (server, url, html, originalUrl) => {
+		return applyHtmlTransforms(html, transformHooks, pluginContext, {
+			path: url,
+			filename: getHtmlFilename(url, server),
+			server,
+			originalUrl
+		});
+	};
+}
+function getHtmlFilename(url, server) {
+	if (url.startsWith(FS_PREFIX)) return decodeURIComponent(fsPathFromId(url));
+	else return decodeURIComponent(normalizePath(path.join(server.config.root, url.slice(1))));
+}
+function shouldPreTransform(url, config) {
+	return !checkPublicFile(url, config) && (isJSRequest(url) || isCSSRequest(url));
+}
+const wordCharRE = /\w/;
+function isBareRelative(url) {
+	return wordCharRE.test(url[0]) && !url.includes(":");
+}
+const processNodeUrl = (url, useSrcSetReplacer, config, htmlPath, originalUrl, server, isClassicScriptLink) => {
+	const replacer = (url) => {
+		if (url[0] === "/" && url[1] !== "/" || (url[0] === "." || isBareRelative(url)) && originalUrl && originalUrl !== "/" && htmlPath === "/index.html") url = path.posix.join(config.base, url);
+		let preTransformUrl;
+		if (!isClassicScriptLink && shouldPreTransform(url, config)) {
+			if (url[0] === "/" && url[1] !== "/") preTransformUrl = url;
+			else if (url[0] === "." || isBareRelative(url)) preTransformUrl = path.posix.join(config.base, path.posix.dirname(htmlPath), url);
+		}
+		if (server) {
+			const mod = server.environments.client.moduleGraph.urlToModuleMap.get(preTransformUrl || url);
+			if (mod && mod.lastHMRTimestamp > 0) url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
+		}
+		if (server && preTransformUrl) {
+			try {
+				preTransformUrl = decodeURI(preTransformUrl);
+			} catch {
+				return url;
+			}
+			preTransformRequest(server, preTransformUrl, config.decodedBase);
+		}
+		return url;
+	};
+	return useSrcSetReplacer ? processSrcSetSync(url, ({ url }) => replacer(url)) : replacer(url);
+};
+const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl }) => {
+	const { config, watcher } = server;
+	const base = config.base || "/";
+	const decodedBase = config.decodedBase || "/";
+	let proxyModulePath;
+	let proxyModuleUrl;
+	const trailingSlash = htmlPath.endsWith("/");
+	if (!trailingSlash && fs.existsSync(filename)) {
+		proxyModulePath = htmlPath;
+		proxyModuleUrl = proxyModulePath;
+	} else {
+		proxyModulePath = `\0${`${htmlPath}${trailingSlash ? "index.html" : ""}`}`;
+		proxyModuleUrl = wrapId(proxyModulePath);
+	}
+	proxyModuleUrl = joinUrlSegments(decodedBase, proxyModuleUrl);
+	const s = new MagicString(html);
+	let inlineModuleIndex = -1;
+	const proxyCacheUrl = decodeURI(cleanUrl(proxyModulePath).replace(normalizePath(config.root), ""));
+	const styleUrl = [];
+	const inlineStyles = [];
+	const inlineModulePaths = [];
+	const addInlineModule = (node, ext) => {
+		inlineModuleIndex++;
+		const contentNode = node.childNodes[0];
+		const code = contentNode.value;
+		let map;
+		if (proxyModulePath[0] !== "\0") {
+			map = new MagicString(html).snip(contentNode.sourceCodeLocation.startOffset, contentNode.sourceCodeLocation.endOffset).generateMap({ hires: "boundary" });
+			map.sources = [filename];
+			map.file = filename;
+		}
+		addToHTMLProxyCache(config, proxyCacheUrl, inlineModuleIndex, {
+			code,
+			map
+		});
+		const modulePath = `${proxyModuleUrl}?html-proxy&index=${inlineModuleIndex}.${ext}`;
+		inlineModulePaths.push(modulePath);
+		s.update(node.sourceCodeLocation.startOffset, node.sourceCodeLocation.endOffset, `<script type="module" src="${modulePath}"><\/script>`);
+		preTransformRequest(server, modulePath, decodedBase);
+	};
+	await traverseHtml(html, filename, config.logger.warn, (node) => {
+		if (!nodeIsElement(node)) return;
+		if (node.nodeName === "script") {
+			const { src, srcSourceCodeLocation, isModule, isIgnored } = getScriptInfo(node);
+			if (isIgnored) removeViteIgnoreAttr(s, node.sourceCodeLocation);
+			else if (src) {
+				const processedUrl = processNodeUrl(src.value, false, config, htmlPath, originalUrl, server, !isModule);
+				if (processedUrl !== src.value) overwriteAttrValue(s, srcSourceCodeLocation, processedUrl);
+			} else if (isModule && node.childNodes.length) addInlineModule(node, "js");
+			else if (node.childNodes.length) {
+				const scriptNode = node.childNodes[node.childNodes.length - 1];
+				for (const { url, start, end } of extractImportExpressionFromClassicScript(scriptNode)) {
+					const processedUrl = processNodeUrl(url, false, config, htmlPath, originalUrl);
+					if (processedUrl !== url) s.update(start, end, processedUrl);
+				}
+			}
+		}
+		const inlineStyle = findNeedTransformStyleAttribute(node);
+		if (inlineStyle) {
+			inlineModuleIndex++;
+			inlineStyles.push({
+				index: inlineModuleIndex,
+				location: inlineStyle.location,
+				code: inlineStyle.attr.value
+			});
+		}
+		if (node.nodeName === "style" && node.childNodes.length) {
+			const children = node.childNodes[0];
+			styleUrl.push({
+				start: children.sourceCodeLocation.startOffset,
+				end: children.sourceCodeLocation.endOffset,
+				code: children.value
+			});
+		}
+		const assetAttributes = getNodeAssetAttributes(node);
+		for (const attr of assetAttributes) if (attr.type === "remove") s.remove(attr.location.startOffset, attr.location.endOffset);
+		else {
+			const processedUrl = processNodeUrl(attr.value, attr.type === "srcset", config, htmlPath, originalUrl);
+			if (processedUrl !== attr.value) overwriteAttrValue(s, attr.location, processedUrl);
+		}
+	});
+	const clientModuleGraph = server?.environments.client.moduleGraph;
+	if (clientModuleGraph) await Promise.all(inlineModulePaths.map(async (url) => {
+		const module = await clientModuleGraph.getModuleByUrl(url);
+		if (module) clientModuleGraph.invalidateModule(module);
+	}));
+	await Promise.all([...styleUrl.map(async ({ start, end, code }, index) => {
+		const url = `${proxyModulePath}?html-proxy&direct&index=${index}.css`;
+		const mod = await server.environments.client.moduleGraph.ensureEntryFromUrl(url, false);
+		ensureWatchedFile(watcher, mod.file, config.root);
+		const result = await server.environments.client.pluginContainer.transform(code, mod.id);
+		let content = "";
+		if (result.map && "version" in result.map) {
+			if (result.map.mappings) await injectSourcesContent(result.map, proxyModulePath, config.logger);
+			content = getCodeWithSourcemap("css", result.code, result.map);
+		} else content = result.code;
+		s.overwrite(start, end, content);
+	}), ...inlineStyles.map(async ({ index, location, code }) => {
+		const url = `${proxyModulePath}?html-proxy&inline-css&style-attr&index=${index}.css`;
+		const mod = await server.environments.client.moduleGraph.ensureEntryFromUrl(url, false);
+		ensureWatchedFile(watcher, mod.file, config.root);
+		await server?.environments.client.pluginContainer.transform(code, mod.id);
+		const hash = getHash(cleanUrl(mod.id));
+		overwriteAttrValue(s, location, htmlProxyResult.get(`${hash}_${index}`) ?? "");
+	})]);
+	html = s.toString();
+	return {
+		html,
+		tags: [{
+			tag: "script",
+			attrs: {
+				type: "module",
+				src: path.posix.join(base, CLIENT_PUBLIC_PATH)
+			},
+			injectTo: "head-prepend"
+		}]
+	};
+};
+function indexHtmlMiddleware(root, server) {
+	const isDev = isDevServer(server);
+	const fullBundleEnv = isDev && server.environments.client instanceof FullBundleDevEnvironment ? server.environments.client : void 0;
+	return async function viteIndexHtmlMiddleware(req, res, next) {
+		if (res.writableEnded) return next();
+		const url = req.url && cleanUrl(req.url);
+		if (url?.endsWith(".html") && req.headers["sec-fetch-dest"] !== "script") {
+			if (fullBundleEnv) {
+				const filePath = decodeURIComponent(url).slice(1);
+				let file = fullBundleEnv.memoryFiles.get(filePath);
+				if (!file && fullBundleEnv.memoryFiles.size !== 0) return next();
+				if ([
+					"document",
+					"iframe",
+					"frame",
+					"fencedframe",
+					"",
+					void 0
+				].includes(req.headers["sec-fetch-dest"]) && (await fullBundleEnv.triggerBundleRegenerationIfStale() || file === void 0)) file = { source: await generateFallbackHtml(server) };
+				if (!file) return next();
+				return send(req, res, typeof file.source === "string" ? file.source : Buffer.from(file.source), "html", {
+					headers: isDev ? server.config.server.headers : server.config.preview.headers,
+					etag: file.etag
+				});
+			}
+			let filePath;
+			if (isDev && url.startsWith(FS_PREFIX)) filePath = decodeURIComponent(fsPathFromId(url));
+			else filePath = normalizePath(path.resolve(path.join(root, decodeURIComponent(url))));
+			if (isDev) {
+				const servingAccessResult = checkLoadingAccess(server.config, filePath);
+				if (servingAccessResult === "denied") return respondWithAccessDenied(filePath, server, res);
+				if (servingAccessResult === "fallback") return next();
+			} else if (!isParentDirectory(root, filePath)) return next();
+			if (fs.existsSync(filePath)) {
+				const headers = isDev ? server.config.server.headers : server.config.preview.headers;
+				try {
+					let html = await fsp.readFile(filePath, "utf-8");
+					if (isDev) html = await server.transformIndexHtml(url, html, req.originalUrl);
+					return send(req, res, html, "html", { headers });
+				} catch (e) {
+					return next(e);
+				}
+			}
+		}
+		next();
+	};
+}
+function preTransformRequest(server, decodedUrl, decodedBase) {
+	if (!server.config.server.preTransformRequests) return;
+	decodedUrl = unwrapId(stripBase(decodedUrl, decodedBase));
+	server.warmupRequest(decodedUrl);
+}
+async function generateFallbackHtml(server) {
+	return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <script type="module">
+    ${(await getHmrImplementation(server.config)).replaceAll("<\/script>", "<\\/script>")}
+  <\/script>
+  <style>
+    :root {
+      --page-bg: #ffffff;
+      --text-color: #1d1d1f;
+      --spinner-track: #f5f5f7;
+      --spinner-accent: #0071e3;
+    }
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --page-bg: #1e1e1e;
+        --text-color: #f5f5f5;
+        --spinner-track: #424242;
+      }
+    }
+
+    body {
+      margin: 0;
+      min-height: 100vh;
+      display: flex;
+      background-color: var(--page-bg);
+      color: var(--text-color);
+    }
+
+    .container {
+      margin: auto;
+      padding: 2rem;
+      text-align: center;
+      border-radius: 1rem;
+    }
+
+    .spinner {
+      width: 3rem;
+      height: 3rem;
+      margin: 2rem auto;
+      border: 3px solid var(--spinner-track);
+      border-top-color: var(--spinner-accent);
+      border-radius: 50%;
+      animation: spin 1s linear infinite;
+    }
+
+    @keyframes spin { to { transform: rotate(360deg) } }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Bundling in progress</h1>
+    <p>The page will automatically reload when ready.</p>
+    <div class="spinner"></div>
+  </div>
+</body>
+</html>
+`;
+}
+//#endregion
+//#region src/node/server/middlewares/time.ts
+const logTime = createDebugger("vite:time");
+function timeMiddleware(root) {
+	return function viteTimeMiddleware(req, res, next) {
+		const start = performance$1.now();
+		const end = res.end;
+		res.end = (...args) => {
+			logTime?.(`${timeFrom(start)} ${prettifyUrl(req.url, root)}`);
+			return end.call(res, ...args);
+		};
+		next();
+	};
+}
+//#endregion
+//#region src/node/server/mixedModuleGraph.ts
+/**
+* Backward compatible ModuleNode and ModuleGraph with mixed nodes from both the client and ssr environments
+* It would be good to take the types names for the new EnvironmentModuleNode and EnvironmentModuleGraph but we can't
+* do that at this point without breaking to much code in the ecosystem.
+* We are going to deprecate these types and we can try to use them back in the future.
+*/
+const EMPTY_OBJECT$1 = Object.freeze({});
+var ModuleNode = class {
+	_moduleGraph;
+	_clientModule;
+	_ssrModule;
+	constructor(moduleGraph, clientModule, ssrModule) {
+		this._moduleGraph = moduleGraph;
+		this._clientModule = clientModule;
+		this._ssrModule = ssrModule;
+	}
+	_get(prop) {
+		return this._clientModule?.[prop] ?? this._ssrModule?.[prop];
+	}
+	_set(prop, value) {
+		if (this._clientModule) this._clientModule[prop] = value;
+		if (this._ssrModule) this._ssrModule[prop] = value;
+	}
+	_wrapModuleSet(prop, module) {
+		if (!module) return /* @__PURE__ */ new Set();
+		return createBackwardCompatibleModuleSet(this._moduleGraph, prop, module);
+	}
+	_getModuleSetUnion(prop) {
+		const importedModules = /* @__PURE__ */ new Set();
+		const ids = /* @__PURE__ */ new Set();
+		if (this._clientModule) for (const mod of this._clientModule[prop]) {
+			if (mod.id) ids.add(mod.id);
+			importedModules.add(this._moduleGraph.getBackwardCompatibleModuleNode(mod));
+		}
+		if (this._ssrModule) {
+			for (const mod of this._ssrModule[prop]) if (mod.id && !ids.has(mod.id)) importedModules.add(this._moduleGraph.getBackwardCompatibleModuleNode(mod));
+		}
+		return importedModules;
+	}
+	_getModuleInfoUnion(prop) {
+		const _clientValue = this._clientModule?.[prop];
+		const _ssrValue = this._ssrModule?.[prop];
+		if (_clientValue == null && _ssrValue == null) return void 0;
+		return new Proxy({}, { get: (_, key) => {
+			if (key === "meta") return this.meta || EMPTY_OBJECT$1;
+			if (_clientValue) {
+				if (key in _clientValue) return _clientValue[key];
+			}
+			if (_ssrValue) {
+				if (key in _ssrValue) return _ssrValue[key];
+			}
+		} });
+	}
+	_getModuleObjectUnion(prop) {
+		const _clientValue = this._clientModule?.[prop];
+		const _ssrValue = this._ssrModule?.[prop];
+		if (_clientValue == null && _ssrValue == null) return void 0;
+		const info = {};
+		if (_ssrValue) Object.assign(info, _ssrValue);
+		if (_clientValue) Object.assign(info, _clientValue);
+		return info;
+	}
+	get url() {
+		return this._get("url");
+	}
+	set url(value) {
+		this._set("url", value);
+	}
+	get id() {
+		return this._get("id");
+	}
+	set id(value) {
+		this._set("id", value);
+	}
+	get file() {
+		return this._get("file");
+	}
+	set file(value) {
+		this._set("file", value);
+	}
+	get type() {
+		return this._get("type");
+	}
+	get info() {
+		return this._getModuleInfoUnion("info");
+	}
+	get meta() {
+		return this._getModuleObjectUnion("meta");
+	}
+	get importers() {
+		return this._getModuleSetUnion("importers");
+	}
+	get clientImportedModules() {
+		return this._wrapModuleSet("importedModules", this._clientModule);
+	}
+	get ssrImportedModules() {
+		return this._wrapModuleSet("importedModules", this._ssrModule);
+	}
+	get importedModules() {
+		return this._getModuleSetUnion("importedModules");
+	}
+	get acceptedHmrDeps() {
+		return this._wrapModuleSet("acceptedHmrDeps", this._clientModule);
+	}
+	get acceptedHmrExports() {
+		return this._clientModule?.acceptedHmrExports ?? null;
+	}
+	get importedBindings() {
+		return this._clientModule?.importedBindings ?? null;
+	}
+	get isSelfAccepting() {
+		return this._clientModule?.isSelfAccepting;
+	}
+	get transformResult() {
+		return this._clientModule?.transformResult ?? null;
+	}
+	set transformResult(value) {
+		if (this._clientModule) this._clientModule.transformResult = value;
+	}
+	get ssrTransformResult() {
+		return this._ssrModule?.transformResult ?? null;
+	}
+	set ssrTransformResult(value) {
+		if (this._ssrModule) this._ssrModule.transformResult = value;
+	}
+	get ssrModule() {
+		return this._ssrModule?.ssrModule ?? null;
+	}
+	get ssrError() {
+		return this._ssrModule?.ssrError ?? null;
+	}
+	get lastHMRTimestamp() {
+		return Math.max(this._clientModule?.lastHMRTimestamp ?? 0, this._ssrModule?.lastHMRTimestamp ?? 0);
+	}
+	set lastHMRTimestamp(value) {
+		if (this._clientModule) this._clientModule.lastHMRTimestamp = value;
+		if (this._ssrModule) this._ssrModule.lastHMRTimestamp = value;
+	}
+	get lastInvalidationTimestamp() {
+		return Math.max(this._clientModule?.lastInvalidationTimestamp ?? 0, this._ssrModule?.lastInvalidationTimestamp ?? 0);
+	}
+	get invalidationState() {
+		return this._clientModule?.invalidationState;
+	}
+	get ssrInvalidationState() {
+		return this._ssrModule?.invalidationState;
+	}
+};
+function mapIterator(iterable, transform) {
+	return {
+		[Symbol.iterator]() {
+			return this;
+		},
+		next() {
+			const r = iterable.next();
+			return r.done ? r : {
+				value: transform(r.value),
+				done: false
+			};
+		}
+	};
+}
+var ModuleGraph = class {
+	/** @internal */
+	_moduleGraphs;
+	/** @internal */
+	get _client() {
+		return this._moduleGraphs.client();
+	}
+	/** @internal */
+	get _ssr() {
+		return this._moduleGraphs.ssr();
+	}
+	urlToModuleMap;
+	idToModuleMap;
+	etagToModuleMap;
+	fileToModulesMap;
+	moduleNodeCache = new DualWeakMap();
+	constructor(moduleGraphs) {
+		this._moduleGraphs = moduleGraphs;
+		const getModuleMapUnion = (prop) => () => {
+			if (this._ssr[prop].size === 0) return this._client[prop];
+			const map = new Map(this._client[prop]);
+			for (const [key, module] of this._ssr[prop]) if (!map.has(key)) map.set(key, module);
+			return map;
+		};
+		this.urlToModuleMap = createBackwardCompatibleModuleMap(this, "urlToModuleMap", getModuleMapUnion("urlToModuleMap"));
+		this.idToModuleMap = createBackwardCompatibleModuleMap(this, "idToModuleMap", getModuleMapUnion("idToModuleMap"));
+		this.etagToModuleMap = createBackwardCompatibleModuleMap(this, "etagToModuleMap", () => this._client.etagToModuleMap);
+		this.fileToModulesMap = createBackwardCompatibleFileToModulesMap(this);
+	}
+	getModuleById(id) {
+		const clientModule = this._client.getModuleById(id);
+		const ssrModule = this._ssr.getModuleById(id);
+		if (!clientModule && !ssrModule) return;
+		return this.getBackwardCompatibleModuleNodeDual(clientModule, ssrModule);
+	}
+	async getModuleByUrl(url, _ssr) {
+		const [clientModule, ssrModule] = await Promise.all([this._client.getModuleByUrl(url), this._ssr.getModuleByUrl(url)]);
+		if (!clientModule && !ssrModule) return;
+		return this.getBackwardCompatibleModuleNodeDual(clientModule, ssrModule);
+	}
+	getModulesByFile(file) {
+		const clientModules = this._client.getModulesByFile(file);
+		const ssrModules = this._ssr.getModulesByFile(file);
+		if (!clientModules && !ssrModules) return;
+		const result = /* @__PURE__ */ new Set();
+		if (clientModules) for (const mod of clientModules) result.add(this.getBackwardCompatibleBrowserModuleNode(mod));
+		if (ssrModules) {
+			for (const mod of ssrModules) if (mod.id == null || !this._client.getModuleById(mod.id)) result.add(this.getBackwardCompatibleServerModuleNode(mod));
+		}
+		return result;
+	}
+	onFileChange(file) {
+		this._client.onFileChange(file);
+		this._ssr.onFileChange(file);
+	}
+	onFileDelete(file) {
+		this._client.onFileDelete(file);
+		this._ssr.onFileDelete(file);
+	}
+	/** @internal */
+	_getModuleGraph(environment) {
+		switch (environment) {
+			case "client": return this._client;
+			case "ssr": return this._ssr;
+			default: throw new Error(`Invalid module node environment ${environment}`);
+		}
+	}
+	invalidateModule(mod, seen = /* @__PURE__ */ new Set(), timestamp = monotonicDateNow(), isHmr = false, softInvalidate = false) {
+		if (mod._clientModule) this._client.invalidateModule(mod._clientModule, new Set([...seen].map((mod) => mod._clientModule).filter(Boolean)), timestamp, isHmr, softInvalidate);
+		if (mod._ssrModule) this._ssr.invalidateModule(mod._ssrModule, new Set([...seen].map((mod) => mod._ssrModule).filter(Boolean)), timestamp, isHmr, softInvalidate);
+	}
+	invalidateAll() {
+		this._client.invalidateAll();
+		this._ssr.invalidateAll();
+	}
+	async ensureEntryFromUrl(rawUrl, ssr, setIsSelfAccepting = true) {
+		const module = await (ssr ? this._ssr : this._client).ensureEntryFromUrl(rawUrl, setIsSelfAccepting);
+		return this.getBackwardCompatibleModuleNode(module);
+	}
+	createFileOnlyEntry(file) {
+		const clientModule = this._client.createFileOnlyEntry(file);
+		const ssrModule = this._ssr.createFileOnlyEntry(file);
+		return this.getBackwardCompatibleModuleNodeDual(clientModule, ssrModule);
+	}
+	async resolveUrl(url, ssr) {
+		return ssr ? this._ssr.resolveUrl(url) : this._client.resolveUrl(url);
+	}
+	updateModuleTransformResult(mod, result, ssr) {
+		const environment = ssr ? "ssr" : "client";
+		this._getModuleGraph(environment).updateModuleTransformResult(environment === "client" ? mod._clientModule : mod._ssrModule, result);
+	}
+	getModuleByEtag(etag) {
+		const mod = this._client.etagToModuleMap.get(etag);
+		return mod && this.getBackwardCompatibleBrowserModuleNode(mod);
+	}
+	getBackwardCompatibleBrowserModuleNode(clientModule) {
+		return this.getBackwardCompatibleModuleNodeDual(clientModule, clientModule.id ? this._ssr.getModuleById(clientModule.id) : void 0);
+	}
+	getBackwardCompatibleServerModuleNode(ssrModule) {
+		return this.getBackwardCompatibleModuleNodeDual(ssrModule.id ? this._client.getModuleById(ssrModule.id) : void 0, ssrModule);
+	}
+	getBackwardCompatibleModuleNode(mod) {
+		return mod.environment === "client" ? this.getBackwardCompatibleBrowserModuleNode(mod) : this.getBackwardCompatibleServerModuleNode(mod);
+	}
+	getBackwardCompatibleModuleNodeDual(clientModule, ssrModule) {
+		const cached = this.moduleNodeCache.get(clientModule, ssrModule);
+		if (cached) return cached;
+		const moduleNode = new ModuleNode(this, clientModule, ssrModule);
+		this.moduleNodeCache.set(clientModule, ssrModule, moduleNode);
+		return moduleNode;
+	}
+};
+var DualWeakMap = class {
+	map = /* @__PURE__ */ new WeakMap();
+	undefinedKey = {};
+	get(key1, key2) {
+		const k1 = key1 ?? this.undefinedKey;
+		const k2 = key2 ?? this.undefinedKey;
+		return this.map.get(k1)?.get(k2);
+	}
+	set(key1, key2, value) {
+		const k1 = key1 ?? this.undefinedKey;
+		const k2 = key2 ?? this.undefinedKey;
+		if (!this.map.has(k1)) this.map.set(k1, /* @__PURE__ */ new Map());
+		this.map.get(k1).set(k2, value);
+	}
+};
+function createBackwardCompatibleModuleSet(moduleGraph, prop, module) {
+	return {
+		[Symbol.iterator]() {
+			return this.keys();
+		},
+		has(key) {
+			if (!key.id) return false;
+			const keyModule = moduleGraph._getModuleGraph(module.environment).getModuleById(key.id);
+			return keyModule !== void 0 && module[prop].has(keyModule);
+		},
+		values() {
+			return this.keys();
+		},
+		keys() {
+			return mapIterator(module[prop].keys(), (mod) => moduleGraph.getBackwardCompatibleModuleNode(mod));
+		},
+		get size() {
+			return module[prop].size;
+		},
+		forEach(callback, thisArg) {
+			return module[prop].forEach((mod) => {
+				const backwardCompatibleMod = moduleGraph.getBackwardCompatibleModuleNode(mod);
+				callback.call(thisArg, backwardCompatibleMod, backwardCompatibleMod, this);
+			});
+		}
+	};
+}
+function createBackwardCompatibleModuleMap(moduleGraph, prop, getModuleMap) {
+	return {
+		[Symbol.iterator]() {
+			return this.entries();
+		},
+		get(key) {
+			const clientModule = moduleGraph._client[prop].get(key);
+			const ssrModule = moduleGraph._ssr[prop].get(key);
+			if (!clientModule && !ssrModule) return;
+			return moduleGraph.getBackwardCompatibleModuleNodeDual(clientModule, ssrModule);
+		},
+		set(key, mod) {
+			const clientModule = mod._clientModule;
+			if (clientModule) moduleGraph._client[prop].set(key, clientModule);
+			const ssrModule = mod._ssrModule;
+			if (ssrModule) moduleGraph._ssr[prop].set(key, ssrModule);
+		},
+		keys() {
+			return getModuleMap().keys();
+		},
+		values() {
+			return mapIterator(getModuleMap().values(), (mod) => moduleGraph.getBackwardCompatibleModuleNode(mod));
+		},
+		entries() {
+			return mapIterator(getModuleMap().entries(), ([key, mod]) => [key, moduleGraph.getBackwardCompatibleModuleNode(mod)]);
+		},
+		get size() {
+			return getModuleMap().size;
+		},
+		forEach(callback, thisArg) {
+			return getModuleMap().forEach((mod, key) => {
+				const backwardCompatibleMod = moduleGraph.getBackwardCompatibleModuleNode(mod);
+				callback.call(thisArg, backwardCompatibleMod, key, this);
+			});
+		}
+	};
+}
+function createBackwardCompatibleFileToModulesMap(moduleGraph) {
+	const getFileToModulesMap = () => {
+		if (!moduleGraph._ssr.fileToModulesMap.size) return moduleGraph._client.fileToModulesMap;
+		const map = new Map(moduleGraph._client.fileToModulesMap);
+		for (const [key, modules] of moduleGraph._ssr.fileToModulesMap) {
+			const modulesSet = map.get(key);
+			if (!modulesSet) map.set(key, modules);
+			else for (const ssrModule of modules) {
+				let hasModule = false;
+				for (const clientModule of modulesSet) {
+					hasModule ||= clientModule.id === ssrModule.id;
+					if (hasModule) break;
+				}
+				if (!hasModule) modulesSet.add(ssrModule);
+			}
+		}
+		return map;
+	};
+	const getBackwardCompatibleModules = (modules) => new Set([...modules].map((mod) => moduleGraph.getBackwardCompatibleModuleNode(mod)));
+	return {
+		[Symbol.iterator]() {
+			return this.entries();
+		},
+		get(key) {
+			const clientModules = moduleGraph._client.fileToModulesMap.get(key);
+			const ssrModules = moduleGraph._ssr.fileToModulesMap.get(key);
+			if (!clientModules && !ssrModules) return;
+			const modules = clientModules ?? /* @__PURE__ */ new Set();
+			if (ssrModules) {
+				for (const ssrModule of ssrModules) if (ssrModule.id) {
+					let found = false;
+					for (const mod of modules) {
+						found ||= mod.id === ssrModule.id;
+						if (found) break;
+					}
+					if (!found) modules.add(ssrModule);
+				}
+			}
+			return getBackwardCompatibleModules(modules);
+		},
+		keys() {
+			return getFileToModulesMap().keys();
+		},
+		values() {
+			return mapIterator(getFileToModulesMap().values(), getBackwardCompatibleModules);
+		},
+		entries() {
+			return mapIterator(getFileToModulesMap().entries(), ([key, modules]) => [key, getBackwardCompatibleModules(modules)]);
+		},
+		get size() {
+			return getFileToModulesMap().size;
+		},
+		forEach(callback, thisArg) {
+			return getFileToModulesMap().forEach((modules, key) => {
+				callback.call(thisArg, getBackwardCompatibleModules(modules), key, this);
+			});
+		}
+	};
+}
+//#endregion
+//#region src/node/server/middlewares/notFound.ts
+function notFoundMiddleware() {
+	return function vite404Middleware(_, res) {
+		res.statusCode = 404;
+		res.end();
+	};
+}
+//#endregion
+//#region src/node/server/middlewares/hostCheck.ts
+function getAdditionalAllowedHosts(resolvedServerOptions, resolvedPreviewOptions) {
+	const list = [];
+	if (typeof resolvedServerOptions.host === "string" && resolvedServerOptions.host) list.push(resolvedServerOptions.host);
+	if (typeof resolvedServerOptions.hmr === "object" && resolvedServerOptions.hmr.host) list.push(resolvedServerOptions.hmr.host);
+	if (typeof resolvedPreviewOptions.host === "string" && resolvedPreviewOptions.host) list.push(resolvedPreviewOptions.host);
+	if (resolvedServerOptions.origin) try {
+		const serverOriginUrl = new URL(resolvedServerOptions.origin);
+		list.push(serverOriginUrl.hostname);
+	} catch {}
+	return list;
+}
+function hostValidationMiddleware(allowedHosts, isPreview) {
+	return hostValidationMiddleware$1({
+		allowedHosts: Object.freeze([...allowedHosts]),
+		generateErrorMessage(hostname) {
+			const hostnameWithQuotes = JSON.stringify(hostname);
+			return `Blocked request. This host (${hostnameWithQuotes}) is not allowed.\nTo allow this host, add ${hostnameWithQuotes} to \`${`${isPreview ? "preview" : "server"}.allowedHosts`}\` in vite.config.js.`;
+		}
+	});
+}
+//#endregion
+//#region src/node/server/middlewares/rejectInvalidRequest.ts
+/**
+* disallows request that contains `#` in the URL
+*/
+function rejectInvalidRequestMiddleware() {
+	return function viteRejectInvalidRequestMiddleware(req, res, next) {
+		if (req.url?.includes("#")) {
+			res.writeHead(400);
+			res.end();
+			return;
+		}
+		return next();
+	};
+}
+//#endregion
+//#region src/node/server/middlewares/memoryFiles.ts
+function memoryFilesMiddleware(server) {
+	const memoryFiles = server.environments.client instanceof FullBundleDevEnvironment ? server.environments.client.memoryFiles : void 0;
+	if (!memoryFiles) throw new Error("memoryFilesMiddleware can only be used for fullBundleMode");
+	const headers = server.config.server.headers;
+	return function viteMemoryFilesMiddleware(req, res, next) {
+		const cleanedUrl = cleanUrl(req.url);
+		if (cleanedUrl.endsWith(".html")) return next();
+		const filePath = decodeURIComponent(cleanedUrl).slice(1);
+		const file = memoryFiles.get(filePath);
+		if (file) {
+			if (file.etag) {
+				if (req.headers["if-none-match"] === file.etag) {
+					res.statusCode = 304;
+					res.end();
+					return;
+				}
+				res.setHeader("Etag", file.etag);
+			}
+			const mime = lookup(filePath);
+			if (mime) res.setHeader("Content-Type", mime);
+			for (const name in headers) res.setHeader(name, headers[name]);
+			return res.end(file.source);
+		}
+		next();
+	};
+}
+//#endregion
+//#region src/node/server/middlewares/triggerLazyBundling.ts
+function triggerLazyBundlingMiddleware(server) {
+	const environment = server.environments.client instanceof FullBundleDevEnvironment ? server.environments.client : void 0;
+	if (!environment) throw new Error("triggerLazyBundlingMiddleware can only be used for fullBundleMode");
+	return async function viteTriggerLazyBundlingMiddleware(req, res, next) {
+		if (!req.url?.startsWith("/@vite/lazy?")) return next();
+		let params;
+		try {
+			params = new URL(`http://localhost${req.url}`).searchParams;
+		} catch {
+			return next();
+		}
+		const moduleId = params.get("id");
+		const clientId = params.get("clientId");
+		const code = await environment.triggerLazyBundling(moduleId, clientId);
+		if (code == null) return next();
+		res.setHeader("Content-Type", "application/javascript");
+		return res.end(code);
+	};
+}
+//#endregion
+//#region src/node/server/index.ts
+var server_exports = /* @__PURE__ */ __exportAll({
+	_createServer: () => _createServer,
+	createServer: () => createServer$2,
+	createServerCloseFn: () => createServerCloseFn,
+	resolveForwardConsoleOptions: () => resolveForwardConsoleOptions,
+	resolveServerOptions: () => resolveServerOptions,
+	restartServerWithUrls: () => restartServerWithUrls,
+	serverConfigDefaults: () => serverConfigDefaults
+});
+var import_connect = /* @__PURE__ */ __toESM(require_connect(), 1);
+var import_lib = /* @__PURE__ */ __toESM(require_lib$1(), 1);
+var import_chokidar = /* @__PURE__ */ __toESM(require_chokidar(), 1);
+var import_launch_editor_middleware = /* @__PURE__ */ __toESM(require_launch_editor_middleware(), 1);
+var import_dist = require_dist();
+const usedConfigs = /* @__PURE__ */ new WeakSet();
+async function resolveForwardConsoleOptions(value) {
+	value ??= (await (0, import_dist.determineAgent)()).isAgent;
+	if (value === false) return {
+		enabled: false,
+		unhandledErrors: false,
+		logLevels: []
+	};
+	if (value === true) return {
+		enabled: true,
+		unhandledErrors: true,
+		logLevels: ["error", "warn"]
+	};
+	const unhandledErrors = value.unhandledErrors ?? true;
+	const logLevels = value.logLevels ?? [];
+	return {
+		enabled: unhandledErrors || logLevels.length > 0,
+		unhandledErrors,
+		logLevels
+	};
+}
+function createServer$2(inlineConfig = {}) {
+	return _createServer(inlineConfig, { listen: true });
+}
+async function _createServer(inlineConfig = {}, options) {
+	const config = isResolvedConfig(inlineConfig) ? inlineConfig : await resolveConfig(inlineConfig, "serve");
+	if (usedConfigs.has(config)) throw new Error(`There is already a server associated with the config.`);
+	if (config.command !== "serve") throw new Error(`Config was resolved for a "build", expected a "serve" command.`);
+	usedConfigs.add(config);
+	const initPublicFilesPromise = initPublicFiles(config);
+	const { root, server: serverConfig } = config;
+	const httpsOptions = await resolveHttpsConfig(config.server.https);
+	const { middlewareMode } = serverConfig;
+	const resolvedOutDirs = getResolvedOutDirs(config.root, config.build.outDir, config.build.rollupOptions.output);
+	const emptyOutDir = resolveEmptyOutDir(config.build.emptyOutDir, config.root, resolvedOutDirs);
+	const resolvedWatchOptions = resolveChokidarOptions({
+		disableGlobbing: true,
+		...serverConfig.watch
+	}, resolvedOutDirs, emptyOutDir, config.cacheDir);
+	const middlewares = (0, import_connect.default)();
+	const httpServer = middlewareMode ? null : await resolveHttpServer(middlewares, httpsOptions);
+	const ws = createWebSocketServer(httpServer, config, httpsOptions);
+	const publicFiles = await initPublicFilesPromise;
+	const { publicDir } = config;
+	if (httpServer) setClientErrorHandler(httpServer, config.logger);
+	const watcher = serverConfig.watch !== null ? import_chokidar.watch([
+		...config.experimental.bundledDev ? [] : [root],
+		...config.configFileDependencies,
+		...getEnvFilesForMode(config.mode, config.envDir),
+		...publicDir && publicFiles ? [publicDir] : []
+	], resolvedWatchOptions) : createNoopWatcher(resolvedWatchOptions);
+	const environments = {};
+	await Promise.all(Object.entries(config.environments).map(async ([name, environmentOptions]) => {
+		const environment = await environmentOptions.dev.createEnvironment(name, config, { ws });
+		environments[name] = environment;
+		await environment.init({
+			watcher,
+			previousInstance: options.previousEnvironments?.[environment.name]
+		});
+	}));
+	let moduleGraph = new ModuleGraph({
+		client: () => environments.client.moduleGraph,
+		ssr: () => environments.ssr.moduleGraph
+	});
+	let pluginContainer = createPluginContainer(environments);
+	const closeHttpServer = createServerCloseFn(httpServer);
+	const devHtmlTransformFn = createDevHtmlTransformFn(config);
+	let closeServerPromise;
+	const closeServer = async () => {
+		if (!middlewareMode) teardownSIGTERMListener(closeServerAndExit);
+		await Promise.allSettled([
+			watcher.close(),
+			ws.close(),
+			Promise.allSettled(Object.values(server.environments).map((environment) => environment.close())),
+			closeHttpServer(),
+			server._ssrCompatModuleRunner?.close()
+		]);
+		server.resolvedUrls = null;
+		server._ssrCompatModuleRunner = void 0;
+	};
+	let hot = ws;
+	let server = {
+		config,
+		middlewares,
+		httpServer,
+		watcher,
+		ws,
+		get hot() {
+			warnFutureDeprecation(config, "removeServerHot");
+			return hot;
+		},
+		set hot(h) {
+			hot = h;
+		},
+		environments,
+		get pluginContainer() {
+			warnFutureDeprecation(config, "removeServerPluginContainer");
+			return pluginContainer;
+		},
+		set pluginContainer(p) {
+			pluginContainer = p;
+		},
+		get moduleGraph() {
+			warnFutureDeprecation(config, "removeServerModuleGraph");
+			return moduleGraph;
+		},
+		set moduleGraph(graph) {
+			moduleGraph = graph;
+		},
+		resolvedUrls: null,
+		ssrTransform(code, inMap, url, originalCode = code) {
+			return ssrTransform(code, inMap, url, originalCode, { json: { stringify: config.json.stringify === true && config.json.namedExports !== true } });
+		},
+		transformRequest(url, options) {
+			warnFutureDeprecation(config, "removeServerTransformRequest");
+			return server.environments[options?.ssr ? "ssr" : "client"].transformRequest(url);
+		},
+		warmupRequest(url, options) {
+			warnFutureDeprecation(config, "removeServerWarmupRequest");
+			return server.environments[options?.ssr ? "ssr" : "client"].warmupRequest(url);
+		},
+		transformIndexHtml(url, html, originalUrl) {
+			return devHtmlTransformFn(server, url, html, originalUrl);
+		},
+		async ssrLoadModule(url, opts) {
+			warnFutureDeprecation(config, "removeSsrLoadModule");
+			return ssrLoadModule(url, server, opts?.fixStacktrace);
+		},
+		ssrFixStacktrace(e) {
+			warnFutureDeprecation(config, "removeSsrLoadModule", "ssrFixStacktrace doesn't need to be used for Environment Module Runners.");
+			ssrFixStacktrace(e, server.environments.ssr.moduleGraph);
+		},
+		ssrRewriteStacktrace(stack) {
+			warnFutureDeprecation(config, "removeSsrLoadModule", "ssrRewriteStacktrace doesn't need to be used for Environment Module Runners.");
+			return ssrRewriteStacktrace(stack, server.environments.ssr.moduleGraph).result;
+		},
+		async reloadModule(module) {
+			warnFutureDeprecation(config, "removeServerReloadModule");
+			if (serverConfig.hmr !== false && module.file) {
+				const environmentModule = module._clientModule ?? module._ssrModule;
+				updateModules(environments[environmentModule.environment], module.file, [environmentModule], monotonicDateNow());
+			}
+		},
+		async listen(port, isRestart) {
+			const hostname = await resolveHostname(config.server.host);
+			if (httpServer) httpServer.prependListener("listening", () => {
+				server.resolvedUrls = resolveServerUrls(httpServer, config.server, hostname, httpsOptions, config);
+			});
+			await startServer(server, hostname, port);
+			if (httpServer) {
+				if (!isRestart && config.server.open) server.openBrowser();
+			}
+			return server;
+		},
+		openBrowser() {
+			const options = server.config.server;
+			const url = getServerUrlByHost(server.resolvedUrls, options.host);
+			if (url) {
+				const path = typeof options.open === "string" ? new URL(options.open, url).href : url;
+				if (server.config.server.preTransformRequests) setTimeout(() => {
+					(path.startsWith("https:") ? get$1 : get)(path, { headers: { Accept: "text/html" } }, (res) => {
+						res.on("end", () => {});
+					}).on("error", () => {}).end();
+				}, 0);
+				openBrowser(path, true, server.config.logger);
+			} else server.config.logger.warn("No URL available to open in browser");
+		},
+		async close() {
+			if (!closeServerPromise) closeServerPromise = closeServer();
+			return closeServerPromise;
+		},
+		printUrls() {
+			if (server.resolvedUrls) printServerUrls(server.resolvedUrls, serverConfig.host, config.logger.info);
+			else if (middlewareMode) throw new Error("cannot print server URLs in middleware mode.");
+			else throw new Error("cannot print server URLs before server.listen is called.");
+		},
+		bindCLIShortcuts(options) {
+			bindCLIShortcuts(server, options);
+		},
+		async restart(forceOptimize) {
+			if (!server._restartPromise) {
+				server._forceOptimizeOnRestart = !!forceOptimize;
+				server._restartPromise = restartServer(server).finally(() => {
+					server._restartPromise = null;
+					server._forceOptimizeOnRestart = false;
+				});
+			}
+			return server._restartPromise;
+		},
+		waitForRequestsIdle(ignoredId) {
+			return environments.client.waitForRequestsIdle(ignoredId);
+		},
+		_setInternalServer(_server) {
+			server = _server;
+		},
+		_restartPromise: options.previousRestartPromise ?? null,
+		_forceOptimizeOnRestart: options.previousForceOptimizeOnRestart ?? false,
+		_shortcutsState: options.previousShortcutsState
+	};
+	const reflexServer = new Proxy(server, {
+		get: (_, property) => {
+			return server[property];
+		},
+		set: (_, property, value) => {
+			server[property] = value;
+			return true;
+		}
+	});
+	const closeServerAndExit = async (_, exitCode) => {
+		try {
+			await server.close();
+		} finally {
+			process.exitCode ??= exitCode ? 128 + exitCode : void 0;
+			process.exit();
+		}
+	};
+	if (!middlewareMode) setupSIGTERMListener(closeServerAndExit);
+	const onHMRUpdate = async (type, file) => {
+		if (serverConfig.hmr !== false) await handleHMRUpdate(type, file, server);
+	};
+	const onFileAddUnlink = async (file, isUnlink) => {
+		file = normalizePath(file);
+		reloadOnTsconfigChange(server, file);
+		await Promise.all(Object.values(server.environments).map((environment) => environment.pluginContainer.watchChange(file, { event: isUnlink ? "delete" : "create" })));
+		if (publicDir && publicFiles) {
+			if (file.startsWith(publicDir)) {
+				const path = file.slice(publicDir.length);
+				publicFiles[isUnlink ? "delete" : "add"](path);
+				if (!isUnlink) {
+					const clientModuleGraph = server.environments.client.moduleGraph;
+					const etag = (await clientModuleGraph.getModuleByUrl(path))?.transformResult?.etag;
+					if (etag) clientModuleGraph.etagToModuleMap.delete(etag);
+				}
+			}
+		}
+		if (isUnlink) for (const environment of Object.values(server.environments)) environment.moduleGraph.onFileDelete(file);
+		await onHMRUpdate(isUnlink ? "delete" : "create", file);
+	};
+	const onFileChange = async (file) => {
+		file = normalizePath(file);
+		reloadOnTsconfigChange(server, file);
+		await Promise.all(Object.values(server.environments).map((environment) => environment.pluginContainer.watchChange(file, { event: "update" })));
+		for (const environment of Object.values(server.environments)) environment.moduleGraph.onFileChange(file);
+		await onHMRUpdate("update", file);
+	};
+	watcher.on("change", (file) => {
+		onFileChange(file).catch((e) => server.config.logger.error(e));
+	});
+	watcher.on("add", (file) => {
+		onFileAddUnlink(file, false).catch((e) => server.config.logger.error(e));
+	});
+	watcher.on("unlink", (file) => {
+		onFileAddUnlink(file, true).catch((e) => server.config.logger.error(e));
+	});
+	if (!middlewareMode && httpServer) httpServer.once("listening", () => {
+		serverConfig.port = httpServer.address().port;
+	});
+	if (process.env.DEBUG) middlewares.use(timeMiddleware(root));
+	middlewares.use(rejectInvalidRequestMiddleware());
+	const { cors } = serverConfig;
+	if (cors !== false) middlewares.use((0, import_lib.default)(typeof cors === "boolean" ? {} : cors));
+	const { allowedHosts } = serverConfig;
+	if (allowedHosts !== true && !serverConfig.https) middlewares.use(hostValidationMiddleware(allowedHosts, false));
+	const configureServerContext = new BasicMinimalPluginContext({
+		...basePluginContextMeta,
+		watchMode: true
+	}, config.logger);
+	const postHooks = [];
+	for (const hook of config.getSortedPluginHooks("configureServer")) postHooks.push(await hook.call(configureServerContext, reflexServer));
+	if (!config.experimental.bundledDev) middlewares.use(cachedTransformMiddleware(server));
+	const { proxy } = serverConfig;
+	if (proxy) {
+		const middlewareServer = (isObject$1(middlewareMode) ? middlewareMode.server : null) || httpServer;
+		middlewares.use(proxyMiddleware(middlewareServer, proxy, config));
+	}
+	if (config.base !== "/") middlewares.use(baseMiddleware(config.rawBase, !!middlewareMode));
+	middlewares.use("/__open-in-editor", (0, import_launch_editor_middleware.default)());
+	middlewares.use(function viteHMRPingMiddleware(req, res, next) {
+		if (req.headers.accept === "text/x-vite-ping") res.writeHead(204).end();
+		else next();
+	});
+	if (publicDir) middlewares.use(servePublicMiddleware(server, publicFiles));
+	if (config.experimental.bundledDev) {
+		middlewares.use(triggerLazyBundlingMiddleware(server));
+		middlewares.use(memoryFilesMiddleware(server));
+	} else {
+		middlewares.use(transformMiddleware(server));
+		middlewares.use(serveRawFsMiddleware(server));
+		middlewares.use(serveStaticMiddleware(server));
+	}
+	if (config.appType === "spa" || config.appType === "mpa") middlewares.use(htmlFallbackMiddleware(root, config.appType === "spa", server.environments.client));
+	postHooks.forEach((fn) => fn && fn());
+	if (config.appType === "spa" || config.appType === "mpa") {
+		middlewares.use(indexHtmlMiddleware(root, server));
+		middlewares.use(notFoundMiddleware());
+	}
+	middlewares.use(errorMiddleware(server, !!middlewareMode));
+	let initingServer;
+	let serverInited = false;
+	const initServer = async (onListen) => {
+		if (serverInited) return;
+		if (initingServer) return initingServer;
+		initingServer = (async function() {
+			if (!config.experimental.bundledDev) await environments.client.pluginContainer.buildStart();
+			if (onListen || options.listen) await Promise.all(Object.values(environments).map((e) => e.listen(server)));
+			initingServer = void 0;
+			serverInited = true;
+		})();
+		return initingServer;
+	};
+	if (!middlewareMode && httpServer) {
+		const listen = httpServer.listen.bind(httpServer);
+		httpServer.listen = (async (port, ...args) => {
+			try {
+				await initServer(true);
+			} catch (e) {
+				httpServer.emit("error", e);
+				return;
+			}
+			return listen(port, ...args);
+		});
+	} else await initServer(false);
+	return server;
+}
+async function startServer(server, hostname, inlinePort) {
+	const httpServer = server.httpServer;
+	if (!httpServer) throw new Error("Cannot call server.listen in middleware mode.");
+	const options = server.config.server;
+	const configPort = inlinePort ?? options.port;
+	const port = (!configPort || configPort === server._configServerPort ? server._currentServerPort : configPort) ?? 5173;
+	server._configServerPort = configPort;
+	server._currentServerPort = await httpServerStart(httpServer, {
+		port,
+		strictPort: options.strictPort,
+		host: hostname.host,
+		logger: server.config.logger
+	});
+}
+function createServerCloseFn(server) {
+	if (!server) return () => Promise.resolve();
+	let hasListened = false;
+	const openSockets = /* @__PURE__ */ new Set();
+	server.on("connection", (socket) => {
+		openSockets.add(socket);
+		socket.on("close", () => {
+			openSockets.delete(socket);
+		});
+	});
+	server.once("listening", () => {
+		hasListened = true;
+	});
+	return () => new Promise((resolve, reject) => {
+		openSockets.forEach((s) => s.destroy());
+		if (hasListened) server.close((err) => {
+			if (err) reject(err);
+			else resolve();
+		});
+		else resolve();
+	});
+}
+function resolvedAllowDir(root, dir) {
+	return normalizePath(path.resolve(root, dir));
+}
+const _serverConfigDefaults = Object.freeze({
+	port: DEFAULT_DEV_PORT,
+	strictPort: false,
+	host: "localhost",
+	allowedHosts: [],
+	https: void 0,
+	open: false,
+	proxy: void 0,
+	cors: { origin: defaultAllowedOrigins },
+	headers: {},
+	warmup: {
+		clientFiles: [],
+		ssrFiles: []
+	},
+	middlewareMode: false,
+	fs: {
+		strict: true,
+		deny: [
+			".env",
+			".env.*",
+			"*.{crt,pem}",
+			"**/.git/**"
+		]
+	},
+	preTransformRequests: true,
+	perEnvironmentStartEndDuringDev: false,
+	perEnvironmentWatchChangeDuringDev: false,
+	forwardConsole: void 0
+});
+const serverConfigDefaults = _serverConfigDefaults;
+async function resolveServerOptions(root, raw, logger) {
+	const _server = mergeWithDefaults({
+		..._serverConfigDefaults,
+		host: void 0,
+		sourcemapIgnoreList: isInNodeModules
+	}, raw ?? {});
+	const server = {
+		..._server,
+		fs: {
+			..._server.fs,
+			allow: raw?.fs?.allow ?? [searchForWorkspaceRoot(root)]
+		},
+		sourcemapIgnoreList: _server.sourcemapIgnoreList === false ? () => false : _server.sourcemapIgnoreList,
+		forwardConsole: await resolveForwardConsoleOptions(_server.forwardConsole)
+	};
+	let allowDirs = server.fs.allow;
+	if (process.versions.pnp) {
+		const cwd = searchForPackageRoot(root);
+		try {
+			const yarnCacheDir = execSync(`yarn config get ${execSync("yarn config get enableGlobalCache", { cwd }).toString().trim() === "true" ? "globalFolder" : "cacheFolder"}`, { cwd }).toString().trim();
+			allowDirs.push(yarnCacheDir);
+		} catch (e) {
+			logger.warn(`Get yarn cache dir error: ${e.message}`, { timestamp: true });
+		}
+	}
+	allowDirs = allowDirs.map((i) => resolvedAllowDir(root, i));
+	const resolvedClientDir = resolvedAllowDir(root, CLIENT_DIR);
+	if (!allowDirs.some((dir) => isParentDirectory(dir, resolvedClientDir))) allowDirs.push(resolvedClientDir);
+	server.fs.allow = allowDirs;
+	if (server.origin?.endsWith("/")) {
+		server.origin = server.origin.slice(0, -1);
+		logger.warn(import_picocolors.default.yellow(`${import_picocolors.default.bold("(!)")} server.origin should not end with "/". Using "${server.origin}" instead.`));
+	}
+	if (process.env.__VITE_ADDITIONAL_SERVER_ALLOWED_HOSTS && Array.isArray(server.allowedHosts)) {
+		const additionalHost = process.env.__VITE_ADDITIONAL_SERVER_ALLOWED_HOSTS;
+		server.allowedHosts = [...server.allowedHosts, additionalHost];
+	}
+	return server;
+}
+async function restartServer(server) {
+	global.__vite_start_time = performance$1.now();
+	let inlineConfig = server.config.inlineConfig;
+	if (server._forceOptimizeOnRestart) inlineConfig = mergeConfig(inlineConfig, { forceOptimizeDeps: true });
+	{
+		let newServer = null;
+		try {
+			newServer = await _createServer(inlineConfig, {
+				listen: false,
+				previousEnvironments: server.environments,
+				previousShortcutsState: server._shortcutsState,
+				previousRestartPromise: server._restartPromise,
+				previousForceOptimizeOnRestart: server._forceOptimizeOnRestart
+			});
+		} catch (err) {
+			server.config.logger.error(err.message, { timestamp: true });
+			server.config.logger.error("server restart failed", { timestamp: true });
+			return;
+		}
+		server._shortcutsState = void 0;
+		await server.close();
+		const middlewares = server.middlewares;
+		newServer._configServerPort = server._configServerPort;
+		newServer._currentServerPort = server._currentServerPort;
+		Object.assign(server, newServer);
+		middlewares.stack = newServer.middlewares.stack;
+		server.middlewares = middlewares;
+		newServer._setInternalServer(server);
+	}
+	const { logger, server: { port, middlewareMode } } = server.config;
+	if (!middlewareMode) await server.listen(port, true);
+	else await Promise.all(Object.values(server.environments).map((e) => e.listen(server)));
+	logger.info("server restarted.", { timestamp: true });
+	if (server._shortcutsState?.options) bindCLIShortcuts(server, { print: false }, true);
+}
+/**
+* Internal function to restart the Vite server and print URLs if changed
+*/
+async function restartServerWithUrls(server) {
+	if (server.config.server.middlewareMode) {
+		await server.restart();
+		return;
+	}
+	const { port: prevPort, host: prevHost } = server.config.server;
+	const prevUrls = server.resolvedUrls;
+	await server.restart();
+	const { logger, server: { port, host } } = server.config;
+	if ((port ?? 5173) !== (prevPort ?? 5173) || host !== prevHost || diffDnsOrderChange(prevUrls, server.resolvedUrls)) {
+		logger.info("");
+		server.printUrls();
+	}
+}
+//#endregion
+//#region src/node/server/hmr.ts
+const debugHmr = createDebugger("vite:hmr");
+const whitespaceRE = /\s/;
+const normalizedClientDir = normalizePath(CLIENT_DIR);
+function getShortName(file, root) {
+	return file.startsWith(withTrailingSlash(root)) ? path.posix.relative(root, file) : file;
+}
+const normalizeHotChannel = (channel, enableHmr, normalizeClient = true) => {
+	const normalizedListenerMap = /* @__PURE__ */ new WeakMap();
+	const normalizedClients = /* @__PURE__ */ new WeakMap();
+	let invokeHandlers;
+	let listenerForInvokeHandler;
+	const handleInvoke = async (payload) => {
+		if (!invokeHandlers) return { error: {
+			name: "TransportError",
+			message: "invokeHandlers is not set",
+			stack: (/* @__PURE__ */ new Error()).stack
+		} };
+		const { name, data: args } = payload.data;
+		try {
+			const invokeHandler = invokeHandlers[name];
+			return { result: await invokeHandler(...args) };
+		} catch (error) {
+			return { error: {
+				name: error.name,
+				message: error.message,
+				stack: error.stack,
+				...error
+			} };
+		}
+	};
+	return {
+		...channel,
+		on: (event, fn) => {
+			if (event === "connection" || !normalizeClient) {
+				channel.on?.(event, fn);
+				return;
+			}
+			const listenerWithNormalizedClient = (data, client) => {
+				if (!normalizedClients.has(client)) normalizedClients.set(client, { send: (...args) => {
+					let payload;
+					if (typeof args[0] === "string") payload = {
+						type: "custom",
+						event: args[0],
+						data: args[1]
+					};
+					else payload = args[0];
+					client.send(payload);
+				} });
+				fn(data, normalizedClients.get(client));
+			};
+			normalizedListenerMap.set(fn, listenerWithNormalizedClient);
+			channel.on?.(event, listenerWithNormalizedClient);
+		},
+		off: (event, fn) => {
+			if (event === "connection" || !normalizeClient) {
+				channel.off?.(event, fn);
+				return;
+			}
+			const normalizedListener = normalizedListenerMap.get(fn);
+			if (normalizedListener) channel.off?.(event, normalizedListener);
+		},
+		setInvokeHandler(_invokeHandlers) {
+			invokeHandlers = _invokeHandlers;
+			if (!_invokeHandlers) {
+				if (listenerForInvokeHandler) channel.off?.("vite:invoke", listenerForInvokeHandler);
+				return;
+			}
+			listenerForInvokeHandler = async (payload, client) => {
+				const responseInvoke = payload.id.replace("send", "response");
+				client.send({
+					type: "custom",
+					event: "vite:invoke",
+					data: {
+						name: payload.name,
+						id: responseInvoke,
+						data: await handleInvoke({
+							type: "custom",
+							event: "vite:invoke",
+							data: payload
+						})
+					}
+				});
+			};
+			channel.on?.("vite:invoke", listenerForInvokeHandler);
+		},
+		handleInvoke,
+		send: (...args) => {
+			let payload;
+			if (typeof args[0] === "string") payload = {
+				type: "custom",
+				event: args[0],
+				data: args[1]
+			};
+			else payload = args[0];
+			if (enableHmr || payload.type === "connected" || payload.type === "ping" || payload.type === "custom" || payload.type === "error") channel.send?.(payload);
+		},
+		listen() {
+			return channel.listen?.();
+		},
+		close() {
+			return channel.close?.();
+		}
+	};
+};
+function getSortedPluginsByHotUpdateHook(plugins) {
+	const sortedPlugins = [];
+	let pre = 0, normal = 0, post = 0;
+	for (const plugin of plugins) {
+		const hook = plugin.hotUpdate ?? plugin.handleHotUpdate;
+		if (hook) {
+			if (typeof hook === "object") {
+				if (hook.order === "pre") {
+					sortedPlugins.splice(pre++, 0, plugin);
+					continue;
+				}
+				if (hook.order === "post") {
+					sortedPlugins.splice(pre + normal + post++, 0, plugin);
+					continue;
+				}
+			}
+			sortedPlugins.splice(pre + normal++, 0, plugin);
+		}
+	}
+	return sortedPlugins;
+}
+const sortedHotUpdatePluginsCache = /* @__PURE__ */ new WeakMap();
+function getSortedHotUpdatePlugins(environment) {
+	let sortedPlugins = sortedHotUpdatePluginsCache.get(environment);
+	if (!sortedPlugins) {
+		sortedPlugins = getSortedPluginsByHotUpdateHook(environment.plugins);
+		sortedHotUpdatePluginsCache.set(environment, sortedPlugins);
+	}
+	return sortedPlugins;
+}
+async function handleHMRUpdate(type, file, server) {
+	const { config } = server;
+	const mixedModuleGraph = ignoreDeprecationWarnings(() => server.moduleGraph);
+	const environments = Object.values(server.environments);
+	const shortFile = getShortName(file, config.root);
+	const isConfig = file === config.configFile;
+	const isConfigDependency = config.configFileDependencies.some((name) => file === name);
+	const isEnv = config.envDir !== false && getEnvFilesForMode(config.mode, config.envDir).includes(file);
+	if (isConfig || isConfigDependency || isEnv) {
+		debugHmr?.(`[config change] ${import_picocolors.default.dim(shortFile)}`);
+		config.logger.info(import_picocolors.default.green(`${normalizePath(path.relative(process.cwd(), file))} changed, restarting server...`), {
+			clear: true,
+			timestamp: true
+		});
+		try {
+			await restartServerWithUrls(server);
+		} catch (e) {
+			config.logger.error(import_picocolors.default.red(e));
+		}
+		return;
+	}
+	debugHmr?.(`[file change] ${import_picocolors.default.dim(shortFile)}`);
+	if (file.startsWith(withTrailingSlash(normalizedClientDir))) {
+		environments.forEach(({ hot }) => hot.send({
+			type: "full-reload",
+			path: "*",
+			triggeredBy: path.resolve(config.root, file)
+		}));
+		return;
+	}
+	if (config.experimental.bundledDev) return;
+	const timestamp = monotonicDateNow();
+	const contextMeta = {
+		type,
+		file,
+		timestamp,
+		read: () => readModifiedFile(file),
+		server
+	};
+	const hotMap = /* @__PURE__ */ new Map();
+	for (const environment of Object.values(server.environments)) {
+		const mods = new Set(environment.moduleGraph.getModulesByFile(file));
+		if (type === "create") for (const mod of environment.moduleGraph._hasResolveFailedErrorModules) mods.add(mod);
+		const options = {
+			...contextMeta,
+			modules: [...mods]
+		};
+		hotMap.set(environment, { options });
+	}
+	const mixedMods = new Set(mixedModuleGraph.getModulesByFile(file));
+	const mixedHmrContext = {
+		...contextMeta,
+		modules: [...mixedMods]
+	};
+	const contextForHandleHotUpdate = new BasicMinimalPluginContext({
+		...basePluginContextMeta,
+		watchMode: true
+	}, config.logger);
+	const clientEnvironment = server.environments.client;
+	const ssrEnvironment = server.environments.ssr;
+	const clientContext = clientEnvironment.pluginContainer.minimalContext;
+	const clientHotUpdateOptions = hotMap.get(clientEnvironment).options;
+	const ssrHotUpdateOptions = hotMap.get(ssrEnvironment)?.options;
+	try {
+		for (const plugin of getSortedHotUpdatePlugins(server.environments.client)) if (plugin.hotUpdate) {
+			const filteredModules = await getHookHandler(plugin.hotUpdate).call(clientContext, clientHotUpdateOptions);
+			if (filteredModules) {
+				clientHotUpdateOptions.modules = filteredModules;
+				mixedHmrContext.modules = mixedHmrContext.modules.filter((mixedMod) => filteredModules.some((mod) => mixedMod.id === mod.id) || ssrHotUpdateOptions?.modules.some((ssrMod) => ssrMod.id === mixedMod.id));
+				mixedHmrContext.modules.push(...filteredModules.filter((mod) => !mixedHmrContext.modules.some((mixedMod) => mixedMod.id === mod.id)).map((mod) => mixedModuleGraph.getBackwardCompatibleModuleNode(mod)));
+			}
+		} else if (type === "update") {
+			warnFutureDeprecation(config, "removePluginHookHandleHotUpdate", `Used in plugin "${plugin.name}".`, false);
+			const filteredModules = await getHookHandler(plugin.handleHotUpdate).call(contextForHandleHotUpdate, mixedHmrContext);
+			if (filteredModules) {
+				mixedHmrContext.modules = filteredModules;
+				clientHotUpdateOptions.modules = clientHotUpdateOptions.modules.filter((mod) => filteredModules.some((mixedMod) => mod.id === mixedMod.id));
+				clientHotUpdateOptions.modules.push(...filteredModules.filter((mixedMod) => !clientHotUpdateOptions.modules.some((mod) => mod.id === mixedMod.id)).map((mixedMod) => mixedMod._clientModule).filter(Boolean));
+				if (ssrHotUpdateOptions) {
+					ssrHotUpdateOptions.modules = ssrHotUpdateOptions.modules.filter((mod) => filteredModules.some((mixedMod) => mod.id === mixedMod.id));
+					ssrHotUpdateOptions.modules.push(...filteredModules.filter((mixedMod) => !ssrHotUpdateOptions.modules.some((mod) => mod.id === mixedMod.id)).map((mixedMod) => mixedMod._ssrModule).filter(Boolean));
+				}
+			}
+		}
+	} catch (error) {
+		hotMap.get(server.environments.client).error = error;
+	}
+	for (const environment of Object.values(server.environments)) {
+		if (environment.name === "client") continue;
+		const hot = hotMap.get(environment);
+		const context = environment.pluginContainer.minimalContext;
+		try {
+			for (const plugin of getSortedHotUpdatePlugins(environment)) if (plugin.hotUpdate) {
+				const filteredModules = await getHookHandler(plugin.hotUpdate).call(context, hot.options);
+				if (filteredModules) hot.options.modules = filteredModules;
+			}
+		} catch (error) {
+			hot.error = error;
+		}
+	}
+	async function hmr(environment) {
+		try {
+			const { options, error } = hotMap.get(environment);
+			if (error) throw error;
+			if (!options.modules.length) {
+				if (file.endsWith(".html") && environment.name === "client") {
+					environment.logger.info(import_picocolors.default.green(`page reload `) + import_picocolors.default.dim(shortFile), {
+						clear: true,
+						timestamp: true
+					});
+					environment.hot.send({
+						type: "full-reload",
+						path: config.server.middlewareMode ? "*" : "/" + normalizePath(path.relative(config.root, file))
+					});
+				} else debugHmr?.(`(${environment.name}) [no modules matched] ${import_picocolors.default.dim(shortFile)}`);
+				return;
+			}
+			updateModules(environment, shortFile, options.modules, timestamp);
+		} catch (err) {
+			environment.hot.send({
+				type: "error",
+				err: prepareError(err)
+			});
+		}
+	}
+	await (server.config.server.hotUpdateEnvironments ?? ((server, hmr) => {
+		return Promise.all(Object.values(server.environments).map((environment) => hmr(environment)));
+	}))(server, hmr);
+}
+function updateModules(environment, file, modules, timestamp, firstInvalidatedBy) {
+	const { hot } = environment;
+	const updates = [];
+	const invalidatedModules = /* @__PURE__ */ new Set();
+	const traversedModules = /* @__PURE__ */ new Set();
+	let needFullReload = modules.length === 0;
+	for (const mod of modules) {
+		const boundaries = [];
+		const hasDeadEnd = propagateUpdate(mod, traversedModules, boundaries);
+		environment.moduleGraph.invalidateModule(mod, invalidatedModules, timestamp, true);
+		if (needFullReload) continue;
+		if (hasDeadEnd) {
+			needFullReload = hasDeadEnd;
+			continue;
+		}
+		if (firstInvalidatedBy && boundaries.some(({ acceptedVia }) => normalizeHmrUrl(acceptedVia.url) === firstInvalidatedBy)) {
+			needFullReload = "circular import invalidate";
+			continue;
+		}
+		updates.push(...boundaries.map(({ boundary, acceptedVia, isWithinCircularImport }) => ({
+			type: `${boundary.type}-update`,
+			timestamp,
+			path: normalizeHmrUrl(boundary.url),
+			acceptedPath: normalizeHmrUrl(acceptedVia.url),
+			explicitImportRequired: boundary.type === "js" ? isExplicitImportRequired(acceptedVia.url) : false,
+			isWithinCircularImport,
+			firstInvalidatedBy
+		})));
+	}
+	const isClientHtmlChange = file.endsWith(".html") && environment.name === "client" && modules.every((mod) => mod.type !== "js");
+	if (needFullReload || isClientHtmlChange) {
+		const reason = typeof needFullReload === "string" ? import_picocolors.default.dim(` (${needFullReload})`) : "";
+		environment.logger.info(import_picocolors.default.green(`page reload `) + import_picocolors.default.dim(file) + reason, {
+			clear: !firstInvalidatedBy,
+			timestamp: true
+		});
+		hot.send({
+			type: "full-reload",
+			triggeredBy: path.resolve(environment.config.root, file),
+			path: !isClientHtmlChange || environment.config.server.middlewareMode || updates.length > 0 ? "*" : "/" + file
+		});
+		return;
+	}
+	if (updates.length === 0) {
+		debugHmr?.(import_picocolors.default.yellow(`no update happened `) + import_picocolors.default.dim(file));
+		return;
+	}
+	const filePaths = [...new Set(updates.map((u) => u.path))];
+	const { formatted, truncated } = formatAndTruncateFileList(filePaths);
+	if (truncated) debugHmr?.(`hmr update ${filePaths.join(", ")}`);
+	environment.logger.info(import_picocolors.default.green(`hmr update `) + import_picocolors.default.dim(formatted), {
+		clear: !firstInvalidatedBy,
+		timestamp: true
+	});
+	hot.send({
+		type: "update",
+		updates
+	});
+}
+function areAllImportsAccepted(importedBindings, acceptedExports) {
+	for (const binding of importedBindings) if (!acceptedExports.has(binding)) return false;
+	return true;
+}
+function propagateUpdate(node, traversedModules, boundaries, currentChain = [node]) {
+	if (traversedModules.has(node)) return false;
+	traversedModules.add(node);
+	if (node.id && node.isSelfAccepting === void 0) {
+		debugHmr?.(`[propagate update] stop propagation because not analyzed: ${import_picocolors.default.dim(node.id)}`);
+		return false;
+	}
+	if (node.isSelfAccepting) {
+		const boundary = node;
+		boundaries.push({
+			boundary,
+			acceptedVia: boundary,
+			isWithinCircularImport: isNodeWithinCircularImports(node, currentChain)
+		});
+		return false;
+	}
+	if (node.acceptedHmrExports) {
+		const boundary = node;
+		boundaries.push({
+			boundary,
+			acceptedVia: boundary,
+			isWithinCircularImport: isNodeWithinCircularImports(node, currentChain)
+		});
+	} else if (!node.importers.size) return true;
+	for (const importer of node.importers) {
+		const subChain = currentChain.concat(importer);
+		if (importer.acceptedHmrDeps.has(node)) {
+			boundaries.push({
+				boundary: importer,
+				acceptedVia: node,
+				isWithinCircularImport: isNodeWithinCircularImports(importer, subChain)
+			});
+			continue;
+		}
+		if (node.id && node.acceptedHmrExports && importer.importedBindings) {
+			const importedBindingsFromNode = importer.importedBindings.get(node.id);
+			if (importedBindingsFromNode && areAllImportsAccepted(importedBindingsFromNode, node.acceptedHmrExports)) continue;
+		}
+		if (!currentChain.includes(importer) && propagateUpdate(importer, traversedModules, boundaries, subChain)) return true;
+	}
+	return false;
+}
+/**
+* Check importers recursively if it's an import loop. An accepted module within
+* an import loop cannot recover its execution order and should be reloaded.
+*
+* @param node The node that accepts HMR and is a boundary
+* @param nodeChain The chain of nodes/imports that lead to the node.
+*   (The last node in the chain imports the `node` parameter)
+* @param currentChain The current chain tracked from the `node` parameter
+* @param traversedModules The set of modules that have traversed
+*/
+function isNodeWithinCircularImports(node, nodeChain, currentChain = [node], traversedModules = /* @__PURE__ */ new Set()) {
+	if (traversedModules.has(node)) return false;
+	traversedModules.add(node);
+	for (const importer of node.importers) {
+		if (importer === node) continue;
+		const importerIndex = nodeChain.indexOf(importer);
+		if (importerIndex > -1) {
+			if (debugHmr) {
+				const importChain = [
+					importer,
+					...[...currentChain].reverse(),
+					...nodeChain.slice(importerIndex, -1).reverse()
+				];
+				debugHmr(import_picocolors.default.yellow(`circular imports detected: `) + importChain.map((m) => import_picocolors.default.dim(m.url)).join(" -> "));
+			}
+			return true;
+		}
+		if (!currentChain.includes(importer)) {
+			const result = isNodeWithinCircularImports(importer, nodeChain, currentChain.concat(importer), traversedModules);
+			if (result) return result;
+		}
+	}
+	return false;
+}
+function handlePrunedModules(mods, { hot }) {
+	const t = monotonicDateNow();
+	mods.forEach((mod) => {
+		mod.lastHMRTimestamp = t;
+		mod.lastHMRInvalidationReceived = false;
+		debugHmr?.(`[dispose] ${import_picocolors.default.dim(mod.file)}`);
+	});
+	hot.send({
+		type: "prune",
+		paths: [...mods].map((m) => m.url)
+	});
+}
+/**
+* Lex import.meta.hot.accept() for accepted deps.
+* Since hot.accept() can only accept string literals or array of string
+* literals, we don't really need a heavy @babel/parse call on the entire source.
+*
+* @returns selfAccepts
+*/
+function lexAcceptedHmrDeps(code, start, urls) {
+	let state = 0;
+	let prevState = 0;
+	let currentDep = "";
+	function addDep(index) {
+		urls.add({
+			url: currentDep,
+			start: index - currentDep.length - 1,
+			end: index + 1
+		});
+		currentDep = "";
+	}
+	for (let i = start; i < code.length; i++) {
+		const char = code.charAt(i);
+		switch (state) {
+			case 0:
+			case 4:
+				if (char === `'`) {
+					prevState = state;
+					state = 1;
+				} else if (char === `"`) {
+					prevState = state;
+					state = 2;
+				} else if (char === "`") {
+					prevState = state;
+					state = 3;
+				} else if (whitespaceRE.test(char)) continue;
+				else if (state === 0) if (char === `[`) state = 4;
+				else return true;
+				else if (char === `]`) return false;
+				else if (char === ",") continue;
+				else error(i);
+				break;
+			case 1:
+				if (char === `'`) {
+					addDep(i);
+					if (prevState === 0) return false;
+					else state = prevState;
+				} else currentDep += char;
+				break;
+			case 2:
+				if (char === `"`) {
+					addDep(i);
+					if (prevState === 0) return false;
+					else state = prevState;
+				} else currentDep += char;
+				break;
+			case 3:
+				if (char === "`") {
+					addDep(i);
+					if (prevState === 0) return false;
+					else state = prevState;
+				} else if (char === "$" && code.charAt(i + 1) === "{") error(i);
+				else currentDep += char;
+				break;
+			default: throw new Error("unknown import.meta.hot lexer state");
+		}
+	}
+	return false;
+}
+function lexAcceptedHmrExports(code, start, exportNames) {
+	const urls = /* @__PURE__ */ new Set();
+	lexAcceptedHmrDeps(code, start, urls);
+	for (const { url } of urls) exportNames.add(url);
+	return urls.size > 0;
+}
+function normalizeHmrUrl(url) {
+	if (url[0] !== "." && url[0] !== "/") url = wrapId(url);
+	return url;
+}
+function error(pos) {
+	const err = /* @__PURE__ */ new Error("import.meta.hot.accept() can only accept string literals or an Array of string literals.");
+	err.pos = pos;
+	throw err;
+}
+async function readModifiedFile(file) {
+	const content = await fsp.readFile(file, "utf-8");
+	if (!content) {
+		const mtime = (await fsp.stat(file)).mtimeMs;
+		for (let n = 0; n < 10; n++) {
+			await new Promise((r) => setTimeout(r, 10));
+			if ((await fsp.stat(file)).mtimeMs !== mtime) break;
+		}
+		return await fsp.readFile(file, "utf-8");
+	} else return content;
+}
+function createServerHotChannel() {
+	const innerEmitter = new EventEmitter();
+	const outsideEmitter = new EventEmitter();
+	return {
+		skipFsCheck: true,
+		send(payload) {
+			outsideEmitter.emit("send", payload);
+		},
+		off(event, listener) {
+			innerEmitter.off(event, listener);
+		},
+		on: ((event, listener) => {
+			innerEmitter.on(event, listener);
+		}),
+		close() {
+			innerEmitter.removeAllListeners();
+			outsideEmitter.removeAllListeners();
+		},
+		listen() {
+			innerEmitter.emit("connection");
+		},
+		api: {
+			innerEmitter,
+			outsideEmitter
+		}
+	};
+}
+//#endregion
+//#region src/node/external.ts
+const debug$5 = createDebugger("vite:external");
+const isExternalCache = /* @__PURE__ */ new WeakMap();
+function shouldExternalize(environment, id, importer) {
+	let isExternal = isExternalCache.get(environment);
+	if (!isExternal) {
+		isExternal = createIsExternal(environment);
+		isExternalCache.set(environment, isExternal);
+	}
+	return isExternal(id, importer);
+}
+function createIsConfiguredAsExternal(environment) {
+	const { config } = environment;
+	const { root, resolve } = config;
+	const { external, noExternal } = resolve;
+	const noExternalFilter = typeof noExternal !== "boolean" && !(Array.isArray(noExternal) && noExternal.length === 0) && createFilter$1(void 0, noExternal, { resolve: false });
+	const targetConditions = resolve.externalConditions;
+	const resolveOptions = {
+		...resolve,
+		root,
+		isProduction: false,
+		isBuild: true,
+		conditions: targetConditions
+	};
+	const isExternalizable = (id, importer, configuredAsExternal) => {
+		if (!bareImportRE.test(id) || id.includes("\0")) return false;
+		try {
+			const resolved = tryNodeResolve(id, config.command === "build" ? void 0 : importer, resolveOptions, void 0, false);
+			if (!resolved) return false;
+			if (!configuredAsExternal && !isInNodeModules(resolved.id)) return false;
+			return canExternalizeFile(resolved.id);
+		} catch {
+			debug$5?.(`Failed to node resolve "${id}". Skipping externalizing it by default.`);
+			return false;
+		}
+	};
+	return (id, importer) => {
+		if (external !== true && external.includes(id)) return true;
+		const pkgName = getNpmPackageName(id);
+		if (!pkgName) return isExternalizable(id, importer, false);
+		if (external !== true && external.includes(pkgName)) return isExternalizable(id, importer, true);
+		if (typeof noExternal === "boolean") return !noExternal;
+		if (noExternalFilter && !noExternalFilter(pkgName)) return false;
+		return isExternalizable(id, importer, external === true);
+	};
+}
+function createIsExternal(environment) {
+	const processedIds = /* @__PURE__ */ new Map();
+	const isConfiguredAsExternal = createIsConfiguredAsExternal(environment);
+	return (id, importer) => {
+		if (processedIds.has(id)) return processedIds.get(id);
+		let isExternal = false;
+		if (id[0] !== "." && !path.isAbsolute(id)) isExternal = isBuiltin(environment.config.resolve.builtins, id) || isConfiguredAsExternal(id, importer);
+		processedIds.set(id, isExternal);
+		return isExternal;
+	};
+}
+function canExternalizeFile(filePath) {
+	const ext = path.extname(filePath);
+	return !ext || ext === ".js" || ext === ".mjs" || ext === ".cjs";
+}
+//#endregion
+//#region src/node/plugins/worker.ts
+var WorkerOutputCache = class {
+	/**
+	* worker bundle information for each input id
+	* used to bundle the same worker file only once
+	*/
+	bundles = /* @__PURE__ */ new Map();
+	/** list of assets emitted for the worker bundles */
+	assets = /* @__PURE__ */ new Map();
+	fileNameHash = /* @__PURE__ */ new Map();
+	invalidatedBundles = /* @__PURE__ */ new Set();
+	saveWorkerBundle(file, watchedFiles, outputEntryFilename, outputEntryCode, outputAssets, logger) {
+		for (const asset of outputAssets) this.saveAsset(asset, logger);
+		const bundle = {
+			entryFilename: outputEntryFilename,
+			entryCode: outputEntryCode,
+			entryUrlPlaceholder: this.generateEntryUrlPlaceholder(outputEntryFilename),
+			referencedAssets: new Set(outputAssets.map((asset) => asset.fileName)),
+			watchedFiles
+		};
+		this.bundles.set(file, bundle);
+		return bundle;
+	}
+	saveAsset(asset, logger) {
+		const duplicateAsset = this.assets.get(asset.fileName);
+		if (duplicateAsset) {
+			if (!isSameContent(duplicateAsset.source, asset.source)) logger.warn(`\n` + import_picocolors.default.yellow(`The emitted file ${JSON.stringify(asset.fileName)} overwrites a previously emitted file of the same name.`));
+		}
+		this.assets.set(asset.fileName, asset);
+	}
+	invalidateAffectedBundles(file) {
+		for (const [bundleInputFile, bundle] of this.bundles.entries()) if (bundle.watchedFiles.includes(file)) this.invalidatedBundles.add(bundleInputFile);
+	}
+	removeBundleIfInvalidated(file) {
+		if (this.invalidatedBundles.has(file)) {
+			this.invalidatedBundles.delete(file);
+			this.removeBundle(file);
+		}
+	}
+	removeBundle(file) {
+		const bundle = this.bundles.get(file);
+		if (!bundle) return;
+		this.bundles.delete(file);
+		this.fileNameHash.delete(getHash(bundle.entryFilename));
+		this.assets.delete(bundle.entryFilename);
+		const keptBundles = [...this.bundles.values()];
+		for (const asset of bundle.referencedAssets) if (keptBundles.every((b) => !b.referencedAssets.has(asset))) this.assets.delete(asset);
+	}
+	getWorkerBundle(file) {
+		return this.bundles.get(file);
+	}
+	getAssets() {
+		return this.assets.values();
+	}
+	getEntryFilenameFromHash(hash) {
+		return this.fileNameHash.get(hash);
+	}
+	generateEntryUrlPlaceholder(entryFilename) {
+		const hash = getHash(entryFilename);
+		if (!this.fileNameHash.has(hash)) this.fileNameHash.set(hash, entryFilename);
+		return `__VITE_WORKER_ASSET__${hash}__`;
+	}
+};
+const workerOrSharedWorkerRE = /(?:\?|&)(worker|sharedworker)(?:&|$)/;
+const workerFileRE = /(?:\?|&)worker_file&type=(\w+)(?:&|$)/;
+const inlineRE = /[?&]inline\b/;
+const WORKER_FILE_ID = "worker_file";
+const workerOutputCaches = /* @__PURE__ */ new WeakMap();
+async function bundleWorkerEntry(config, id) {
+	const input = cleanUrl(id);
+	const workerOutput = workerOutputCaches.get(config.mainConfig || config);
+	workerOutput.removeBundleIfInvalidated(input);
+	const bundleInfo = workerOutput.getWorkerBundle(input);
+	if (bundleInfo) return bundleInfo;
+	const newBundleChain = [...config.bundleChain, input];
+	if (config.bundleChain.includes(input)) throw new Error(`Circular worker imports detected. Vite does not support it. Import chain: ${newBundleChain.map((id) => prettifyUrl(id, config.root)).join(" -> ")}`);
+	const { rolldown } = await import("rolldown");
+	const { plugins, rollupOptions, format } = config.worker;
+	const workerEnvironment = new BuildEnvironment("client", await plugins(newBundleChain));
+	await workerEnvironment.init();
+	const chunkMetadataMap = new ChunkMetadataMap();
+	const workerBuildTarget = workerEnvironment.config.build.target;
+	const bundle = await rolldown({
+		...rollupOptions,
+		input,
+		plugins: workerEnvironment.plugins.map((p) => injectEnvironmentToHooks(workerEnvironment, chunkMetadataMap, p)),
+		onLog(level, log) {
+			onRollupLog(level, log, workerEnvironment);
+		},
+		transform: {
+			target: workerBuildTarget === false ? void 0 : workerBuildTarget,
+			...rollupOptions.transform,
+			define: {
+				...rollupOptions.transform?.define,
+				"process.env.NODE_ENV": "process.env.NODE_ENV"
+			}
+		},
+		moduleTypes: {
+			".css": "js",
+			...rollupOptions.moduleTypes
+		},
+		preserveEntrySignatures: false,
+		experimental: {
+			...rollupOptions.experimental,
+			viteMode: true
+		}
+	});
+	let result;
+	let watchedFiles;
+	try {
+		const workerOutputConfig = config.worker.rollupOptions.output;
+		const workerConfig = workerOutputConfig ? Array.isArray(workerOutputConfig) ? workerOutputConfig[0] || {} : workerOutputConfig : {};
+		result = await bundle.generate({
+			entryFileNames: path.posix.join(config.build.assetsDir, "[name]-[hash].js"),
+			chunkFileNames: path.posix.join(config.build.assetsDir, "[name]-[hash].js"),
+			assetFileNames: path.posix.join(config.build.assetsDir, "[name]-[hash].[ext]"),
+			minify: workerEnvironment.config.build.minify === "oxc" ? true : workerEnvironment.config.build.minify === false ? "dce-only" : void 0,
+			...workerConfig,
+			format,
+			sourcemap: workerEnvironment.config.build.sourcemap
+		});
+		watchedFiles = (await bundle.watchFiles).map((f) => normalizePath(f));
+	} catch (e) {
+		if (e instanceof Error && e.name === "RollupError" && e.code === "INVALID_OPTION" && e.message.includes("\"output.format\"")) e.message = e.message.replace("output.format", "worker.format");
+		throw e;
+	} finally {
+		await bundle.close();
+	}
+	const { output: [outputChunk, ...outputChunks] } = result;
+	const assets = outputChunks.map((outputChunk) => outputChunk.type === "asset" ? outputChunk : {
+		fileName: outputChunk.fileName,
+		originalFileName: null,
+		originalFileNames: [],
+		source: outputChunk.code
+	});
+	if ((config.build.sourcemap === "hidden" || config.build.sourcemap === true) && outputChunk.map) assets.push({
+		fileName: outputChunk.fileName + ".map",
+		originalFileName: null,
+		originalFileNames: [],
+		source: outputChunk.map.toString()
+	});
+	return workerOutputCaches.get(config.mainConfig || config).saveWorkerBundle(input, watchedFiles, outputChunk.fileName, outputChunk.code, assets, config.logger);
+}
+const workerAssetUrlRE = /__VITE_WORKER_ASSET__([a-z\d]{8})__/g;
+async function workerFileToUrl(config, id) {
+	const workerOutput = workerOutputCaches.get(config.mainConfig || config);
+	const bundle = await bundleWorkerEntry(config, id);
+	workerOutput.saveAsset({
+		fileName: bundle.entryFilename,
+		originalFileName: null,
+		originalFileNames: [],
+		source: bundle.entryCode
+	}, config.logger);
+	return bundle;
+}
+function webWorkerPostPlugin(_config) {
+	return {
+		name: "vite:worker-post",
+		applyToEnvironment(environment) {
+			if (environment.config.isBundled) {
+				if (environment.config.worker.format === "iife") return viteWebWorkerPostPlugin();
+				return false;
+			}
+			return true;
+		},
+		transform: {
+			filter: { code: "import.meta" },
+			order: "post",
+			async handler(code, id) {
+				if (this.environment.config.worker.format === "iife") {
+					await init;
+					let imports;
+					try {
+						imports = parse$2(code)[0];
+					} catch {
+						return;
+					}
+					let injectedImportMeta = false;
+					let s;
+					for (const { s: start, e: end, d: dynamicIndex } of imports) if (dynamicIndex === -2) if (code.slice(end, end + 4) === ".url") {
+						s ||= new MagicString(code);
+						s.overwrite(start, end + 4, "self.location.href");
+					} else {
+						s ||= new MagicString(code);
+						if (!injectedImportMeta) {
+							s.prepend("const _vite_importMeta = { url: self.location.href };\n");
+							injectedImportMeta = true;
+						}
+						s.overwrite(start, end, "_vite_importMeta");
+					}
+					if (!s) return;
+					return {
+						code: s.toString(),
+						map: s.generateMap({
+							hires: "boundary",
+							source: id
+						})
+					};
+				}
+			}
+		}
+	};
+}
+function webWorkerPlugin(config) {
+	const isBuild = config.command === "build";
+	const isWorker = config.isWorker;
+	workerOutputCaches.set(config, new WorkerOutputCache());
+	const emittedAssets = /* @__PURE__ */ new Set();
+	return {
+		name: "vite:worker",
+		buildStart() {
+			if (isWorker) return;
+			emittedAssets.clear();
+		},
+		load: {
+			filter: { id: workerOrSharedWorkerRE },
+			async handler(id) {
+				const workerMatch = workerOrSharedWorkerRE.exec(id);
+				if (!workerMatch) return;
+				const { format } = config.worker;
+				const workerConstructor = workerMatch[1] === "sharedworker" ? "SharedWorker" : "Worker";
+				const isBundled = this.environment.config.isBundled;
+				const workerType = isBundled ? format === "es" ? "module" : "classic" : "module";
+				const workerTypeOption = `{
+          ${workerType === "module" ? `type: "module",` : ""}
+          name: options?.name
+        }`;
+				let urlCode;
+				if (isBundled) if (isWorker && config.bundleChain.at(-1) === cleanUrl(id)) urlCode = "self.location.href";
+				else if (inlineRE.test(id)) {
+					const result = await bundleWorkerEntry(config, id);
+					for (const file of result.watchedFiles) this.addWatchFile(file);
+					const jsContent = `const jsContent = ${JSON.stringify(result.entryCode)};`;
+					return {
+						code: workerConstructor === "Worker" ? `${jsContent}
+            const blob = typeof self !== "undefined" && self.Blob && new Blob([${workerType === "classic" ? `'(self.URL || self.webkitURL).revokeObjectURL(self.location.href);',` : `'URL.revokeObjectURL(import.meta.url);',`}jsContent], { type: "text/javascript;charset=utf-8" });
+            export default function WorkerWrapper(options) {
+              let objURL;
+              try {
+                objURL = blob && (self.URL || self.webkitURL).createObjectURL(blob);
+                if (!objURL) throw ''
+                const worker = new ${workerConstructor}(objURL, ${workerTypeOption});
+                worker.addEventListener("error", () => {
+                  (self.URL || self.webkitURL).revokeObjectURL(objURL);
+                });
+                return worker;
+              } catch(e) {
+                return new ${workerConstructor}(
+                  'data:text/javascript;charset=utf-8,' + encodeURIComponent(jsContent),
+                  ${workerTypeOption}
+                );
+              }
+            }` : `${jsContent}
+            export default function WorkerWrapper(options) {
+              return new ${workerConstructor}(
+                'data:text/javascript;charset=utf-8,' + encodeURIComponent(jsContent),
+                ${workerTypeOption}
+              );
+            }
+            `,
+						map: { mappings: "" }
+					};
+				} else {
+					const result = await workerFileToUrl(config, id);
+					let url;
+					if (this.environment.config.command === "serve" && this.environment.config.isBundled) url = toOutputFilePathInJSForBundledDev(this.environment, result.entryFilename);
+					else url = result.entryUrlPlaceholder;
+					urlCode = JSON.stringify(url);
+					for (const file of result.watchedFiles) this.addWatchFile(file);
+				}
+				else {
+					let url = await fileToUrl$1(this, cleanUrl(id));
+					url = injectQuery(url, `${WORKER_FILE_ID}&type=${workerType}`);
+					urlCode = JSON.stringify(url);
+				}
+				if (urlRE$1.test(id)) return {
+					code: `export default ${urlCode}`,
+					map: { mappings: "" }
+				};
+				return {
+					code: `export default function WorkerWrapper(options) {
+            return new ${workerConstructor}(
+              ${urlCode},
+              ${workerTypeOption}
+            );
+          }`,
+					map: { mappings: "" }
+				};
+			}
+		},
+		transform: {
+			filter: { id: workerFileRE },
+			handler(raw, id) {
+				const workerFileMatch = workerFileRE.exec(id);
+				if (workerFileMatch) {
+					const workerType = workerFileMatch[1];
+					let injectEnv = "";
+					if (workerType === "classic") injectEnv = `importScripts(${JSON.stringify(path.posix.join(config.base, ENV_PUBLIC_PATH))})\n`;
+					else if (workerType === "module") injectEnv = `import ${JSON.stringify(ENV_PUBLIC_PATH)}\n`;
+					else if (workerType === "ignore") if (this.environment.config.isBundled) injectEnv = "";
+					else {
+						const environment = this.environment;
+						injectEnv = ((environment.mode === "dev" ? environment.moduleGraph : void 0)?.getModuleById(ENV_ENTRY))?.transformResult?.code || "";
+					}
+					if (injectEnv) {
+						const s = new MagicString(raw);
+						s.prepend(injectEnv + ";\n");
+						return {
+							code: s.toString(),
+							map: s.generateMap({ hires: "boundary" })
+						};
+					}
+				}
+			}
+		},
+		...isBuild ? { renderChunk(code, chunk, outputOptions) {
+			let s;
+			const result = () => {
+				return s && {
+					code: s.toString(),
+					map: this.environment.config.build.sourcemap ? s.generateMap({ hires: "boundary" }) : null
+				};
+			};
+			workerAssetUrlRE.lastIndex = 0;
+			if (workerAssetUrlRE.test(code)) {
+				const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(outputOptions.format, this.environment.config.isWorker);
+				let match;
+				s = new MagicString(code);
+				workerAssetUrlRE.lastIndex = 0;
+				const workerOutputCache = workerOutputCaches.get(config.mainConfig || config);
+				while (match = workerAssetUrlRE.exec(code)) {
+					const [full, hash] = match;
+					const filename = workerOutputCache.getEntryFilenameFromHash(hash);
+					if (!filename) {
+						this.warn(`Could not find worker asset for hash: ${hash}`);
+						continue;
+					}
+					const replacement = toOutputFilePathInJS(this.environment, filename, "asset", chunk.fileName, "js", toRelativeRuntime);
+					const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`;
+					s.update(match.index, match.index + full.length, replacementString);
+				}
+			}
+			return result();
+		} } : {},
+		generateBundle(opts, bundle) {
+			if (this.environment.config.isOutputOptionsForLegacyChunks?.(opts) || isWorker) return;
+			for (const asset of workerOutputCaches.get(config).getAssets()) {
+				if (emittedAssets.has(asset.fileName)) continue;
+				emittedAssets.add(asset.fileName);
+				const duplicateAsset = bundle[asset.fileName];
+				if (duplicateAsset) {
+					if (isSameContent(duplicateAsset.type === "asset" ? duplicateAsset.source : duplicateAsset.code, asset.source)) continue;
+				}
+				this.emitFile({
+					type: "asset",
+					fileName: asset.fileName,
+					source: asset.source
+				});
+			}
+		},
+		watchChange(file) {
+			if (isWorker) return;
+			workerOutputCaches.get(config).invalidateAffectedBundles(normalizePath(file));
+		}
+	};
+}
+function isSameContent(a, b) {
+	if (typeof a === "string") {
+		if (typeof b === "string") return a === b;
+		return Buffer.from(a).equals(b);
+	}
+	return Buffer.from(b).equals(a);
+}
+//#endregion
+//#region src/node/plugins/preAlias.ts
+/**
+* A plugin to avoid an aliased AND optimized dep from being aliased in src
+*/
+function preAliasPlugin(config) {
+	const findPatterns = getAliasPatterns(config.resolve.alias);
+	return {
+		name: "vite:pre-alias",
+		applyToEnvironment(environment) {
+			if (environment.config.isBundled) return false;
+			return !isDepOptimizationDisabled(environment.config.optimizeDeps);
+		},
+		async resolveId(id, importer, options) {
+			const environment = this.environment;
+			const ssr = environment.config.consumer === "server";
+			const depsOptimizer = environment.depsOptimizer;
+			if (importer && depsOptimizer && bareImportRE.test(id) && !options.scan && id !== "@vite/client" && id !== "@vite/env") {
+				if (findPatterns.find((pattern) => matches(pattern, id))) {
+					const optimizedId = await tryOptimizedResolve(depsOptimizer, id, importer, config.resolve.preserveSymlinks, config.packageCache);
+					if (optimizedId) return optimizedId;
+					if (depsOptimizer.options.noDiscovery) return;
+					const resolved = await this.resolve(id, importer, options);
+					if (resolved && !depsOptimizer.isOptimizedDepFile(resolved.id)) {
+						const optimizeDeps = depsOptimizer.options;
+						const resolvedId = cleanUrl(resolved.id);
+						if (!(resolvedId === id || resolvedId.includes("\0")) && fs.existsSync(resolvedId) && !moduleListContains(optimizeDeps.exclude, id) && path.isAbsolute(resolvedId) && (isInNodeModules(resolvedId) || optimizeDeps.include?.includes(id)) && isOptimizable(resolvedId, optimizeDeps) && (!ssr || optimizeAliasReplacementForSSR(resolvedId, optimizeDeps))) {
+							const optimizedInfo = depsOptimizer.registerMissingImport(id, resolvedId);
+							return { id: depsOptimizer.getOptimizedDepId(optimizedInfo) };
+						}
+					}
+					return resolved;
+				}
+			}
+		}
+	};
+}
+function optimizeAliasReplacementForSSR(id, optimizeDeps) {
+	if (optimizeDeps.include?.includes(id)) return true;
+	return false;
+}
+function matches(pattern, importee) {
+	if (pattern instanceof RegExp) return pattern.test(importee);
+	if (importee.length < pattern.length) return false;
+	if (importee === pattern) return true;
+	return importee.startsWith(withTrailingSlash(pattern));
+}
+function getAliasPatterns(entries) {
+	if (Array.isArray(entries)) return entries.map((entry) => entry.find);
+	return Object.entries(entries).map(([find]) => find);
+}
+function getAliasPatternMatcher(entries) {
+	const patterns = getAliasPatterns(entries);
+	return (importee) => patterns.some((pattern) => matches(pattern, importee));
+}
+//#endregion
+//#region src/node/plugins/importAnalysis.ts
+const debug$4 = createDebugger("vite:import-analysis");
+const clientDir = normalizePath(CLIENT_DIR);
+const skipRE = /\.(?:map|json)(?:$|\?)/;
+const canSkipImportAnalysis = (id) => skipRE.test(id) || isDirectCSSRequest(id);
+const optimizedDepChunkRE = /\/chunk-[A-Z\d]{8}\.js/;
+const hasViteIgnoreRE = /\/\*\s*@vite-ignore\s*\*\//;
+const urlIsStringRE = /^(?:'.*'|".*"|`.*`)$/;
+const templateLiteralRE = /^\s*`(.*)`\s*$/;
+function isExplicitImportRequired(url) {
+	return !isJSRequest(url) && !isCSSRequest(url);
+}
+function normalizeResolvedIdToUrl(environment, url, resolved) {
+	const root = environment.config.root;
+	const depsOptimizer = environment.depsOptimizer;
+	if (resolved.id.startsWith(withTrailingSlash(root))) url = resolved.id.slice(root.length);
+	else if (depsOptimizer?.isOptimizedDepFile(resolved.id) || resolved.id !== "/@react-refresh" && path.isAbsolute(resolved.id) && fs.existsSync(cleanUrl(resolved.id))) url = path.posix.join(FS_PREFIX, resolved.id);
+	else url = resolved.id;
+	if (url[0] !== "." && url[0] !== "/") url = wrapId(resolved.id);
+	return url;
+}
+function extractImportedBindings(id, source, importSpec, importedBindings) {
+	let bindings = importedBindings.get(id);
+	if (!bindings) {
+		bindings = /* @__PURE__ */ new Set();
+		importedBindings.set(id, bindings);
+	}
+	if (importSpec.d > -1 || importSpec.d === -2) {
+		bindings.add("*");
+		return;
+	}
+	const exp = source.slice(importSpec.ss, importSpec.se);
+	ESM_STATIC_IMPORT_RE.lastIndex = 0;
+	const match = ESM_STATIC_IMPORT_RE.exec(exp);
+	if (!match) return;
+	const parsed = parseStaticImport({
+		type: "static",
+		code: match[0],
+		start: match.index,
+		end: match.index + match[0].length,
+		imports: match.groups.imports,
+		specifier: match.groups.specifier
+	});
+	if (parsed.namespacedImport) bindings.add("*");
+	if (parsed.defaultImport) bindings.add("default");
+	if (parsed.namedImports) for (const name of Object.keys(parsed.namedImports)) bindings.add(name);
+}
+/**
+* Dev-only plugin that lexes, resolves, rewrites and analyzes url imports.
+*
+* - Imports are resolved to ensure they exist on disk
+*
+* - Lexes HMR accept calls and updates import relationships in the module graph
+*
+* - Bare module imports are resolved (by @rollup-plugin/node-resolve) to
+* absolute file paths, e.g.
+*
+*     ```js
+*     import 'foo'
+*     ```
+*     is rewritten to
+*     ```js
+*     import '/@fs//project/node_modules/foo/dist/foo.js'
+*     ```
+*
+* - CSS imports are appended with `.js` since both the js module and the actual
+* css (referenced via `<link>`) may go through the transform pipeline:
+*
+*     ```js
+*     import './style.css'
+*     ```
+*     is rewritten to
+*     ```js
+*     import './style.css.js'
+*     ```
+*/
+function importAnalysisPlugin(config) {
+	const { root, base } = config;
+	const clientPublicPath = path.posix.join(base, CLIENT_PUBLIC_PATH);
+	const enablePartialAccept = config.experimental.hmrPartialAccept;
+	const matchAlias = getAliasPatternMatcher(config.resolve.alias);
+	let _env;
+	let _ssrEnv;
+	function getEnv(ssr) {
+		if (!_ssrEnv || !_env) {
+			const importMetaEnvKeys = {};
+			const userDefineEnv = {};
+			for (const key in config.env) importMetaEnvKeys[key] = JSON.stringify(config.env[key]);
+			for (const key in config.define) if (key.startsWith("import.meta.env.")) userDefineEnv[key.slice(16)] = config.define[key];
+			const env = `import.meta.env = ${serializeDefine({
+				...importMetaEnvKeys,
+				SSR: "__vite_ssr__",
+				...userDefineEnv
+			})};`;
+			_ssrEnv = env.replace("__vite_ssr__", "true");
+			_env = env.replace("__vite_ssr__", "false");
+		}
+		return ssr ? _ssrEnv : _env;
+	}
+	return {
+		name: "vite:import-analysis",
+		applyToEnvironment(environment) {
+			return !environment.config.isBundled;
+		},
+		async transform(source, importer) {
+			const environment = this.environment;
+			const ssr = environment.config.consumer === "server";
+			const moduleGraph = environment.moduleGraph;
+			if (canSkipImportAnalysis(importer)) {
+				debug$4?.(import_picocolors.default.dim(`[skipped] ${prettifyUrl(importer, root)}`));
+				return null;
+			}
+			const msAtStart = debug$4 ? performance$1.now() : 0;
+			await init;
+			let imports;
+			let exports;
+			source = stripBomTag(source);
+			try {
+				[imports, exports] = parse$2(source);
+			} catch (_e) {
+				const e = _e;
+				const { message, showCodeFrame } = createParseErrorInfo(importer, source);
+				this.error(message, showCodeFrame ? e.idx : void 0);
+			}
+			const depsOptimizer = environment.depsOptimizer;
+			const importerModule = moduleGraph.getModuleById(importer);
+			if (!importerModule) throwOutdatedRequest(importer);
+			if (!imports.length && !this._addedImports) {
+				const prunedImports = await moduleGraph.updateModuleInfo(importerModule, /* @__PURE__ */ new Set(), null, /* @__PURE__ */ new Set(), null, false);
+				if (prunedImports) handlePrunedModules(prunedImports, environment);
+				debug$4?.(`${timeFrom(msAtStart)} ${import_picocolors.default.dim(`[no imports] ${prettifyUrl(importer, root)}`)}`);
+				return source;
+			}
+			let hasHMR = false;
+			let isSelfAccepting = false;
+			let hasEnv = false;
+			let needQueryInjectHelper = false;
+			let s;
+			const str = () => s || (s = new MagicString(source));
+			let isPartiallySelfAccepting = false;
+			const importedBindings = enablePartialAccept ? /* @__PURE__ */ new Map() : null;
+			const normalizeUrl = async (url, pos, forceSkipImportAnalysis = false) => {
+				let importerFile = importer;
+				if (depsOptimizer && moduleListContains(depsOptimizer.options.exclude, url)) {
+					await depsOptimizer.scanProcessing;
+					for (const optimizedModule of depsOptimizer.metadata.depInfoList) {
+						if (!optimizedModule.src) continue;
+						if (optimizedModule.file === importerModule.file) importerFile = optimizedModule.src;
+					}
+				}
+				const resolved = await this.resolve(url, importerFile).catch((e) => {
+					if (e instanceof Error) e.pos ??= pos;
+					throw e;
+				});
+				if (!resolved || resolved.meta?.["vite:alias"]?.noResolved) {
+					if (ssr) return [url, null];
+					importerModule.isSelfAccepting = false;
+					moduleGraph._hasResolveFailedErrorModules.add(importerModule);
+					return this.error(`Failed to resolve import "${url}" from "${normalizePath(path.relative(process.cwd(), importerFile))}". Does the file exist?`, pos);
+				}
+				if (isExternalUrl(resolved.id)) return [resolved.id, resolved.id];
+				url = normalizeResolvedIdToUrl(environment, url, resolved);
+				try {
+					const depModule = await moduleGraph._ensureEntryFromUrl(unwrapId(url), canSkipImportAnalysis(url) || forceSkipImportAnalysis, resolved);
+					if (environment.config.consumer === "client" && depModule.lastHMRTimestamp > 0) url = injectQuery(url, `t=${depModule.lastHMRTimestamp}`);
+				} catch (e) {
+					e.pos = pos;
+					throw e;
+				}
+				if (environment.config.consumer === "client") {
+					const isRelative = url[0] === ".";
+					const isSelfImport = !isRelative && cleanUrl(url) === cleanUrl(importer);
+					if (isExplicitImportRequired(url)) url = injectQuery(url, "import");
+					else if ((isRelative || isSelfImport) && !DEP_VERSION_RE.test(url)) {
+						const versionMatch = DEP_VERSION_RE.exec(importer);
+						if (versionMatch) url = injectQuery(url, versionMatch[1]);
+					}
+				}
+				if (!ssr) url = joinUrlSegments(base, url);
+				return [url, resolved.id];
+			};
+			const orderedImportedUrls = new Array(imports.length);
+			const orderedAcceptedUrls = new Array(imports.length);
+			const orderedAcceptedExports = new Array(imports.length);
+			let _isNodeModeResult = config.legacy?.inconsistentCjsInterop ? false : void 0;
+			const isNodeMode = () => {
+				_isNodeModeResult ??= isFilePathESM(importer, config.packageCache);
+				return _isNodeModeResult;
+			};
+			await Promise.all(imports.map(async (importSpecifier, index) => {
+				const { s: start, e: end, ss: expStart, se: expEnd, d: dynamicIndex, a: attributeIndex } = importSpecifier;
+				let specifier = importSpecifier.n;
+				const rawUrl = source.slice(start, end);
+				if (rawUrl === "import.meta") {
+					const prop = source.slice(end, end + 4);
+					if (prop === ".hot") {
+						hasHMR = true;
+						const endHot = end + 4 + (source[end + 4] === "?" ? 1 : 0);
+						if (source.slice(endHot, endHot + 7) === ".accept") if (source.slice(endHot, endHot + 14) === ".acceptExports") {
+							const importAcceptedExports = orderedAcceptedExports[index] = /* @__PURE__ */ new Set();
+							lexAcceptedHmrExports(source, source.indexOf("(", endHot + 14) + 1, importAcceptedExports);
+							isPartiallySelfAccepting = true;
+						} else {
+							const importAcceptedUrls = orderedAcceptedUrls[index] = /* @__PURE__ */ new Set();
+							if (lexAcceptedHmrDeps(source, source.indexOf("(", endHot + 7) + 1, importAcceptedUrls)) isSelfAccepting = true;
+						}
+					} else if (prop === ".env") hasEnv = true;
+					return;
+				} else if (templateLiteralRE.test(rawUrl)) {
+					if (!(rawUrl.includes("${") && rawUrl.includes("}"))) specifier = rawUrl.replace(templateLiteralRE, "$1");
+				}
+				const isDynamicImport = dynamicIndex > -1;
+				if (!isDynamicImport && attributeIndex > -1) str().remove(end + 1, expEnd);
+				if (specifier !== void 0) {
+					if ((isExternalUrl(specifier) && !specifier.startsWith("file://") || isDataUrl(specifier)) && !matchAlias(specifier)) return;
+					if (ssr && !matchAlias(specifier)) {
+						if (shouldExternalize(environment, specifier, importer)) return;
+						if (isBuiltin(environment.config.resolve.builtins, specifier)) return;
+					}
+					if (specifier === clientPublicPath) return;
+					if (specifier[0] === "/" && !(config.assetsInclude(cleanUrl(specifier)) || urlRE$1.test(specifier)) && checkPublicFile(specifier, config)) throw new Error(`Cannot import non-asset file ${specifier} which is inside /public. JS/CSS files inside /public are copied as-is on build and can only be referenced via <script src> or <link href> in html. If you want to get the URL of that file, use ${injectQuery(specifier, "url")} instead.`);
+					let [url, resolvedId] = await normalizeUrl(specifier, start);
+					resolvedId = resolvedId || url;
+					config.safeModulePaths.add(fsPathFromUrl(stripBase(url, base)));
+					if (url !== specifier) {
+						let rewriteDone = false;
+						if (!depsOptimizer?.isOptimizedDepFile(importer) && depsOptimizer?.isOptimizedDepFile(resolvedId) && !optimizedDepChunkRE.test(resolvedId)) {
+							const file = cleanUrl(resolvedId);
+							const depInfo = optimizedDepInfoFromFile(depsOptimizer.metadata, file);
+							const needsInterop = await optimizedDepNeedsInterop(environment, depsOptimizer.metadata, file);
+							if (needsInterop === void 0) {
+								if (depInfo?.isDynamicEntry) config.logger.error(import_picocolors.default.red(`Vite Error, ${url} optimized info should be defined`));
+							} else if (needsInterop) {
+								debug$4?.(`${url} needs interop`);
+								interopNamedImports(str(), importSpecifier, url, index, importer, isNodeMode(), config);
+								rewriteDone = true;
+							}
+						} else if (url.startsWith(wrapId("__vite-browser-external")) && source.slice(expStart, start).includes("{")) {
+							interopNamedImports(str(), importSpecifier, url, index, importer, isNodeMode(), config);
+							rewriteDone = true;
+						}
+						if (!rewriteDone) {
+							const rewrittenUrl = JSON.stringify(url);
+							const s = isDynamicImport ? start : start - 1;
+							const e = isDynamicImport ? end : end + 1;
+							str().overwrite(s, e, rewrittenUrl, { contentOnly: true });
+						}
+					}
+					const hmrUrl = unwrapId(stripBase(url, base));
+					const isLocalImport = !isExternalUrl(hmrUrl) && !isDataUrl(hmrUrl);
+					if (isLocalImport) orderedImportedUrls[index] = hmrUrl;
+					if (enablePartialAccept && importedBindings) extractImportedBindings(resolvedId, source, importSpecifier, importedBindings);
+					if (!isDynamicImport && isLocalImport && environment.config.dev.preTransformRequests) {
+						const url = removeImportQuery(hmrUrl);
+						environment.warmupRequest(url);
+					}
+				} else if (!importer.startsWith(withTrailingSlash(clientDir))) {
+					if (!isInNodeModules(importer)) {
+						if (!hasViteIgnoreRE.test(source.slice(dynamicIndex + 1, end))) this.warn(`\n` + import_picocolors.default.cyan(importerModule.file) + `\n` + import_picocolors.default.reset(generateCodeFrame(source, start, end)) + import_picocolors.default.yellow(`\nThe above dynamic import cannot be analyzed by Vite.\nSee ${import_picocolors.default.blue(`https://github.com/rollup/plugins/tree/master/packages/dynamic-import-vars#limitations`)} for supported dynamic import formats. If this is intended to be left as-is, you can use the /* @vite-ignore */ comment inside the import() call to suppress this warning.\n`));
+					}
+					if (!ssr) {
+						if (!urlIsStringRE.test(rawUrl) || isExplicitImportRequired(rawUrl.slice(1, -1))) {
+							needQueryInjectHelper = true;
+							str().overwrite(start, end, `__vite__injectQuery(${rawUrl}, 'import')`, { contentOnly: true });
+						}
+					}
+				}
+			}));
+			const _orderedImportedUrls = orderedImportedUrls.filter(isDefined);
+			const importedUrls = new Set(_orderedImportedUrls);
+			const staticImportedUrls = new Set(_orderedImportedUrls.map((url) => removeTimestampQuery(url)));
+			const acceptedUrls = mergeAcceptedUrls(orderedAcceptedUrls);
+			const acceptedExports = mergeAcceptedUrls(orderedAcceptedExports);
+			const isClassicWorker = importer.includes("worker_file") && importer.includes("type=classic");
+			if (hasEnv && !isClassicWorker) str().prepend(getEnv(ssr));
+			if (hasHMR && !ssr && !isClassicWorker) {
+				debugHmr?.(`${isSelfAccepting ? `[self-accepts]` : isPartiallySelfAccepting ? `[accepts-exports]` : acceptedUrls.size ? `[accepts-deps]` : `[detected api usage]`} ${prettifyUrl(importer, root)}`);
+				str().prepend(`import { createHotContext as __vite__createHotContext } from "${clientPublicPath}";import.meta.hot = __vite__createHotContext(${JSON.stringify(normalizeHmrUrl(importerModule.url))});`);
+			}
+			if (needQueryInjectHelper) if (isClassicWorker) str().append("\n" + __vite__injectQuery.toString());
+			else str().prepend(`import { injectQuery as __vite__injectQuery } from "${clientPublicPath}";`);
+			const normalizedAcceptedUrls = /* @__PURE__ */ new Set();
+			for (const { url, start, end } of acceptedUrls) {
+				let [normalized, resolvedId] = await normalizeUrl(url, start).catch(() => []);
+				if (resolvedId) {
+					const mod = moduleGraph.getModuleById(resolvedId);
+					if (!mod) {
+						this.error(`module was not found for ${JSON.stringify(resolvedId)}`, start);
+						return;
+					}
+					normalized = mod.url;
+				} else this.error({
+					message: `Failed to resolve ${JSON.stringify(url)} from ${importer}.`,
+					pos: start
+				});
+				normalizedAcceptedUrls.add(normalized);
+				const hmrAccept = normalizeHmrUrl(normalized);
+				str().overwrite(start, end, JSON.stringify(hmrAccept), { contentOnly: true });
+			}
+			if (!isCSSRequest(importer) || SPECIAL_QUERY_RE.test(importer)) {
+				const pluginImports = this._addedImports;
+				if (pluginImports) (await Promise.all([...pluginImports].map((id) => normalizeUrl(id, 0, true)))).forEach(([url]) => importedUrls.add(stripBase(url, base)));
+				if (ssr && importerModule.isSelfAccepting) isSelfAccepting = true;
+				if (!isSelfAccepting && isPartiallySelfAccepting && acceptedExports.size >= exports.length && exports.every((e) => acceptedExports.has(e.n))) isSelfAccepting = true;
+				const prunedImports = await moduleGraph.updateModuleInfo(importerModule, importedUrls, importedBindings, normalizedAcceptedUrls, isPartiallySelfAccepting ? acceptedExports : null, isSelfAccepting, staticImportedUrls);
+				if (prunedImports) handlePrunedModules(prunedImports, environment);
+			}
+			debug$4?.(`${timeFrom(msAtStart)} ${import_picocolors.default.dim(`[${importedUrls.size} imports rewritten] ${prettifyUrl(importer, root)}`)}`);
+			if (s) return transformStableResult(s, importer, config);
+			else return source;
+		}
+	};
+}
+function mergeAcceptedUrls(orderedUrls) {
+	const acceptedUrls = /* @__PURE__ */ new Set();
+	for (const urls of orderedUrls) {
+		if (!urls) continue;
+		for (const url of urls) acceptedUrls.add(url);
+	}
+	return acceptedUrls;
+}
+function createParseErrorInfo(importer, source) {
+	const isVue = importer.endsWith(".vue");
+	const isJsx = importer.endsWith(".jsx") || importer.endsWith(".tsx");
+	const maybeJSX = !isVue && isJSRequest(importer);
+	const probablyBinary = source.includes("�");
+	return {
+		message: "Failed to parse source for import analysis because the content contains invalid JS syntax. " + (isVue ? `Install @vitejs/plugin-vue to handle .vue files.` : maybeJSX ? isJsx ? `If you use tsconfig.json, make sure to not set jsx to preserve.` : `If you are using JSX, make sure to name the file with the .jsx or .tsx extension.` : `You may need to install appropriate plugins to handle the ${path.extname(importer)} file format, or if it's an asset, add "**/*${path.extname(importer)}" to \`assetsInclude\` in your configuration.`),
+		showCodeFrame: !probablyBinary
+	};
+}
+const interopHelper = (m, n) => n || !m?.__esModule ? {
+	...typeof m === "object" && !Array.isArray(m) || typeof m === "function" ? m : {},
+	default: m
+} : m;
+const interopHelperStr = interopHelper.toString().replaceAll("\n", "");
+function interopNamedImports(str, importSpecifier, rewrittenUrl, importIndex, importer, isNodeMode, config) {
+	const source = str.original;
+	const { s: start, e: end, ss: expStart, se: expEnd, d: dynamicIndex } = importSpecifier;
+	const exp = source.slice(expStart, expEnd);
+	if (dynamicIndex > -1) str.overwrite(expStart, expEnd, `import('${rewrittenUrl}').then(m => (${interopHelperStr})(m.default, ${!!config.legacy?.inconsistentCjsInterop ? 0 : 1}))` + getLineBreaks(exp), { contentOnly: true });
+	else {
+		const rewritten = transformCjsImport(exp, rewrittenUrl, source.slice(start, end), importIndex, importer, isNodeMode, config);
+		if (rewritten) {
+			str.overwrite(expStart, expEnd, rewritten.importLine + getLineBreaks(exp), { contentOnly: true });
+			if (rewritten.hoistedAssignments) str.appendLeft(getFileStartIndex(source), rewritten.hoistedAssignments + ";");
+		} else str.overwrite(start, end, rewrittenUrl + getLineBreaks(source.slice(start, end)), { contentOnly: true });
+	}
+}
+function getLineBreaks(str) {
+	return str.includes("\n") ? "\n".repeat(str.split("\n").length - 1) : "";
+}
+/**
+* Detect import statements to a known optimized CJS dependency and provide
+* ES named imports interop. We do this by rewriting named imports to a variable
+* assignment to the corresponding property on the `module.exports` of the cjs
+* module. Note this doesn't support dynamic re-assignments from within the cjs
+* module.
+*
+* Note that es-module-lexer treats `export * from '...'` as an import as well,
+* so, we may encounter ExportAllDeclaration here, in which case `undefined`
+* will be returned.
+*
+* Credits \@csr632 via #837
+*/
+function transformCjsImport(importExp, url, rawUrl, importIndex, importer, isNodeMode, config) {
+	const node = parseAst(importExp).body[0];
+	if (config.command === "serve" && node.type === "ExportAllDeclaration" && !node.exported) config.logger.warn(import_picocolors.default.yellow(`\nUnable to interop \`${importExp}\` in ${importer}, this may lose module exports. Please export "${rawUrl}" as ESM or use named exports instead, e.g. \`export { A, B } from "${rawUrl}"\``));
+	else if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") {
+		if (!node.specifiers.length) return { importLine: `import "${url}"` };
+		const importNames = [];
+		const exportNames = [];
+		let defaultExports = "";
+		for (const spec of node.specifiers) if (spec.type === "ImportSpecifier") {
+			const importedName = getIdentifierNameOrLiteralValue(spec.imported);
+			importNames.push({
+				importedName,
+				localName: spec.local.name
+			});
+		} else if (spec.type === "ImportDefaultSpecifier") importNames.push({
+			importedName: "default",
+			localName: spec.local.name
+		});
+		else if (spec.type === "ImportNamespaceSpecifier") importNames.push({
+			importedName: "*",
+			localName: spec.local.name
+		});
+		else if (spec.type === "ExportSpecifier") {
+			const importedName = getIdentifierNameOrLiteralValue(spec.local);
+			const exportedName = getIdentifierNameOrLiteralValue(spec.exported);
+			if (exportedName === "default") {
+				defaultExports = makeLegalIdentifier(`__vite__cjsExportDefault_${importIndex}`);
+				importNames.push({
+					importedName,
+					localName: defaultExports
+				});
+			} else {
+				const localName = `__vite__cjsExport${spec.exported.type === "Literal" ? `L_${getHash(spec.exported.value)}` : "I_" + spec.exported.name}`;
+				importNames.push({
+					importedName,
+					localName
+				});
+				exportNames.push(`${localName} as ${spec.exported.type === "Literal" ? JSON.stringify(exportedName) : exportedName}`);
+			}
+		}
+		const cjsModuleName = makeLegalIdentifier(`__vite__cjsImport${importIndex}_${rawUrl}`);
+		const importLine = `import ${cjsModuleName} from "${url}"`;
+		const lines = [];
+		importNames.forEach(({ importedName, localName }) => {
+			if (importedName === "*") lines.push(`const ${localName} = (${interopHelperStr})(${cjsModuleName}, ${+isNodeMode})`);
+			else if (importedName === "default") if (isNodeMode) lines.push(`const ${localName} = ${cjsModuleName}`);
+			else lines.push(`const ${localName} = !${cjsModuleName}.__esModule ? ${cjsModuleName} : ${cjsModuleName}.default`);
+			else lines.push(`const ${localName} = ${cjsModuleName}["${importedName}"]`);
+		});
+		if (defaultExports) lines.push(`export default ${defaultExports}`);
+		if (exportNames.length) lines.push(`export { ${exportNames.join(", ")} }`);
+		return {
+			importLine,
+			hoistedAssignments: lines.join("; ")
+		};
+	}
+}
+function getIdentifierNameOrLiteralValue(node) {
+	return node.type === "Identifier" ? node.name : node.value;
+}
+function __vite__injectQuery(url, queryToInject) {
+	if (url[0] !== "." && url[0] !== "/") return url;
+	const pathname = url.replace(/[?#].*$/, "");
+	const { search, hash } = new URL(url, "http://vite.dev");
+	return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
+}
+//#endregion
+//#region src/node/plugins/wasm.ts
+const wasmHelperId = "\0vite/wasm-helper.js";
+const wasmInitRE = /(?<![?#].*)\.wasm\?init/;
+const wasmInitUrlRE = /__VITE_WASM_INIT__([\w$]+)__/g;
+const wasmHelper = async (opts = {}, url) => {
+	let result;
+	if (url.startsWith("data:")) {
+		const urlContent = url.replace(/^data:.*?base64,/, "");
+		let bytes;
+		if (typeof Buffer === "function" && typeof Buffer.from === "function") bytes = Buffer.from(urlContent, "base64");
+		else if (typeof atob === "function") {
+			const binaryString = atob(urlContent);
+			bytes = new Uint8Array(binaryString.length);
+			for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+		} else throw new Error("Failed to decode base64-encoded data URL, Buffer and atob are not supported");
+		result = await WebAssembly.instantiate(bytes, opts);
+	} else result = await instantiateFromUrl(url, opts);
+	return result.instance;
+};
+const wasmHelperCode = wasmHelper.toString();
+const instantiateFromUrl = async (url, opts) => {
+	const response = await fetch(url);
+	const contentType = response.headers.get("Content-Type") || "";
+	if ("instantiateStreaming" in WebAssembly && contentType.startsWith("application/wasm")) return WebAssembly.instantiateStreaming(response, opts);
+	else {
+		const buffer = await response.arrayBuffer();
+		return WebAssembly.instantiate(buffer, opts);
+	}
+};
+const instantiateFromUrlCode = instantiateFromUrl.toString();
+const instantiateFromFile = async (fileUrlString, opts) => {
+	const { readFile } = await import("node:fs/promises");
+	const buffer = await readFile(new URL(
+		fileUrlString,
+		/** #__KEEP__ */
+		import.meta.url
+	));
+	return WebAssembly.instantiate(buffer, opts);
+};
+const instantiateFromFileCode = instantiateFromFile.toString();
+const wasmHelperPlugin = () => {
+	return perEnvironmentPlugin("vite:wasm-helper", (env) => {
+		return {
+			name: "vite:wasm-helper",
+			resolveId: {
+				filter: { id: exactRegex(wasmHelperId) },
+				handler(id) {
+					return id;
+				}
+			},
+			load: {
+				filter: { id: [exactRegex(wasmHelperId), wasmInitRE] },
+				async handler(id) {
+					const ssr = this.environment.config.consumer === "server";
+					if (id === wasmHelperId) return `
+const instantiateFromUrl = ${ssr ? instantiateFromFileCode : instantiateFromUrlCode}
+export default ${wasmHelperCode}
+`;
+					id = id.split("?")[0];
+					let url = await fileToUrl$1(this, id, ssr);
+					assetUrlRE.lastIndex = 0;
+					if (ssr && assetUrlRE.test(url)) url = url.replace("__VITE_ASSET__", "__VITE_WASM_INIT__");
+					return `
+  import initWasm from "${wasmHelperId}"
+  export default opts => initWasm(opts, ${JSON.stringify(url)})
+  `;
+				}
+			},
+			renderChunk: env.config.consumer === "server" ? {
+				filter: { code: wasmInitUrlRE },
+				handler(code, chunk, opts, meta) {
+					const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(opts.format, this.environment.config.isWorker);
+					let match;
+					let s;
+					wasmInitUrlRE.lastIndex = 0;
+					while (match = wasmInitUrlRE.exec(code)) {
+						const [full, referenceId] = match;
+						const file = this.getFileName(referenceId);
+						chunk.viteMetadata.importedAssets.add(cleanUrl(file));
+						const { runtime } = toRelativeRuntime(file, chunk.fileName);
+						s ??= meta.magicString ?? new MagicString(code);
+						s.update(match.index, match.index + full.length, `"+${runtime}+"`);
+					}
+					if (!s) return null;
+					return meta.magicString ? { code: s } : {
+						code: s.toString(),
+						map: this.environment.config.build.sourcemap ? s.generateMap({ hires: "boundary" }) : null
+					};
+				}
+			} : void 0
+		};
+	});
+};
+//#endregion
+//#region src/node/plugins/workerImportMetaUrl.ts
+function err$1(e, pos) {
+	const error = new Error(e);
+	error.pos = pos;
+	return error;
+}
+function findClosingParen(input, fromIndex) {
+	let count = 1;
+	for (let i = fromIndex; i < input.length; i++) {
+		if (input[i] === "(") count++;
+		if (input[i] === ")") count--;
+		if (count === 0) return i;
+	}
+	return -1;
+}
+function extractWorkerTypeFromAst(expression, optsStartIndex) {
+	if (expression.type !== "ObjectExpression") return;
+	let lastSpreadElementIndex = -1;
+	let typeProperty = null;
+	let typePropertyIndex = -1;
+	for (let i = 0; i < expression.properties.length; i++) {
+		const property = expression.properties[i];
+		if (property.type === "SpreadElement") {
+			lastSpreadElementIndex = i;
+			continue;
+		}
+		if (property.type === "Property" && (property.key.type === "Identifier" && property.key.name === "type" || property.key.type === "Literal" && property.key.value === "type")) {
+			typeProperty = property;
+			typePropertyIndex = i;
+		}
+	}
+	if (typePropertyIndex === -1 && lastSpreadElementIndex === -1) return "classic";
+	if (typePropertyIndex < lastSpreadElementIndex) throw err$1("Expected object spread to be used before the definition of the type property. Vite needs a static value for the type property to correctly infer it.", optsStartIndex);
+	if (typeProperty?.value.type !== "Literal") throw err$1("Expected worker options type property to be a literal value.", optsStartIndex);
+	return typeProperty?.value.value === "module" ? "module" : "classic";
+}
+async function parseWorkerOptions(rawOpts, optsStartIndex) {
+	let opts = {};
+	try {
+		opts = evalValue(rawOpts);
+	} catch {
+		const optsNode = (await parseAstAsync(`(${rawOpts})`)).body[0].expression;
+		const type = extractWorkerTypeFromAst(optsNode, optsStartIndex);
+		if (type) return { type };
+		throw err$1("Vite is unable to parse the worker options as the value is not static. To ignore this error, please use /* @vite-ignore */ in the worker options.", optsStartIndex);
+	}
+	if (opts == null) return {};
+	if (typeof opts !== "object") throw err$1(`Expected worker options to be an object, got ${typeof opts}`, optsStartIndex);
+	return opts;
+}
+async function getWorkerType(raw, clean, i) {
+	const commaIndex = clean.indexOf(",", i);
+	if (commaIndex === -1) return "classic";
+	const endIndex = findClosingParen(clean, i);
+	if (commaIndex > endIndex) return "classic";
+	let workerOptString = raw.substring(commaIndex + 1, endIndex);
+	if (hasViteIgnoreRE.test(workerOptString)) return "ignore";
+	const cleanWorkerOptString = clean.substring(commaIndex + 1, endIndex);
+	const trimmedCleanWorkerOptString = cleanWorkerOptString.trim();
+	if (!trimmedCleanWorkerOptString.length) return "classic";
+	if (trimmedCleanWorkerOptString.endsWith(",")) workerOptString = workerOptString.slice(0, cleanWorkerOptString.lastIndexOf(","));
+	const workerOpts = await parseWorkerOptions(workerOptString, commaIndex + 1);
+	if (workerOpts.type && (workerOpts.type === "module" || workerOpts.type === "classic")) return workerOpts.type;
+	return "classic";
+}
+const workerImportMetaUrlRE = /\bnew\s+(?:Worker|SharedWorker)\s*\(\s*(new\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*(?:,\s*)?\))/dg;
+function workerImportMetaUrlPlugin(config) {
+	let workerResolver;
+	const fsResolveOptions = {
+		...config.resolve,
+		root: config.root,
+		isProduction: config.isProduction,
+		isBuild: config.command === "build",
+		packageCache: config.packageCache,
+		asSrc: true
+	};
+	return {
+		name: "vite:worker-import-meta-url",
+		applyToEnvironment(environment) {
+			return environment.config.consumer === "client";
+		},
+		transform: {
+			filter: { code: workerImportMetaUrlRE },
+			async handler(code, id) {
+				const isBundled = this.environment.config.isBundled;
+				let s;
+				const cleanString = stripLiteral(code);
+				const re = new RegExp(workerImportMetaUrlRE);
+				let match;
+				while (match = re.exec(cleanString)) {
+					const [[, endIndex], [expStart, expEnd], [urlStart, urlEnd]] = match.indices;
+					const rawUrl = code.slice(urlStart, urlEnd);
+					if (rawUrl[0] === "`" && rawUrl.includes("${")) this.error(`\`new URL(url, import.meta.url)\` is not supported in dynamic template string.`, expStart);
+					s ||= new MagicString(code);
+					const workerType = await getWorkerType(code, cleanString, endIndex);
+					const url = rawUrl.slice(1, -1);
+					let file;
+					if (url[0] === ".") {
+						file = path.resolve(path.dirname(id), url);
+						file = slash(tryFsResolve(file, fsResolveOptions) ?? file);
+					} else {
+						workerResolver ??= createBackCompatIdResolver(config, {
+							extensions: [],
+							tryIndex: false,
+							preferRelative: true
+						});
+						file = await workerResolver(this.environment, url, id);
+						file ??= url[0] === "/" ? slash(path.join(config.publicDir, url)) : slash(path.resolve(path.dirname(id), url));
+					}
+					if (isBundled && config.isWorker && config.bundleChain.at(-1) === cleanUrl(file)) s.update(expStart, expEnd, "self.location.href");
+					else {
+						let builtUrl;
+						if (isBundled) {
+							const result = await workerFileToUrl(config, file);
+							if (this.environment.config.command === "serve") builtUrl = toOutputFilePathInJSForBundledDev(this.environment, result.entryFilename);
+							else builtUrl = result.entryUrlPlaceholder;
+							for (const file of result.watchedFiles) this.addWatchFile(file);
+						} else {
+							builtUrl = await fileToUrl$1(this, cleanUrl(file));
+							builtUrl = injectQuery(builtUrl, `${WORKER_FILE_ID}&type=${workerType}`);
+						}
+						s.update(expStart, expEnd, `new URL(/* @vite-ignore */ ${JSON.stringify(builtUrl)}, '' + import.meta.url)`);
+					}
+				}
+				if (s) return transformStableResult(s, id, config);
+				return null;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/importAnalysisBuild.ts
+/**
+* A flag for injected helpers. This flag will be set to `false` if the output
+* target is not native es - so that injected helper logic can be conditionally
+* dropped.
+*/
+const isModernFlag = `__VITE_IS_MODERN__`;
+const preloadMethod = `__vitePreload`;
+const preloadMarker = `__VITE_PRELOAD__`;
+const preloadHelperId = "\0vite/preload-helper.js";
+const preloadMarkerRE = new RegExp(preloadMarker, "g");
+function toRelativePath(filename, importer) {
+	const relPath = path.posix.relative(path.posix.dirname(importer), filename);
+	return relPath[0] === "." ? relPath : `./${relPath}`;
+}
+function findPreloadMarker(str, pos = 0) {
+	preloadMarkerRE.lastIndex = pos;
+	return preloadMarkerRE.exec(str)?.index ?? -1;
+}
+/**
+* Helper for preloading CSS and direct imports of async chunks in parallel to
+* the async chunk itself.
+*/
+function detectScriptRel() {
+	const relList = typeof document !== "undefined" && document.createElement("link").relList;
+	return relList && relList.supports && relList.supports("modulepreload") ? "modulepreload" : "preload";
+}
+function preload(baseModule, deps, importerUrl) {
+	let promise = Promise.resolve();
+	if (__VITE_IS_MODERN__ && deps && deps.length > 0) {
+		const links = document.getElementsByTagName("link");
+		const cspNonceMeta = document.querySelector("meta[property=csp-nonce]");
+		const cspNonce = cspNonceMeta?.nonce || cspNonceMeta?.getAttribute("nonce");
+		function allSettled(promises) {
+			return Promise.all(promises.map((p) => Promise.resolve(p).then((value) => ({
+				status: "fulfilled",
+				value
+			}), (reason) => ({
+				status: "rejected",
+				reason
+			}))));
+		}
+		promise = allSettled(deps.map((dep) => {
+			dep = assetsURL(dep, importerUrl);
+			if (dep in seen) return;
+			seen[dep] = true;
+			const isCss = dep.endsWith(".css");
+			const cssSelector = isCss ? "[rel=\"stylesheet\"]" : "";
+			if (!!importerUrl) for (let i = links.length - 1; i >= 0; i--) {
+				const link = links[i];
+				if (link.href === dep && (!isCss || link.rel === "stylesheet")) return;
+			}
+			else if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) return;
+			const link = document.createElement("link");
+			link.rel = isCss ? "stylesheet" : scriptRel;
+			if (!isCss) link.as = "script";
+			link.crossOrigin = "";
+			link.href = dep;
+			if (cspNonce) link.setAttribute("nonce", cspNonce);
+			document.head.appendChild(link);
+			if (isCss) return new Promise((res, rej) => {
+				link.addEventListener("load", res);
+				link.addEventListener("error", () => rej(/* @__PURE__ */ new Error(`Unable to preload CSS for ${dep}`)));
+			});
+		}));
+	}
+	function handlePreloadError(err) {
+		const e = new Event("vite:preloadError", { cancelable: true });
+		e.payload = err;
+		window.dispatchEvent(e);
+		if (!e.defaultPrevented) throw err;
+	}
+	return promise.then((res) => {
+		for (const item of res || []) {
+			if (item.status !== "rejected") continue;
+			handlePreloadError(item.reason);
+		}
+		return baseModule().catch(handlePreloadError);
+	});
+}
+function getPreloadCode(environment, renderBuiltUrlBoolean, isRelativeBase) {
+	const { modulePreload } = environment.config.build;
+	return `const scriptRel = ${modulePreload && modulePreload.polyfill ? `'modulepreload'` : `/* @__PURE__ */ (${detectScriptRel.toString()})()`};const assetsURL = ${renderBuiltUrlBoolean || isRelativeBase ? `function(dep, importerUrl) { return new URL(dep, importerUrl).href }` : `function(dep) { return ${JSON.stringify(environment.config.base)}+dep }`};const seen = {};export const ${preloadMethod} = ${preload.toString()}`;
+}
+/**
+* Build only. During serve this is performed as part of ./importAnalysis.
+*/
+function buildImportAnalysisPlugin(config) {
+	const getInsertPreload = (environment) => environment.config.consumer === "client" && !config.isWorker && !config.build.lib;
+	const renderBuiltUrl = config.experimental.renderBuiltUrl;
+	const isRelativeBase = config.base === "./" || config.base === "";
+	return [{
+		name: "vite:build-import-analysis",
+		renderChunk(code, _, { format }) {
+			if (code.includes(isModernFlag)) {
+				const re = new RegExp(isModernFlag, "g");
+				const isModern = String(format === "es");
+				const isModernWithPadding = isModern + " ".repeat(isModernFlag.length - isModern.length);
+				return {
+					code: code.replace(re, isModernWithPadding),
+					map: null
+				};
+			}
+			return null;
+		},
+		async generateBundle({ format }, bundle) {
+			if (format !== "es") return;
+			await init;
+			if (!getInsertPreload(this.environment)) {
+				const removedPureCssFiles = removedPureCssFilesCache.get(config);
+				if (removedPureCssFiles && removedPureCssFiles.size > 0) for (const file in bundle) {
+					const chunk = bundle[file];
+					if (chunk.type === "chunk" && chunk.code.includes("import")) {
+						const code = chunk.code;
+						let imports;
+						try {
+							imports = parse$2(code)[0].filter((i) => i.d > -1);
+						} catch (e) {
+							const loc = numberToPos(code, e.idx);
+							this.error({
+								name: e.name,
+								message: e.message,
+								stack: e.stack,
+								cause: e.cause,
+								pos: e.idx,
+								loc: {
+									...loc,
+									file: chunk.fileName
+								},
+								frame: generateCodeFrame(code, loc)
+							});
+						}
+						for (const imp of imports) {
+							const { n: name, s: start, e: end, ss: expStart, se: expEnd } = imp;
+							let url = name;
+							if (!url) {
+								const rawUrl = code.slice(start, end);
+								if (rawUrl[0] === `"` && rawUrl[rawUrl.length - 1] === `"` || rawUrl[0] === "`" && rawUrl[rawUrl.length - 1] === "`") url = rawUrl.slice(1, -1);
+							}
+							if (!url) continue;
+							const normalizedFile = path.posix.join(path.posix.dirname(chunk.fileName), url);
+							if (removedPureCssFiles.has(normalizedFile)) chunk.code = chunk.code.slice(0, expStart) + `Promise.resolve({${"".padEnd(expEnd - expStart - 19, " ")}})` + chunk.code.slice(expEnd);
+						}
+					}
+				}
+				return;
+			}
+			const buildSourcemap = this.environment.config.build.sourcemap;
+			const { modulePreload } = this.environment.config.build;
+			for (const file in bundle) {
+				const chunk = bundle[file];
+				if (chunk.type === "chunk" && chunk.code.includes(preloadMarker)) {
+					const code = chunk.code;
+					let imports;
+					try {
+						imports = parse$2(code)[0].filter((i) => i.d > -1);
+					} catch (e) {
+						const loc = numberToPos(code, e.idx);
+						this.error({
+							name: e.name,
+							message: e.message,
+							stack: e.stack,
+							cause: e.cause,
+							pos: e.idx,
+							loc: {
+								...loc,
+								file: chunk.fileName
+							},
+							frame: generateCodeFrame(code, loc)
+						});
+					}
+					const s = new MagicString(code);
+					const rewroteMarkerStartPos = /* @__PURE__ */ new Set();
+					const fileDeps = [];
+					const addFileDep = (url, runtime = false) => {
+						const index = fileDeps.findIndex((dep) => dep.url === url);
+						if (index === -1) return fileDeps.push({
+							url,
+							runtime
+						}) - 1;
+						else return index;
+					};
+					if (imports.length) for (let index = 0; index < imports.length; index++) {
+						const { n: name, s: start, e: end, ss: expStart, se: expEnd } = imports[index];
+						let url = name;
+						if (!url) {
+							const rawUrl = code.slice(start, end);
+							if (rawUrl[0] === `"` && rawUrl[rawUrl.length - 1] === `"` || rawUrl[0] === "`" && rawUrl[rawUrl.length - 1] === "`") url = rawUrl.slice(1, -1);
+						}
+						const deps = /* @__PURE__ */ new Set();
+						let hasRemovedPureCssChunk = false;
+						let normalizedFile = void 0;
+						if (url) {
+							normalizedFile = path.posix.join(path.posix.dirname(chunk.fileName), url);
+							const ownerFilename = chunk.fileName;
+							const analyzed = /* @__PURE__ */ new Set();
+							const addDeps = (filename) => {
+								if (filename === ownerFilename) return;
+								if (analyzed.has(filename)) return;
+								analyzed.add(filename);
+								const chunk = bundle[filename];
+								if (chunk) {
+									deps.add(chunk.fileName);
+									if (chunk.type === "chunk") {
+										chunk.imports.forEach(addDeps);
+										chunk.viteMetadata.importedCss.forEach((file) => {
+											deps.add(file);
+										});
+									}
+								} else {
+									const chunk = removedPureCssFilesCache.get(config).get(filename);
+									if (chunk) {
+										if (chunk.viteMetadata.importedCss.size) {
+											chunk.viteMetadata.importedCss.forEach((file) => {
+												deps.add(file);
+											});
+											hasRemovedPureCssChunk = true;
+										}
+										s.update(expStart, expEnd, "Promise.resolve({})");
+									}
+								}
+							};
+							addDeps(normalizedFile);
+						}
+						let markerStartPos = findPreloadMarker(code, end);
+						if (markerStartPos === -1 && imports.length === 1) markerStartPos = findPreloadMarker(code);
+						if (markerStartPos > 0) {
+							let depsArray = deps.size > 1 || hasRemovedPureCssChunk && deps.size > 0 ? modulePreload === false ? [...deps].filter((d) => d.endsWith(".css")) : [...deps] : [];
+							const resolveDependencies = modulePreload ? modulePreload.resolveDependencies : void 0;
+							if (resolveDependencies && normalizedFile) {
+								const cssDeps = [];
+								const otherDeps = [];
+								for (const dep of depsArray) (dep.endsWith(".css") ? cssDeps : otherDeps).push(dep);
+								depsArray = [...resolveDependencies(normalizedFile, otherDeps, {
+									hostId: file,
+									hostType: "js"
+								}), ...cssDeps];
+							}
+							let renderedDeps;
+							if (renderBuiltUrl) renderedDeps = depsArray.map((dep) => {
+								const replacement = toOutputFilePathInJS(this.environment, dep, "asset", chunk.fileName, "js", toRelativePath);
+								if (typeof replacement === "string") return addFileDep(replacement);
+								return addFileDep(replacement.runtime, true);
+							});
+							else renderedDeps = depsArray.map((d) => isRelativeBase ? addFileDep(toRelativePath(d, file)) : addFileDep(d));
+							s.update(markerStartPos, markerStartPos + preloadMarker.length, renderedDeps.length > 0 ? `__vite__mapDeps([${renderedDeps.join(",")}])` : `[]`);
+							rewroteMarkerStartPos.add(markerStartPos);
+						}
+					}
+					if (fileDeps.length > 0) {
+						const mapDepsCode = `const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=${`[${fileDeps.map((fileDep) => fileDep.runtime ? fileDep.url : JSON.stringify(fileDep.url)).join(",")}]`})))=>i.map(i=>d[i]);\n`;
+						if (code.startsWith("#!")) s.prependLeft(code.indexOf("\n") + 1, mapDepsCode);
+						else s.prepend(mapDepsCode);
+					}
+					let markerStartPos = findPreloadMarker(code);
+					while (markerStartPos >= 0) {
+						if (!rewroteMarkerStartPos.has(markerStartPos)) s.update(markerStartPos, markerStartPos + preloadMarker.length, "void 0");
+						markerStartPos = findPreloadMarker(code, markerStartPos + preloadMarker.length);
+					}
+					if (s.hasChanged()) {
+						chunk.code = s.toString();
+						if (buildSourcemap && chunk.map) {
+							const nextMap = s.generateMap({
+								source: chunk.fileName,
+								hires: "boundary"
+							});
+							const originalFile = chunk.map.file;
+							const map = combineSourcemaps(chunk.fileName, [nextMap, chunk.map]);
+							map.toUrl = () => genSourceMapUrl(map);
+							if (originalFile) map.file = originalFile;
+							const originalDebugId = chunk.map.debugId;
+							chunk.map = map;
+							if (buildSourcemap === "inline") {
+								chunk.code = chunk.code.replace(import_convert_source_map.default.mapFileCommentRegex, "");
+								chunk.code += `\n//# sourceMappingURL=${genSourceMapUrl(map)}`;
+							} else {
+								if (originalDebugId) map.debugId = originalDebugId;
+								const mapAsset = bundle[chunk.fileName + ".map"];
+								if (mapAsset && mapAsset.type === "asset") mapAsset.source = map.toString();
+							}
+						}
+					}
+				}
+			}
+		}
+	}, perEnvironmentPlugin("native:import-analysis-build", (environment) => {
+		return viteBuildImportAnalysisPlugin({
+			preloadCode: getPreloadCode(environment, !!renderBuiltUrl, isRelativeBase),
+			insertPreload: getInsertPreload(environment),
+			optimizeModulePreloadRelativePaths: false,
+			renderBuiltUrl: !!renderBuiltUrl,
+			isRelativeBase
+		});
+	})];
+}
+//#endregion
+//#region src/node/plugins/assetImportMetaUrl.ts
+/**
+* Convert `new URL('./foo.png', import.meta.url)` to its resolved built URL
+*
+* Supports template string with dynamic segments:
+* ```
+* new URL(`./dir/${name}.png`, import.meta.url)
+* // transformed to
+* import.meta.glob('./dir/**.png', { eager: true, import: 'default' })[`./dir/${name}.png`]
+* ```
+*/
+const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*(?:,\s*)?\)/dg;
+function assetImportMetaUrlPlugin(config) {
+	const { publicDir } = config;
+	let assetResolver;
+	const fsResolveOptions = {
+		...config.resolve,
+		root: config.root,
+		isProduction: config.isProduction,
+		isBuild: config.command === "build",
+		packageCache: config.packageCache,
+		asSrc: true
+	};
+	return {
+		name: "vite:asset-import-meta-url",
+		applyToEnvironment(environment) {
+			return environment.config.consumer === "client";
+		},
+		transform: {
+			filter: {
+				id: { exclude: [exactRegex(preloadHelperId), exactRegex(CLIENT_ENTRY)] },
+				code: assetImportMetaUrlRE
+			},
+			async handler(code, id) {
+				let s;
+				const re = new RegExp(assetImportMetaUrlRE);
+				const cleanString = stripLiteral(code);
+				let match;
+				while (match = re.exec(cleanString)) {
+					const [[startIndex, endIndex], [urlStart, urlEnd]] = match.indices;
+					if (hasViteIgnoreRE.test(code.slice(startIndex, urlStart))) continue;
+					const rawUrl = code.slice(urlStart, urlEnd);
+					if (!s) s = new MagicString(code);
+					if (rawUrl[0] === "`" && rawUrl.includes("${")) {
+						const queryDelimiterIndex = getQueryDelimiterIndex(rawUrl);
+						const hasQueryDelimiter = queryDelimiterIndex !== -1;
+						const pureUrl = hasQueryDelimiter ? rawUrl.slice(0, queryDelimiterIndex) + "`" : rawUrl;
+						const queryString = hasQueryDelimiter ? rawUrl.slice(queryDelimiterIndex, -1) : "";
+						const templateLiteral = this.parse(pureUrl).body[0].expression;
+						if (templateLiteral.expressions.length) {
+							const pattern = buildGlobPattern(templateLiteral);
+							if (pattern[0] === "*") continue;
+							const globOptions = {
+								eager: true,
+								import: "default",
+								query: injectQuery(queryString, "url")
+							};
+							s.update(startIndex, endIndex, `new URL((import.meta.glob(${JSON.stringify(pattern)}, ${JSON.stringify(globOptions)}))[${pureUrl}], import.meta.url)`);
+							continue;
+						}
+					}
+					const url = rawUrl.slice(1, -1);
+					if (isDataUrl(url)) continue;
+					let file;
+					if (url[0] === ".") {
+						file = slash(path.resolve(path.dirname(id), url));
+						file = tryFsResolve(file, fsResolveOptions) ?? file;
+					} else {
+						assetResolver ??= createBackCompatIdResolver(config, {
+							extensions: [],
+							mainFields: [],
+							tryIndex: false,
+							preferRelative: true
+						});
+						file = await assetResolver(this.environment, url, id);
+						file ??= url[0] === "/" ? slash(path.join(publicDir, url)) : slash(path.resolve(path.dirname(id), url));
+					}
+					let builtUrl;
+					if (file) try {
+						if (publicDir && isParentDirectory(publicDir, file)) {
+							const publicPath = "/" + path.posix.relative(publicDir, file);
+							builtUrl = await fileToUrl$1(this, publicPath);
+						} else {
+							builtUrl = await fileToUrl$1(this, file);
+							if (tryStatSync(file)?.isFile()) this.addWatchFile(file);
+						}
+					} catch {}
+					if (!builtUrl) {
+						const rawExp = code.slice(startIndex, endIndex);
+						config.logger.warnOnce(`\n${rawExp} doesn't exist at build time, it will remain unchanged to be resolved at runtime. If this is intended, you can use the /* @vite-ignore */ comment to suppress this warning.`);
+						builtUrl = url;
+					}
+					s.update(startIndex, endIndex, `new URL(${JSON.stringify(builtUrl)}, '' + import.meta.url)`);
+				}
+				if (s) return transformStableResult(s, id, config);
+			}
+		}
+	};
+}
+function buildGlobPattern(ast) {
+	let pattern = "";
+	let lastIsGlob = false;
+	for (let i = 0; i < ast.quasis.length; i++) {
+		const str = ast.quasis[i].value.raw;
+		if (str) {
+			pattern += str;
+			lastIsGlob = false;
+		}
+		if (ast.expressions[i] && !lastIsGlob) {
+			pattern += "*";
+			lastIsGlob = true;
+		}
+	}
+	return pattern;
+}
+function getQueryDelimiterIndex(rawUrl) {
+	let bracketsStack = 0;
+	for (let i = 0; i < rawUrl.length; i++) if (rawUrl[i] === "{") bracketsStack++;
+	else if (rawUrl[i] === "}") bracketsStack--;
+	else if (rawUrl[i] === "?" && bracketsStack === 0) return i;
+	return -1;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@rollup+plugin-dynamic-import-vars@2.1.4_rollup@4.59.0/node_modules/@rollup/plugin-dynamic-import-vars/dist/es/index.js
+var VariableDynamicImportError = class extends Error {};
+const example = "For example: import(`./foo/${bar}.js`).";
+function sanitizeString(str) {
+	if (str === "") return str;
+	if (str.includes("*")) throw new VariableDynamicImportError("A dynamic import cannot contain * characters.");
+	return escapePath(str);
+}
+function templateLiteralToGlob(node) {
+	let glob = "";
+	for (let i = 0; i < node.quasis.length; i += 1) {
+		glob += sanitizeString(node.quasis[i].value.raw);
+		if (node.expressions[i]) glob += expressionToGlob(node.expressions[i]);
+	}
+	return glob;
+}
+function callExpressionToGlob(node) {
+	const { callee } = node;
+	if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "concat") return `${expressionToGlob(callee.object)}${node.arguments.map(expressionToGlob).join("")}`;
+	return "*";
+}
+function binaryExpressionToGlob(node) {
+	if (node.operator !== "+") throw new VariableDynamicImportError(`${node.operator} operator is not supported.`);
+	return `${expressionToGlob(node.left)}${expressionToGlob(node.right)}`;
+}
+function expressionToGlob(node) {
+	switch (node.type) {
+		case "TemplateLiteral": return templateLiteralToGlob(node);
+		case "CallExpression": return callExpressionToGlob(node);
+		case "BinaryExpression": return binaryExpressionToGlob(node);
+		case "Literal": return sanitizeString(node.value);
+		default: return "*";
+	}
+}
+const defaultProtocol = "file:";
+const ignoredProtocols = [
+	"data:",
+	"http:",
+	"https:"
+];
+function shouldIgnore(glob) {
+	const containsAsterisk = glob.includes("*");
+	const globURL = new URL(glob, defaultProtocol);
+	const containsIgnoredProtocol = ignoredProtocols.some((ignoredProtocol) => ignoredProtocol === globURL.protocol);
+	return !containsAsterisk || containsIgnoredProtocol;
+}
+function dynamicImportToGlob(node, sourceString) {
+	let glob = expressionToGlob(node);
+	if (shouldIgnore(glob)) return null;
+	glob = glob.replace(/\*\*/g, "*");
+	if (glob.startsWith("*")) throw new VariableDynamicImportError(`invalid import "${sourceString}". It cannot be statically analyzed. Variable dynamic imports must start with ./ and be limited to a specific directory. ${example}`);
+	if (glob.startsWith("/")) throw new VariableDynamicImportError(`invalid import "${sourceString}". Variable absolute imports are not supported, imports must start with ./ in the static part of the import. ${example}`);
+	if (!glob.startsWith("./") && !glob.startsWith("../")) throw new VariableDynamicImportError(`invalid import "${sourceString}". Variable bare imports are not supported, imports must start with ./ in the static part of the import. ${example}`);
+	if (/^\.\/\*\.\w+$/.test(glob)) throw new VariableDynamicImportError(`${`invalid import "${sourceString}". Variable imports cannot import their own directory, place imports in a separate directory or make the import filename more specific. `}${example}`);
+	if (path$1.extname(glob) === "") throw new VariableDynamicImportError(`invalid import "${sourceString}". A file extension must be included in the static part of the import. ${example}`);
+	return glob;
+}
+//#endregion
+//#region src/node/plugins/dynamicImportVars.ts
+const dynamicImportHelperId = "\0vite/dynamic-import-helper.js";
+const relativePathRE = /^\.{1,2}\//;
+const hasDynamicImportRE = /\bimport\s*[(/]/;
+const dynamicImportHelper = (glob, path, segs) => {
+	const v = glob[path];
+	if (v) return typeof v === "function" ? v() : Promise.resolve(v);
+	return new Promise((_, reject) => {
+		(typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(reject.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : ""))));
+	});
+};
+function parseDynamicImportPattern(strings) {
+	const filename = strings.slice(1, -1);
+	const ast = parseAst(strings).body[0].expression;
+	const userPatternQuery = dynamicImportToGlob(ast, filename);
+	if (!userPatternQuery) return null;
+	const [userPattern] = userPatternQuery.split(requestQueryMaybeEscapedSplitRE, 2);
+	let [rawPattern, search] = filename.split(requestQuerySplitRE, 2);
+	let globParams = null;
+	if (search) {
+		search = "?" + search;
+		if (workerOrSharedWorkerRE.test(search) || urlRE$1.test(search) || rawRE$1.test(search)) globParams = {
+			query: search,
+			import: "*"
+		};
+		else globParams = { query: search };
+	}
+	return {
+		globParams,
+		userPattern,
+		rawPattern
+	};
+}
+async function transformDynamicImport(importSource, importer, resolve, root) {
+	if (importSource[1] !== "." && importSource[1] !== "/") {
+		const resolvedFileName = await resolve(importSource.slice(1, -1), importer);
+		if (!resolvedFileName) return null;
+		const relativeFileName = normalizePath(posix.relative(posix.dirname(normalizePath(importer)), normalizePath(resolvedFileName)));
+		importSource = "`" + (relativeFileName[0] === "." ? "" : "./") + relativeFileName + "`";
+	}
+	const dynamicImportPattern = parseDynamicImportPattern(importSource);
+	if (!dynamicImportPattern) return null;
+	const { globParams, rawPattern, userPattern } = dynamicImportPattern;
+	const params = globParams ? `, ${JSON.stringify(globParams)}` : "";
+	const dir = importer ? posix.dirname(importer) : root;
+	const normalized = rawPattern[0] === "/" ? posix.join(root, rawPattern.slice(1)) : posix.join(dir, rawPattern);
+	let newRawPattern = posix.relative(posix.dirname(importer), normalized);
+	if (!relativePathRE.test(newRawPattern)) newRawPattern = `./${newRawPattern}`;
+	const exp = `(import.meta.glob(${JSON.stringify(userPattern)}${params}))`;
+	return {
+		rawPattern: newRawPattern,
+		pattern: userPattern,
+		glob: exp
+	};
+}
+function dynamicImportVarsPlugin(config) {
+	const resolve = createBackCompatIdResolver(config, {
+		preferRelative: true,
+		tryIndex: false,
+		extensions: []
+	});
+	const getFilter = perEnvironmentState((environment) => {
+		const { include, exclude } = environment.config.build.dynamicImportVarsOptions;
+		return createFilter$1(include, exclude);
+	});
+	return {
+		name: "vite:dynamic-import-vars",
+		applyToEnvironment(environment) {
+			if (environment.config.isBundled) {
+				const { include, exclude } = environment.config.build.dynamicImportVarsOptions;
+				return viteDynamicImportVarsPlugin({
+					include,
+					exclude,
+					resolver(id, importer) {
+						return resolve(environment, id, importer);
+					},
+					sourcemap: !!environment.config.build.sourcemap
+				});
+			}
+			return true;
+		},
+		resolveId: {
+			filter: { id: exactRegex(dynamicImportHelperId) },
+			handler(id) {
+				return id;
+			}
+		},
+		load: {
+			filter: { id: exactRegex(dynamicImportHelperId) },
+			handler(_id) {
+				return `export default ${dynamicImportHelper.toString()}`;
+			}
+		},
+		transform: {
+			filter: {
+				id: { exclude: exactRegex(CLIENT_ENTRY) },
+				code: hasDynamicImportRE
+			},
+			async handler(source, importer) {
+				const { environment } = this;
+				if (!getFilter(this)(importer)) return;
+				await init;
+				let imports = [];
+				try {
+					imports = parse$2(source)[0];
+				} catch {
+					return null;
+				}
+				if (!imports.length) return null;
+				let s;
+				let needDynamicImportHelper = false;
+				for (let index = 0; index < imports.length; index++) {
+					const { s: start, e: end, ss: expStart, se: expEnd, d: dynamicIndex } = imports[index];
+					if (dynamicIndex === -1 || source[start] !== "`") continue;
+					if (hasViteIgnoreRE.test(source.slice(expStart, expEnd))) continue;
+					s ||= new MagicString(source);
+					let result;
+					try {
+						result = await transformDynamicImport(source.slice(start, end), importer, (id, importer) => resolve(environment, id, importer), config.root);
+					} catch (error) {
+						this.warn(error);
+					}
+					if (!result) continue;
+					const { rawPattern, glob } = result;
+					needDynamicImportHelper = true;
+					s.overwrite(expStart, expEnd, `__variableDynamicImportRuntimeHelper(${glob}, \`${rawPattern}\`, ${rawPattern.split("/").length})`);
+				}
+				if (s) {
+					if (needDynamicImportHelper) s.prepend(`import __variableDynamicImportRuntimeHelper from "${dynamicImportHelperId}";`);
+					return transformStableResult(s, importer, config);
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/importMetaGlob.ts
+function importGlobPlugin(config) {
+	const importGlobMaps = /* @__PURE__ */ new Map();
+	return {
+		name: "vite:import-glob",
+		applyToEnvironment(environment) {
+			if (environment.config.isBundled) return viteImportGlobPlugin({
+				root: environment.config.root,
+				sourcemap: !!environment.config.build.sourcemap,
+				restoreQueryExtension: environment.config.experimental.importGlobRestoreExtension
+			});
+			return true;
+		},
+		buildStart() {
+			importGlobMaps.clear();
+		},
+		transform: {
+			filter: { code: "import.meta.glob" },
+			async handler(code, id) {
+				const result = await transformGlobImport(code, id, config.root, (im, _, options) => this.resolve(im, id, options).then((i) => i?.id || im), config.experimental.importGlobRestoreExtension, config.logger);
+				if (result) {
+					if (!importGlobMaps.has(this.environment)) importGlobMaps.set(this.environment, /* @__PURE__ */ new Map());
+					const globMatchers = result.matches.map((i) => {
+						const affirmed = [];
+						const negated = [];
+						for (const glob of i.globsResolved) if (glob[0] === "!") negated.push(glob.slice(1));
+						else affirmed.push(glob);
+						const affirmedMatcher = picomatch(affirmed, {
+							noextglob: true,
+							dot: !!i.options.exhaustive,
+							ignore: i.options.exhaustive ? [] : ["**/node_modules/**"]
+						});
+						const negatedMatcher = picomatch(negated, {
+							noextglob: true,
+							dot: !!i.options.exhaustive,
+							ignore: i.options.exhaustive ? [] : ["**/node_modules/**"]
+						});
+						return (file) => {
+							return (affirmed.length === 0 || affirmedMatcher(file)) && !(negated.length > 0 && negatedMatcher(file));
+						};
+					});
+					importGlobMaps.get(this.environment).set(id, globMatchers);
+					return transformStableResult(result.s, id, config);
+				}
+			}
+		},
+		hotUpdate({ type, file, modules: oldModules }) {
+			if (type === "update") return;
+			const importGlobMap = importGlobMaps.get(this.environment);
+			if (!importGlobMap) return;
+			const modules = [];
+			for (const [id, globMatchers] of importGlobMap) if (globMatchers.some((matcher) => matcher(file))) {
+				const mod = this.environment.moduleGraph.getModuleById(id);
+				if (mod) modules.push(mod);
+			}
+			return modules.length > 0 ? [...oldModules, ...modules] : void 0;
+		}
+	};
+}
+const importGlobRE = /\bimport\.meta\.glob(?:<\w+>)?\s*\(/g;
+const objectKeysRE = /\bObject\.keys\(\s*$/;
+const objectValuesRE = /\bObject\.values\(\s*$/;
+const knownOptions = {
+	as: ["string"],
+	eager: ["boolean"],
+	import: ["string"],
+	exhaustive: ["boolean"],
+	query: ["object", "string"],
+	base: ["string"]
+};
+const forceDefaultAs = ["raw", "url"];
+function err(e, pos) {
+	const error = new Error(e);
+	error.pos = pos;
+	return error;
+}
+function parseGlobOptions(rawOpts, optsStartIndex, logger) {
+	let opts = {};
+	try {
+		opts = evalValue(rawOpts);
+	} catch {
+		throw err("Vite is unable to parse the glob options as the value is not static", optsStartIndex);
+	}
+	if (opts == null) return {};
+	for (const key in opts) {
+		if (!(key in knownOptions)) throw err(`Unknown glob option "${key}"`, optsStartIndex);
+		const allowedTypes = knownOptions[key];
+		const valueType = typeof opts[key];
+		if (!allowedTypes.includes(valueType)) throw err(`Expected glob option "${key}" to be of type ${allowedTypes.join(" or ")}, but got ${valueType}`, optsStartIndex);
+	}
+	if (opts.base) {
+		if (opts.base[0] === "!") throw err("Option \"base\" cannot start with \"!\"", optsStartIndex);
+		else if (opts.base[0] !== "/" && !opts.base.startsWith("./") && !opts.base.startsWith("../")) throw err(`Option "base" must start with '/', './' or '../', but got "${opts.base}"`, optsStartIndex);
+	}
+	if (typeof opts.query === "object") {
+		for (const key in opts.query) {
+			const value = opts.query[key];
+			if (![
+				"string",
+				"number",
+				"boolean"
+			].includes(typeof value)) throw err(`Expected glob option "query.${key}" to be of type string, number, or boolean, but got ${typeof value}`, optsStartIndex);
+		}
+		opts.query = stringifyQuery(opts.query);
+	}
+	if (opts.as && logger) {
+		const importSuggestion = forceDefaultAs.includes(opts.as) ? `, import: 'default'` : "";
+		logger.warn(import_picocolors.default.yellow(`The glob option "as" has been deprecated in favour of "query". Please update \`as: '${opts.as}'\` to \`query: '?${opts.as}'${importSuggestion}\`.`));
+	}
+	if (opts.as && forceDefaultAs.includes(opts.as)) {
+		if (opts.import && opts.import !== "default" && opts.import !== "*") throw err(`Option "import" can only be "default" or "*" when "as" is "${opts.as}", but got "${opts.import}"`, optsStartIndex);
+		opts.import = opts.import || "default";
+	}
+	if (opts.as && opts.query) throw err("Options \"as\" and \"query\" cannot be used together", optsStartIndex);
+	if (opts.as) opts.query = opts.as;
+	if (opts.query && opts.query[0] !== "?") opts.query = `?${opts.query}`;
+	return opts;
+}
+async function parseImportGlob(code, importer, root, resolveId, logger) {
+	let cleanCode;
+	try {
+		cleanCode = stripLiteral(code);
+	} catch {
+		return [];
+	}
+	const tasks = Array.from(cleanCode.matchAll(importGlobRE)).map(async (match, index) => {
+		const start = match.index;
+		const err = (msg) => {
+			const e = /* @__PURE__ */ new Error(`Invalid glob import syntax: ${msg}`);
+			e.pos = start;
+			return e;
+		};
+		const end = findCorrespondingCloseParenthesisPosition(cleanCode, start + match[0].length) + 1;
+		if (end <= 0) throw err("Close parenthesis not found");
+		const rootAst = (await parseAstAsync(code.slice(start, end))).body[0];
+		if (rootAst.type !== "ExpressionStatement") throw err(`Expect CallExpression, got ${rootAst.type}`);
+		const ast = rootAst.expression;
+		if (ast.type !== "CallExpression") throw err(`Expect CallExpression, got ${ast.type}`);
+		if (ast.arguments.length < 1 || ast.arguments.length > 2) throw err(`Expected 1-2 arguments, but got ${ast.arguments.length}`);
+		const arg1 = ast.arguments[0];
+		const arg2 = ast.arguments[1];
+		const globs = [];
+		const validateLiteral = (element) => {
+			if (!element) return;
+			if (element.type === "Literal") {
+				if (typeof element.value !== "string") throw err(`Expected glob to be a string, but got "${typeof element.value}"`);
+				globs.push(element.value);
+			} else if (element.type === "TemplateLiteral") {
+				if (element.expressions.length !== 0) throw err(`Expected glob to be a string, but got dynamic template literal`);
+				globs.push(element.quasis[0].value.raw);
+			} else throw err("Could only use literals");
+		};
+		if (arg1.type === "ArrayExpression") for (const element of arg1.elements) validateLiteral(element);
+		else validateLiteral(arg1);
+		let options = {};
+		if (arg2) {
+			if (arg2.type !== "ObjectExpression") throw err(`Expected the second argument to be an object literal, but got "${arg2.type}"`);
+			options = parseGlobOptions(code.slice(start + arg2.start, start + arg2.end), start + arg2.start, logger);
+		}
+		const globsResolved = await Promise.all(globs.map((glob) => toAbsoluteGlob(glob, root, importer, resolveId, options.base)));
+		const isRelative = globs.every((i) => ".!".includes(i[0]));
+		const sliceCode = cleanCode.slice(0, start);
+		const onlyKeys = objectKeysRE.test(sliceCode);
+		let onlyValues = false;
+		if (!onlyKeys) onlyValues = objectValuesRE.test(sliceCode);
+		return {
+			index,
+			globs,
+			globsResolved,
+			isRelative,
+			options,
+			start,
+			end,
+			onlyKeys,
+			onlyValues
+		};
+	});
+	return (await Promise.all(tasks)).filter(Boolean);
+}
+function findCorrespondingCloseParenthesisPosition(cleanCode, openPos) {
+	const closePos = cleanCode.indexOf(")", openPos);
+	if (closePos < 0) return -1;
+	if (!cleanCode.slice(openPos, closePos).includes("(")) return closePos;
+	let remainingParenthesisCount = 0;
+	const cleanCodeLen = cleanCode.length;
+	for (let pos = openPos; pos < cleanCodeLen; pos++) switch (cleanCode[pos]) {
+		case "(":
+			remainingParenthesisCount++;
+			break;
+		case ")":
+			remainingParenthesisCount--;
+			if (remainingParenthesisCount <= 0) return pos;
+	}
+	return -1;
+}
+const importPrefix = "__vite_glob_";
+const { basename: basename$1, dirname: dirname$1, relative: relative$1 } = posix;
+/**
+* @param optimizeExport for dynamicImportVar plugin don't need to optimize export.
+*/
+async function transformGlobImport(code, id, root, resolveId, restoreQueryExtension = false, logger) {
+	id = slash(id);
+	root = slash(root);
+	const isVirtual = isVirtualModule(id);
+	const dir = isVirtual ? void 0 : dirname$1(id);
+	const matches = await parseImportGlob(code, isVirtual ? void 0 : id, root, resolveId, logger);
+	const matchedFiles = /* @__PURE__ */ new Set();
+	if (!matches.length) return null;
+	const s = new MagicString(code);
+	const staticImports = (await Promise.all(matches.map(async ({ globsResolved, isRelative, options, index, start, end, onlyKeys, onlyValues }) => {
+		const files = (await glob(globsResolved, {
+			absolute: true,
+			cwd: getCommonBase(globsResolved) ?? root,
+			dot: !!options.exhaustive,
+			expandDirectories: false,
+			ignore: options.exhaustive ? [] : ["**/node_modules/**"],
+			extglob: false
+		})).filter((file) => file !== id).sort();
+		const objectProps = [];
+		const staticImports = [];
+		const resolvePaths = (file) => {
+			if (!dir) {
+				if (!options.base && isRelative) throw new Error("In virtual modules, all globs must start with '/'");
+				const importPath = `/${relative$1(root, file)}`;
+				let filePath = options.base ? `${relative$1(posix.join(root, options.base), file)}` : importPath;
+				if (options.base && !filePath.startsWith("./") && !filePath.startsWith("../")) filePath = `./${filePath}`;
+				return {
+					filePath,
+					importPath
+				};
+			}
+			let importPath = relative$1(dir, file);
+			if (!importPath.startsWith("./") && !importPath.startsWith("../")) importPath = `./${importPath}`;
+			let filePath;
+			if (options.base) {
+				filePath = relative$1(posix.join(options.base[0] === "/" ? root : dir, options.base), file);
+				if (!filePath.startsWith("./") && !filePath.startsWith("../")) filePath = `./${filePath}`;
+				if (options.base[0] === "/") importPath = `/${relative$1(root, file)}`;
+			} else if (isRelative) filePath = importPath;
+			else {
+				filePath = relative$1(root, file);
+				if (!filePath.startsWith("./") && !filePath.startsWith("../")) filePath = `/${filePath}`;
+			}
+			return {
+				filePath,
+				importPath
+			};
+		};
+		files.forEach((file, i) => {
+			const paths = resolvePaths(file);
+			const filePath = paths.filePath;
+			let importPath = paths.importPath;
+			let importQuery = options.query ?? "";
+			if (onlyKeys) {
+				objectProps.push(`${JSON.stringify(filePath)}: 0`);
+				return;
+			}
+			if (importQuery && importQuery !== "?raw") {
+				const fileExtension = basename$1(file).split(".").slice(-1)[0];
+				if (fileExtension && restoreQueryExtension) importQuery = `${importQuery}&lang.${fileExtension}`;
+			}
+			importPath = `${importPath}${importQuery}`;
+			const importKey = options.import && options.import !== "*" ? options.import : void 0;
+			if (options.eager) {
+				const variableName = `${importPrefix}${index}_${i}`;
+				const expression = importKey ? `{ ${importKey} as ${variableName} }` : `* as ${variableName}`;
+				staticImports.push(`import ${expression} from ${JSON.stringify(importPath)}`);
+				objectProps.push(onlyValues ? `${variableName}` : `${JSON.stringify(filePath)}: ${variableName}`);
+			} else {
+				let importStatement = `import(${JSON.stringify(importPath)})`;
+				if (importKey) importStatement += `.then(m => m[${JSON.stringify(importKey)}])`;
+				objectProps.push(onlyValues ? `() => ${importStatement}` : `${JSON.stringify(filePath)}: () => ${importStatement}`);
+			}
+		});
+		files.forEach((i) => matchedFiles.add(i));
+		const originalLineBreakCount = code.slice(start, end).match(/\n/g)?.length ?? 0;
+		const lineBreaks = originalLineBreakCount > 0 ? "\n".repeat(originalLineBreakCount) : "";
+		let replacement = "";
+		if (onlyKeys) replacement = `{${objectProps.join(",")}${lineBreaks}}`;
+		else if (onlyValues) replacement = `[${objectProps.join(",")}${lineBreaks}]`;
+		else replacement = `/* #__PURE__ */ Object.assign({${objectProps.join(",")}${lineBreaks}})`;
+		s.overwrite(start, end, replacement);
+		return staticImports;
+	}))).flat();
+	if (staticImports.length) s.prepend(`${staticImports.join(";")};`);
+	return {
+		s,
+		matches,
+		files: matchedFiles
+	};
+}
+function globSafePath(path) {
+	return escapePath(normalizePath(path));
+}
+function lastNthChar(str, n) {
+	return str.charAt(str.length - 1 - n);
+}
+function globSafeResolvedPath(resolved, glob) {
+	let numEqual = 0;
+	const maxEqual = Math.min(resolved.length, glob.length);
+	while (numEqual < maxEqual && lastNthChar(resolved, numEqual) === lastNthChar(glob, numEqual)) numEqual += 1;
+	const staticPartEnd = resolved.length - numEqual;
+	const staticPart = resolved.slice(0, staticPartEnd);
+	const dynamicPart = resolved.slice(staticPartEnd);
+	return globSafePath(staticPart) + dynamicPart;
+}
+async function toAbsoluteGlob(glob, root, importer, resolveId, base) {
+	let pre = "";
+	if (glob[0] === "!") {
+		pre = "!";
+		glob = glob.slice(1);
+	}
+	root = globSafePath(root);
+	let dir;
+	if (base) if (base[0] === "/") dir = posix.join(root, base);
+	else dir = posix.resolve(importer ? globSafePath(dirname$1(importer)) : root, base);
+	else dir = importer ? globSafePath(dirname$1(importer)) : root;
+	if (glob[0] === "/") return pre + posix.join(root, glob.slice(1));
+	if (glob.startsWith("./")) return pre + posix.join(dir, glob.slice(2));
+	if (glob.startsWith("../")) return pre + posix.join(dir, glob);
+	if (glob.startsWith("**")) return pre + glob;
+	const isSubImportsPattern = glob[0] === "#" && glob.includes("*");
+	const resolved = normalizePath(await resolveId(glob, importer, { custom: { "vite:import-glob": { isSubImportsPattern } } }) || glob);
+	if (isAbsolute(resolved)) return pre + globSafeResolvedPath(resolved, glob);
+	throw new Error(`Invalid glob: "${glob}" (resolved: "${resolved}"). It must start with '/' or './'`);
+}
+function getCommonBase(globsResolved) {
+	const bases = globsResolved.filter((g) => g[0] !== "!").map((glob) => {
+		let { base } = picomatch.scan(glob);
+		if (posix.basename(base).includes(".")) base = posix.dirname(base);
+		return base;
+	});
+	if (!bases.length) return null;
+	let commonAncestor = "";
+	const dirS = bases[0].split("/");
+	for (let i = 0; i < dirS.length; i++) {
+		const candidate = dirS.slice(0, i + 1).join("/");
+		if (bases.every((base) => base.startsWith(candidate))) commonAncestor = candidate;
+		else break;
+	}
+	if (!commonAncestor) commonAncestor = "/";
+	return commonAncestor;
+}
+function isVirtualModule(id) {
+	return id.startsWith("virtual:") || id[0] === "\0" || !id.includes("/");
+}
+//#endregion
+//#region src/node/plugins/pluginFilter.ts
+function getMatcherString(glob, cwd) {
+	if (glob.startsWith("**") || path.isAbsolute(glob)) return slash(glob);
+	return slash(path.join(cwd, glob));
+}
+function patternToIdFilter(pattern, cwd) {
+	if (pattern instanceof RegExp) return (id) => {
+		const normalizedId = slash(id);
+		const result = pattern.test(normalizedId);
+		pattern.lastIndex = 0;
+		return result;
+	};
+	const matcher = picomatch(getMatcherString(pattern, cwd), { dot: true });
+	return (id) => {
+		return matcher(slash(id));
+	};
+}
+function patternToCodeFilter(pattern) {
+	if (pattern instanceof RegExp) return (code) => {
+		const result = pattern.test(code);
+		pattern.lastIndex = 0;
+		return result;
+	};
+	return (code) => code.includes(pattern);
+}
+function createFilter(exclude, include) {
+	if (!exclude && !include) return;
+	return (input) => {
+		if (exclude?.some((filter) => filter(input))) return false;
+		if (include?.some((filter) => filter(input))) return true;
+		return !(include && include.length > 0);
+	};
+}
+function normalizeFilter(filter) {
+	if (typeof filter === "string" || filter instanceof RegExp) return { include: [filter] };
+	if (Array.isArray(filter)) return { include: filter };
+	return {
+		include: filter.include ? arraify(filter.include) : void 0,
+		exclude: filter.exclude ? arraify(filter.exclude) : void 0
+	};
+}
+function createIdFilter(filter, cwd = process.cwd()) {
+	if (!filter) return;
+	const { exclude, include } = normalizeFilter(filter);
+	const excludeFilter = exclude?.map((p) => patternToIdFilter(p, cwd));
+	const includeFilter = include?.map((p) => patternToIdFilter(p, cwd));
+	return createFilter(excludeFilter, includeFilter);
+}
+function createCodeFilter(filter) {
+	if (!filter) return;
+	const { exclude, include } = normalizeFilter(filter);
+	const excludeFilter = exclude?.map(patternToCodeFilter);
+	const includeFilter = include?.map(patternToCodeFilter);
+	return createFilter(excludeFilter, includeFilter);
+}
+function createModuleTypeFilter(filter) {
+	if (!filter) return;
+	const include = Array.isArray(filter) ? filter : filter.include ?? [];
+	return (moduleType) => include.includes(moduleType);
+}
+function createFilterForTransform(idFilter, codeFilter, moduleTypeFilter, cwd) {
+	if (!idFilter && !codeFilter && !moduleTypeFilter) return;
+	const idFilterFn = createIdFilter(idFilter, cwd);
+	const codeFilterFn = createCodeFilter(codeFilter);
+	const moduleTypeFilterFn = createModuleTypeFilter(moduleTypeFilter);
+	return (id, code, moduleType) => {
+		let fallback = moduleTypeFilterFn?.(moduleType) ?? true;
+		if (!fallback) return false;
+		if (idFilterFn) fallback &&= idFilterFn(id);
+		if (!fallback) return false;
+		if (codeFilterFn) fallback &&= codeFilterFn(code);
+		return fallback;
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.5/node_modules/@vitest/utils/dist/helpers.js
+function notNullish(v) {
+	return v != null;
+}
+function isPrimitive(value) {
+	return value === null || typeof value !== "function" && typeof value !== "object";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.5/node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve$2 = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute$2(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute$2(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute$2 = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vitest+utils@4.1.5/node_modules/@vitest/utils/dist/source-map.js
+var comma = ",".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt[reader.next()];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) value = -2147483648 | -value;
+	return relative + value;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else seg = [
+					genColumn,
+					sourcesIndex,
+					sourceLine,
+					sourceColumn
+				];
+			} else seg = [genColumn];
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[0] - b[0];
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) low = mid + 1;
+		else high = mid - 1;
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
+		else high = lastIndex;
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+function cast(map) {
+	return map;
+}
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+	let { line, column, bias } = needle;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return OMapping(null, null, null, null);
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+	if (index === -1) return OMapping(null, null, null, null);
+	const segment = segments[index];
+	if (segment.length === 1) return OMapping(null, null, null, null);
+	const { names, resolvedSources } = map;
+	return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+	else if (bias === LEAST_UPPER_BOUND) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+const stackIgnorePatterns = [
+	"node:internal",
+	/\/packages\/\w+\/dist\//,
+	/\/@vitest\/\w+\/dist\//,
+	"/vitest/dist/",
+	"/vitest/src/",
+	"/node_modules/chai/",
+	"/node_modules/tinyspy/",
+	"/vite/dist/node/module-runner",
+	"/rolldown-vite/dist/node/module-runner",
+	"/deps/chunk-",
+	"/deps/@vitest",
+	"/deps/loupe",
+	"/deps/chai",
+	"/browser-playwright/dist/locators.js",
+	"/browser-webdriverio/dist/locators.js",
+	"/browser-preview/dist/locators.js",
+	/node:\w+/,
+	/__vitest_test__/,
+	/__vitest_browser__/,
+	"/@id/__x00__vitest/browser",
+	/\/deps\/vitest_/
+];
+const NOW_LENGTH = Date.now().toString().length;
+const REGEXP_VITEST = new RegExp(`vitest=\\d{${NOW_LENGTH}}`);
+function extractLocation(urlLike) {
+	if (!urlLike.includes(":")) return [urlLike];
+	const parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(urlLike.replace(/^\(|\)$/g, ""));
+	if (!parts) return [urlLike];
+	let url = parts[1];
+	if (url.startsWith("async ")) url = url.slice(6);
+	if (url.startsWith("http:") || url.startsWith("https:")) {
+		const urlObj = new URL(url);
+		urlObj.searchParams.delete("import");
+		urlObj.searchParams.delete("browserv");
+		url = urlObj.pathname + urlObj.hash + urlObj.search;
+	}
+	if (url.startsWith("/@fs/")) {
+		const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+		url = url.slice(isWindows ? 5 : 4);
+	}
+	if (url.includes("vitest=")) url = url.replace(REGEXP_VITEST, "").replace(/[?&]$/, "");
+	return [
+		url,
+		parts[2] || void 0,
+		parts[3] || void 0
+	];
+}
+function parseSingleFFOrSafariStack(raw) {
+	let line = raw.trim();
+	if (SAFARI_NATIVE_CODE_REGEXP.test(line)) return null;
+	if (line.includes(" > eval")) line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
+	if (!line.includes("@")) return null;
+	let atIndex = -1;
+	let locationPart = "";
+	let functionName;
+	for (let i = 0; i < line.length; i++) if (line[i] === "@") {
+		const candidateLocation = line.slice(i + 1);
+		if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
+			atIndex = i;
+			locationPart = candidateLocation;
+			functionName = i > 0 ? line.slice(0, i) : void 0;
+			break;
+		}
+	}
+	if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) return null;
+	const [url, lineNumber, columnNumber] = extractLocation(locationPart);
+	if (!url || !lineNumber || !columnNumber) return null;
+	return {
+		file: url,
+		method: functionName || "",
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
+}
+function parseSingleV8Stack(raw) {
+	let line = raw.trim();
+	if (!CHROME_IE_STACK_REGEXP.test(line)) return null;
+	if (line.includes("(eval ")) line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+	let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+	const location = sanitizedLine.match(/ (\(.+\)$)/);
+	sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+	const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+	let method = location && sanitizedLine || "";
+	let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+	if (!file || !lineNumber || !columnNumber) return null;
+	if (method.startsWith("async ")) method = method.slice(6);
+	if (file.startsWith("file://")) file = file.slice(7);
+	file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve$2(file);
+	if (method) method = method.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
+	return {
+		method,
+		file,
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
+}
+function parseStacktrace(stack, options = {}) {
+	const { ignoreStackEntries = stackIgnorePatterns } = options;
+	let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+	const helperIndex = stacks.findLastIndex((s) => s.method.includes("__VITEST_HELPER__"));
+	if (helperIndex >= 0) stacks = stacks.slice(helperIndex + 1);
+	return stacks.map((stack) => {
+		if (options.getUrlId) stack.file = options.getUrlId(stack.file);
+		const map = options.getSourceMap?.(stack.file);
+		if (!map || typeof map !== "object" || !map.version) return shouldFilter(ignoreStackEntries, stack.file) ? null : stack;
+		const position = getOriginalPosition(new DecodedMap(map, stack.file), stack);
+		if (!position) return stack;
+		const { line, column, source, name } = position;
+		let file = source || stack.file;
+		if (file.match(/\/\w:\//)) file = file.slice(1);
+		if (shouldFilter(ignoreStackEntries, file)) return null;
+		if (line != null && column != null) return {
+			line,
+			column,
+			file,
+			method: name || stack.method
+		};
+		return stack;
+	}).filter((s) => s != null);
+}
+function shouldFilter(ignoreStackEntries, file) {
+	return ignoreStackEntries.some((p) => file.match(p));
+}
+function parseFFOrSafariStackTrace(stack) {
+	return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+}
+function parseV8Stacktrace(stack) {
+	return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
+}
+function parseErrorStacktrace(e, options = {}) {
+	if (!e || isPrimitive(e)) return [];
+	if ("stacks" in e && e.stacks) return e.stacks;
+	const stackStr = e.stack || "";
+	let stackFrames = typeof stackStr === "string" ? parseStacktrace(stackStr, options) : [];
+	if (!stackFrames.length) {
+		const e_ = e;
+		if (e_.fileName != null && e_.lineNumber != null && e_.columnNumber != null) stackFrames = parseStacktrace(`${e_.fileName}:${e_.lineNumber}:${e_.columnNumber}`, options);
+		if (e_.sourceURL != null && e_.line != null && e_._column != null) stackFrames = parseStacktrace(`${e_.sourceURL}:${e_.line}:${e_.column}`, options);
+	}
+	if (options.frameFilter) stackFrames = stackFrames.filter((f) => options.frameFilter(e, f) !== false);
+	e.stacks = stackFrames;
+	return stackFrames;
+}
+var DecodedMap = class {
+	_encoded;
+	_decoded;
+	_decodedMemo;
+	url;
+	version;
+	names = [];
+	resolvedSources;
+	constructor(map, from) {
+		this.map = map;
+		const { mappings, names, sources } = map;
+		this.version = map.version;
+		this.names = names || [];
+		this._encoded = mappings || "";
+		this._decodedMemo = memoizedState();
+		this.url = from;
+		this.resolvedSources = (sources || []).map((s) => resolve$2(from, "..", s || ""));
+	}
+};
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function getOriginalPosition(map, needle) {
+	const result = originalPositionFor(map, needle);
+	if (result.column == null) return null;
+	return result;
+}
+//#endregion
+//#region src/node/plugins/forwardConsole.ts
+function forwardConsolePlugin(pluginOpts) {
+	const sourceMapCache = /* @__PURE__ */ new Map();
+	return {
+		name: "vite:forward-console",
+		apply: "serve",
+		configureServer(server) {
+			for (const name of pluginOpts.environments) {
+				const environment = server.environments[name];
+				environment.hot.on("vite:forward-console", (payload) => {
+					if (payload.type === "error" || payload.type === "unhandled-rejection") {
+						const output = formatError(payload, environment, sourceMapCache);
+						environment.config.logger.error(output, { timestamp: true });
+					} else {
+						const output = import_picocolors.default.dim(`[console.${payload.data.level}] `) + payload.data.message;
+						if (payload.data.level === "error") environment.config.logger.error(output, { timestamp: true });
+						else if (payload.data.level === "warn") environment.config.logger.warn(output, { timestamp: true });
+						else environment.config.logger.info(output, { timestamp: true });
+					}
+				});
+			}
+		}
+	};
+}
+function formatError(payload, environment, sourceMapCache) {
+	const error = payload.data;
+	const stacks = parseErrorStacktrace(error, {
+		getUrlId(id) {
+			const moduleGraph = environment.moduleGraph;
+			if (moduleGraph.getModuleById(id)) return id;
+			const resolvedPath = normalizePath(path.resolve(environment.config.root, id.slice(1)));
+			if (moduleGraph.getModuleById(resolvedPath)) return resolvedPath;
+			const files = moduleGraph.getModulesByFile(resolvedPath);
+			if (files && files.size) return files.values().next().value.id;
+			return id;
+		},
+		getSourceMap(id) {
+			if (sourceMapCache.has(id)) return sourceMapCache.get(id);
+			const result = environment.moduleGraph.getModuleById(id)?.transformResult;
+			if (result && !result.map) try {
+				const filePath = id.split("?")[0];
+				const extracted = extractSourcemapFromFile(result.code, filePath, environment.config.logger);
+				sourceMapCache.set(id, extracted?.map);
+				return extracted?.map;
+			} catch {
+				sourceMapCache.set(id, null);
+				return null;
+			}
+			sourceMapCache.set(id, result?.map);
+			return result?.map;
+		},
+		ignoreStackEntries: []
+	});
+	const nearest = stacks.find((stack) => {
+		return [...environment.moduleGraph.getModulesByFile(stack.file) || []].some((m) => m.transformResult) && fs.existsSync(stack.file);
+	});
+	let output = "";
+	output += import_picocolors.default.red(`${payload.type === "unhandled-rejection" ? "[Unhandled rejection]" : "[Unhandled error]"} ${import_picocolors.default.bold(error.name)}: ${error.message}\n`);
+	for (const stack of stacks) {
+		const file = normalizePath(path.relative(environment.config.root, stack.file));
+		output += ` > ${[stack.method, `${file}:${stack.line}:${stack.column}`].filter(Boolean).join(" ")}\n`;
+		if (stack === nearest) {
+			const code = fs.readFileSync(stack.file, "utf-8");
+			output += generateCodeFrame(code, stack).replace(/^/gm, "    ");
+			output += "\n";
+		}
+	}
+	return output;
+}
+//#endregion
+//#region src/node/plugins/esbuildBannerFooterCompatPlugin.ts
+/**
+* This plugin supports `esbuild.banner` and `esbuild.footer` options.
+* esbuild supported these options and Vite exposed them.
+* But this should be done by plugin with transform hook.
+* This plugin makes these options work in rolldown-vite as a backward compat for now.
+*/
+function esbuildBannerFooterCompatPlugin(config) {
+	const options = config.esbuild;
+	if (!options) return;
+	const { include, exclude, banner, footer } = options;
+	if (!banner && !footer) return;
+	const filter = createFilter$1(include || /\.(m?ts|[jt]sx)$/, exclude || /\.js$/);
+	return {
+		name: "vite:esbuild-banner-footer-compat",
+		transform(code, id) {
+			if (filter(id) || filter(cleanUrl(id))) {
+				if (!(this.environment.mode === "dev" || this.environment.mode === "build" && this.environment.config.build.sourcemap)) {
+					if (banner) code = `${banner}\n${code}`;
+					if (footer) code = `${code}\n${footer}`;
+					return code;
+				}
+				let s;
+				const str = () => s || (s = new MagicString(code));
+				if (banner) str().prepend(`${banner}\n`);
+				if (footer) str().append(`${footer}\n`);
+				if (s) return {
+					code: s.toString(),
+					map: s.generateMap({ hires: "boundary" })
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/index.ts
+async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
+	const isBuild = config.command === "build";
+	const isWorker = config.isWorker;
+	const buildPlugins = isBuild || Object.values(config.environments).some((env) => env.isBundled) ? (await Promise.resolve().then(() => build_exports)).resolveBuildPlugins(config) : {
+		pre: [],
+		post: []
+	};
+	const devtoolsIntegrationPlugin = config.devtools.enabled && !isWorker ? await loadDevToolsIntegrationPlugin(config) : null;
+	const { modulePreload } = config.build;
+	return [
+		optimizedDepsPlugin(),
+		!isWorker ? watchPackageDataPlugin(config.packageCache) : null,
+		preAliasPlugin(config),
+		{
+			...alias$1({
+				entries: config.resolve.alias,
+				customResolver: viteAliasCustomResolver
+			}),
+			applyToEnvironment(environment) {
+				if (environment.config.isBundled && !environment.config.resolve.alias.some((v) => v.customResolver)) return viteAliasPlugin({ entries: config.resolve.alias.map((item) => {
+					return {
+						find: item.find,
+						replacement: item.replacement
+					};
+				}) });
+				return true;
+			}
+		},
+		...prePlugins,
+		modulePreload !== false && modulePreload.polyfill ? modulePreloadPolyfillPlugin() : null,
+		...oxcResolvePlugin({
+			root: config.root,
+			isProduction: config.isProduction,
+			isBuild,
+			packageCache: config.packageCache,
+			asSrc: true,
+			optimizeDeps: true,
+			externalize: true,
+			legacyInconsistentCjsInterop: config.legacy?.inconsistentCjsInterop
+		}, isWorker ? {
+			...config,
+			consumer: "client",
+			isBundled: true,
+			optimizeDepsPluginNames: []
+		} : void 0),
+		htmlInlineProxyPlugin(config),
+		cssPlugin(config),
+		esbuildBannerFooterCompatPlugin(config),
+		config.oxc !== false ? {
+			...oxcRuntimePlugin(),
+			applyToEnvironment(environment) {
+				return !environment.config.isBundled;
+			}
+		} : null,
+		config.oxc !== false ? oxcPlugin(config) : null,
+		viteJsonPlugin({
+			...config.json,
+			minify: isBuild
+		}),
+		wasmHelperPlugin(),
+		webWorkerPlugin(config),
+		assetPlugin(config),
+		config.server.forwardConsole.enabled && forwardConsolePlugin({ environments: ["client"] }),
+		...normalPlugins,
+		viteWasmFallbackPlugin(),
+		definePlugin(config),
+		cssPostPlugin(config),
+		buildHtmlPlugin(config),
+		workerImportMetaUrlPlugin(config),
+		assetImportMetaUrlPlugin(config),
+		...buildPlugins.pre,
+		dynamicImportVarsPlugin(config),
+		importGlobPlugin(config),
+		...postPlugins,
+		...buildPlugins.post,
+		devtoolsIntegrationPlugin,
+		clientInjectionsPlugin(config),
+		cssAnalysisPlugin(config),
+		importAnalysisPlugin(config)
+	].filter(Boolean);
+}
+async function loadDevToolsIntegrationPlugin(config) {
+	try {
+		const { DevToolsIntegration } = await import("@vitejs/devtools/integration");
+		return DevToolsIntegration({ config });
+	} catch (error) {
+		config.logger.error(import_picocolors.default.red(`Failed to load Vite DevTools integration: ${error?.message || error?.stack}`), { error });
+		return null;
+	}
+}
+function createPluginHookUtils(plugins) {
+	const sortedPluginsCache = /* @__PURE__ */ new Map();
+	function getSortedPlugins(hookName) {
+		if (sortedPluginsCache.has(hookName)) return sortedPluginsCache.get(hookName);
+		const sorted = getSortedPluginsByHook(hookName, plugins);
+		sortedPluginsCache.set(hookName, sorted);
+		return sorted;
+	}
+	function getSortedPluginHooks(hookName) {
+		return getSortedPlugins(hookName).map((p) => getHookHandler(p[hookName])).filter(Boolean);
+	}
+	return {
+		getSortedPlugins,
+		getSortedPluginHooks
+	};
+}
+function getSortedPluginsByHook(hookName, plugins) {
+	const sortedPlugins = [];
+	let pre = 0, normal = 0, post = 0;
+	for (const plugin of plugins) {
+		const hook = plugin[hookName];
+		if (hook) {
+			if (typeof hook === "object") {
+				if (hook.order === "pre") {
+					sortedPlugins.splice(pre++, 0, plugin);
+					continue;
+				}
+				if (hook.order === "post") {
+					sortedPlugins.splice(pre + normal + post++, 0, plugin);
+					continue;
+				}
+			}
+			sortedPlugins.splice(pre + normal++, 0, plugin);
+		}
+	}
+	return sortedPlugins;
+}
+function getHookHandler(hook) {
+	return typeof hook === "object" ? hook.handler : hook;
+}
+const filterForPlugin = /* @__PURE__ */ new WeakMap();
+function getCachedFilterForPlugin(plugin, hookName) {
+	let filters = filterForPlugin.get(plugin);
+	if (filters && hookName in filters) return filters[hookName];
+	if (!filters) {
+		filters = {};
+		filterForPlugin.set(plugin, filters);
+	}
+	let filter;
+	switch (hookName) {
+		case "resolveId": {
+			const rawFilter = extractFilter(plugin.resolveId)?.id;
+			filters.resolveId = createIdFilter(rawFilter);
+			filter = filters.resolveId;
+			break;
+		}
+		case "load": {
+			const rawFilter = extractFilter(plugin.load)?.id;
+			filters.load = createIdFilter(rawFilter);
+			filter = filters.load;
+			break;
+		}
+		case "transform": {
+			const rawFilters = extractFilter(plugin.transform);
+			filters.transform = createFilterForTransform(rawFilters?.id, rawFilters?.code, rawFilters?.moduleType);
+			filter = filters.transform;
+			break;
+		}
+	}
+	return filter;
+}
+function extractFilter(hook) {
+	return hook && "filter" in hook && hook.filter ? hook.filter : void 0;
+}
+const viteAliasCustomResolver = async function(id, importer, options) {
+	return await this.resolve(id, importer, options) || {
+		id,
+		meta: { "vite:alias": { noResolved: true } }
+	};
+};
+//#endregion
+//#region src/node/server/pluginContainer.ts
+/**
+* This file is refactored into TypeScript based on
+* https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
+*/
+/**
+https://github.com/preactjs/wmr/blob/master/LICENSE
+
+MIT License
+
+Copyright (c) 2020 The Preact 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.
+*/
+const EMPTY_OBJECT = Object.freeze({});
+const debugSourcemapCombineFilter = process.env.DEBUG_VITE_SOURCEMAP_COMBINE_FILTER;
+const debugSourcemapCombine = createDebugger("vite:sourcemap-combine", { onlyWhenFocused: true });
+const debugResolve = createDebugger("vite:resolve");
+const debugPluginResolve = createDebugger("vite:plugin-resolve", { onlyWhenFocused: "vite:plugin" });
+const debugPluginTransform = createDebugger("vite:plugin-transform", { onlyWhenFocused: "vite:plugin" });
+const debugPluginContainerContext = createDebugger("vite:plugin-container-context");
+const ERR_CLOSED_SERVER = "ERR_CLOSED_SERVER";
+function throwClosedServerError() {
+	const err = /* @__PURE__ */ new Error("The server is being restarted or closed. Request is outdated");
+	err.code = ERR_CLOSED_SERVER;
+	throw err;
+}
+/**
+* Create a plugin container with a set of plugins. We pass them as a parameter
+* instead of using environment.plugins to allow the creation of different
+* pipelines working with the same environment (used for createIdResolver).
+*/
+async function createEnvironmentPluginContainer(environment, plugins, watcher, autoStart = true) {
+	const container = new EnvironmentPluginContainer(environment, plugins, watcher, autoStart);
+	await container.resolveRollupOptions();
+	return container;
+}
+var EnvironmentPluginContainer = class {
+	environment;
+	plugins;
+	watcher;
+	_pluginContextMap = /* @__PURE__ */ new Map();
+	_resolvedRollupOptions;
+	_processesing = /* @__PURE__ */ new Set();
+	_seenResolves = {};
+	_moduleNodeToLoadAddedImports = /* @__PURE__ */ new WeakMap();
+	getSortedPluginHooks;
+	getSortedPlugins;
+	moduleGraph;
+	watchFiles = /* @__PURE__ */ new Set();
+	minimalContext;
+	_started = false;
+	_buildStartPromise;
+	_closed = false;
+	/**
+	* @internal use `createEnvironmentPluginContainer` instead
+	*/
+	constructor(environment, plugins, watcher, autoStart = true) {
+		this.environment = environment;
+		this.plugins = plugins;
+		this.watcher = watcher;
+		this._started = !autoStart;
+		this.minimalContext = new MinimalPluginContext({
+			...basePluginContextMeta,
+			watchMode: true
+		}, environment);
+		const utils = createPluginHookUtils(plugins);
+		this.getSortedPlugins = utils.getSortedPlugins;
+		this.getSortedPluginHooks = utils.getSortedPluginHooks;
+		this.moduleGraph = environment.mode === "dev" ? environment.moduleGraph : void 0;
+	}
+	_updateModuleLoadAddedImports(id, addedImports) {
+		const module = this.moduleGraph?.getModuleById(id);
+		if (module) this._moduleNodeToLoadAddedImports.set(module, addedImports);
+	}
+	_getAddedImports(id) {
+		const module = this.moduleGraph?.getModuleById(id);
+		return module ? this._moduleNodeToLoadAddedImports.get(module) || null : null;
+	}
+	getModuleInfo(id) {
+		const module = this.moduleGraph?.getModuleById(id);
+		if (!module) return null;
+		if (!module.info) module.info = new Proxy({
+			id,
+			meta: module.meta || EMPTY_OBJECT
+		}, { get(info, key) {
+			if (key in info) return info[key];
+			if (key === "then") return;
+			throw Error(`[vite] The "${key}" property of ModuleInfo is not supported.`);
+		} });
+		return module.info ?? null;
+	}
+	handleHookPromise(maybePromise) {
+		if (!maybePromise?.then) return maybePromise;
+		const promise = maybePromise;
+		this._processesing.add(promise);
+		return promise.finally(() => this._processesing.delete(promise));
+	}
+	get options() {
+		return this._resolvedRollupOptions;
+	}
+	async resolveRollupOptions() {
+		if (!this._resolvedRollupOptions) {
+			let options = this.environment.config.build.rollupOptions;
+			for (const optionsHook of this.getSortedPluginHooks("options")) {
+				if (this._closed) throwClosedServerError();
+				options = await this.handleHookPromise(optionsHook.call(this.minimalContext, options)) || options;
+			}
+			this._resolvedRollupOptions = options;
+		}
+		return this._resolvedRollupOptions;
+	}
+	_getPluginContext(plugin) {
+		if (!this._pluginContextMap.has(plugin)) this._pluginContextMap.set(plugin, new PluginContext(plugin, this));
+		return this._pluginContextMap.get(plugin);
+	}
+	async hookParallel(hookName, context, args, condition) {
+		const parallelPromises = [];
+		for (const plugin of this.getSortedPlugins(hookName)) {
+			if (condition && !condition(plugin)) continue;
+			const hook = plugin[hookName];
+			const handler = getHookHandler(hook);
+			if (hook.sequential) {
+				await Promise.all(parallelPromises);
+				parallelPromises.length = 0;
+				await handler.apply(context(plugin), args(plugin));
+			} else parallelPromises.push(handler.apply(context(plugin), args(plugin)));
+		}
+		await Promise.all(parallelPromises);
+	}
+	async buildStart(_options) {
+		if (this._started) {
+			if (this._buildStartPromise) await this._buildStartPromise;
+			return;
+		}
+		this._started = true;
+		const config = this.environment.getTopLevelConfig();
+		this._buildStartPromise = this.handleHookPromise(this.hookParallel("buildStart", (plugin) => this._getPluginContext(plugin), () => [this.options], (plugin) => this.environment.name === "client" || config.server.perEnvironmentStartEndDuringDev || plugin.perEnvironmentStartEndDuringDev));
+		await this._buildStartPromise;
+		this._buildStartPromise = void 0;
+	}
+	async resolveId(rawId, importer = join(this.environment.config.root, "index.html"), options) {
+		if (!this._started) {
+			this.buildStart();
+			await this._buildStartPromise;
+		}
+		const skip = options?.skip;
+		const skipCalls = options?.skipCalls;
+		const scan = !!options?.scan;
+		const ssr = this.environment.config.consumer === "server";
+		const ctx = new ResolveIdContext(this, skip, skipCalls, scan);
+		const topLevelConfig = this.environment.getTopLevelConfig();
+		const mergedSkip = new Set(skip);
+		for (const call of skipCalls ?? []) if (call.called || call.id === rawId && call.importer === importer) mergedSkip.add(call.plugin);
+		const resolveStart = debugResolve ? performance$1.now() : 0;
+		let id = null;
+		const partial = {};
+		for (const plugin of this.getSortedPlugins("resolveId")) {
+			if (this._closed && this.environment.config.dev.recoverable) throwClosedServerError();
+			if (mergedSkip?.has(plugin)) continue;
+			const filter = getCachedFilterForPlugin(plugin, "resolveId");
+			if (filter && !filter(rawId)) continue;
+			ctx._plugin = plugin;
+			const normalizedOptions = {
+				kind: options?.kind,
+				attributes: options?.attributes ?? {},
+				custom: options?.custom,
+				isEntry: !!options?.isEntry,
+				ssr,
+				scan
+			};
+			if (isFutureDeprecationEnabled(topLevelConfig, "removePluginHookSsrArgument")) {
+				let ssrTemp = ssr;
+				Object.defineProperty(normalizedOptions, "ssr", {
+					get() {
+						warnFutureDeprecation(topLevelConfig, "removePluginHookSsrArgument", `Used in plugin "${plugin.name}".`);
+						return ssrTemp;
+					},
+					set(v) {
+						ssrTemp = v;
+					}
+				});
+			}
+			const pluginResolveStart = debugPluginResolve ? performance$1.now() : 0;
+			const handler = getHookHandler(plugin.resolveId);
+			const result = await this.handleHookPromise(handler.call(ctx, rawId, importer, normalizedOptions));
+			if (!result) continue;
+			if (typeof result === "string") id = result;
+			else {
+				id = result.id;
+				Object.assign(partial, result);
+			}
+			debugPluginResolve?.(timeFrom(pluginResolveStart), plugin.name, prettifyUrl(id, this.environment.config.root));
+			break;
+		}
+		if (debugResolve && rawId !== id && !rawId.startsWith(FS_PREFIX)) {
+			const key = rawId + id;
+			if (!this._seenResolves[key]) {
+				this._seenResolves[key] = true;
+				debugResolve(`${timeFrom(resolveStart)} ${import_picocolors.default.cyan(rawId)} -> ${import_picocolors.default.dim(id)}`);
+			}
+		}
+		if (id) {
+			partial.id = isExternalUrl(id) || id[0] === "\0" ? id : normalizePath(id);
+			return partial;
+		} else return null;
+	}
+	async load(id) {
+		let ssr = this.environment.config.consumer === "server";
+		const topLevelConfig = this.environment.getTopLevelConfig();
+		const options = { ssr };
+		const ctx = new LoadPluginContext(this);
+		for (const plugin of this.getSortedPlugins("load")) {
+			if (this._closed && this.environment.config.dev.recoverable) throwClosedServerError();
+			const filter = getCachedFilterForPlugin(plugin, "load");
+			if (filter && !filter(id)) continue;
+			ctx._plugin = plugin;
+			if (isFutureDeprecationEnabled(topLevelConfig, "removePluginHookSsrArgument")) Object.defineProperty(options, "ssr", {
+				get() {
+					warnFutureDeprecation(topLevelConfig, "removePluginHookSsrArgument", `Used in plugin "${plugin.name}".`);
+					return ssr;
+				},
+				set(v) {
+					ssr = v;
+				}
+			});
+			const handler = getHookHandler(plugin.load);
+			const result = await this.handleHookPromise(handler.call(ctx, id, options));
+			if (result != null) {
+				if (isObject$1(result)) ctx._updateModuleInfo(id, result);
+				this._updateModuleLoadAddedImports(id, ctx._addedImports);
+				return result;
+			}
+		}
+		this._updateModuleLoadAddedImports(id, ctx._addedImports);
+		return null;
+	}
+	async transform(code, id, options) {
+		let ssr = this.environment.config.consumer === "server";
+		const topLevelConfig = this.environment.getTopLevelConfig();
+		const optionsWithSSR = options ? {
+			...options,
+			ssr,
+			moduleType: options.moduleType ?? "js"
+		} : {
+			ssr,
+			moduleType: "js"
+		};
+		const inMap = options?.inMap;
+		const ctx = new TransformPluginContext(this, id, code, inMap);
+		ctx._addedImports = this._getAddedImports(id);
+		for (const plugin of this.getSortedPlugins("transform")) {
+			if (this._closed && this.environment.config.dev.recoverable) throwClosedServerError();
+			const filter = getCachedFilterForPlugin(plugin, "transform");
+			if (filter && !filter(id, code, optionsWithSSR.moduleType)) continue;
+			if (isFutureDeprecationEnabled(topLevelConfig, "removePluginHookSsrArgument")) Object.defineProperty(optionsWithSSR, "ssr", {
+				get() {
+					warnFutureDeprecation(topLevelConfig, "removePluginHookSsrArgument", `Used in plugin "${plugin.name}".`);
+					return ssr;
+				},
+				set(v) {
+					ssr = v;
+				}
+			});
+			ctx._updateActiveInfo(plugin, id, code);
+			const start = debugPluginTransform ? performance$1.now() : 0;
+			let result;
+			const handler = getHookHandler(plugin.transform);
+			try {
+				result = await this.handleHookPromise(handler.call(ctx, code, id, optionsWithSSR));
+			} catch (e) {
+				ctx.error(e);
+			}
+			if (!result) continue;
+			debugPluginTransform?.(timeFrom(start), plugin.name, prettifyUrl(id, this.environment.config.root));
+			if (isObject$1(result)) {
+				if (result.code !== void 0) {
+					code = result.code;
+					if (result.map) {
+						if (debugSourcemapCombine) result.map.name = plugin.name;
+						ctx.sourcemapChain.push(result.map);
+					}
+				}
+				if (result.moduleType !== void 0) optionsWithSSR.moduleType = result.moduleType;
+				ctx._updateModuleInfo(id, result);
+			} else code = result;
+		}
+		return {
+			code,
+			map: ctx._getCombinedSourcemap(),
+			moduleType: optionsWithSSR.moduleType
+		};
+	}
+	async watchChange(id, change) {
+		const config = this.environment.getTopLevelConfig();
+		await this.hookParallel("watchChange", (plugin) => this._getPluginContext(plugin), () => [id, change], (plugin) => this.environment.name === "client" || config.server.perEnvironmentWatchChangeDuringDev || plugin.perEnvironmentWatchChangeDuringDev);
+	}
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		await Promise.allSettled(Array.from(this._processesing));
+		const config = this.environment.getTopLevelConfig();
+		await this.hookParallel("buildEnd", (plugin) => this._getPluginContext(plugin), () => [], (plugin) => this.environment.name === "client" || config.server.perEnvironmentStartEndDuringDev || plugin.perEnvironmentStartEndDuringDev);
+		await this.hookParallel("closeBundle", (plugin) => this._getPluginContext(plugin), () => []);
+	}
+};
+const basePluginContextMeta = {
+	viteVersion: VERSION,
+	rollupVersion,
+	rolldownVersion
+};
+var BasicMinimalPluginContext = class {
+	meta;
+	_logger;
+	constructor(meta, _logger) {
+		this.meta = meta;
+		this._logger = _logger;
+	}
+	get pluginName() {
+		return "";
+	}
+	debug(rawLog) {
+		const log = this._normalizeRawLog(rawLog);
+		const msg = buildErrorMessage(log, [`debug: ${log.message}`], false);
+		debugPluginContainerContext?.(msg);
+	}
+	info(rawLog) {
+		const log = this._normalizeRawLog(rawLog);
+		const msg = buildErrorMessage(log, [`info: ${log.message}`], false);
+		this._logger.info(msg, {
+			clear: true,
+			timestamp: true
+		});
+	}
+	warn(rawLog) {
+		const log = this._normalizeRawLog(rawLog);
+		const msg = buildErrorMessage(log, [import_picocolors.default.yellow(`warning: ${log.message}`)], false);
+		this._logger.warn(msg, {
+			clear: true,
+			timestamp: true
+		});
+	}
+	error(e) {
+		throw typeof e === "string" ? new Error(e) : e;
+	}
+	_normalizeRawLog(rawLog) {
+		const logValue = typeof rawLog === "function" ? rawLog() : rawLog;
+		return typeof logValue === "string" ? new Error(logValue) : logValue;
+	}
+};
+var MinimalPluginContext = class extends BasicMinimalPluginContext {
+	environment;
+	constructor(meta, environment) {
+		super(meta, environment.logger);
+		this.environment = environment;
+	}
+};
+const fsModule = {
+	appendFile: fsp.appendFile,
+	copyFile: fsp.copyFile,
+	mkdir: fsp.mkdir,
+	mkdtemp: fsp.mkdtemp,
+	readdir: fsp.readdir,
+	readFile: fsp.readFile,
+	realpath: fsp.realpath,
+	rename: fsp.rename,
+	rmdir: fsp.rmdir,
+	stat: fsp.stat,
+	lstat: fsp.lstat,
+	unlink: fsp.unlink,
+	writeFile: fsp.writeFile
+};
+var PluginContext = class extends MinimalPluginContext {
+	_plugin;
+	_container;
+	ssr = false;
+	_scan = false;
+	_activeId = null;
+	_activeCode = null;
+	_resolveSkips;
+	_resolveSkipCalls;
+	get pluginName() {
+		return this._plugin.name;
+	}
+	constructor(_plugin, _container) {
+		super(_container.minimalContext.meta, _container.environment);
+		this._plugin = _plugin;
+		this._container = _container;
+	}
+	fs = fsModule;
+	parse(code, opts) {
+		return parseAst(code, opts);
+	}
+	async resolve(id, importer, options) {
+		let skipCalls;
+		if (options?.skipSelf === false) skipCalls = this._resolveSkipCalls;
+		else if (this._resolveSkipCalls) {
+			const skipCallsTemp = [...this._resolveSkipCalls];
+			const sameCallIndex = this._resolveSkipCalls.findIndex((c) => c.id === id && c.importer === importer && c.plugin === this._plugin);
+			if (sameCallIndex !== -1) skipCallsTemp[sameCallIndex] = {
+				...skipCallsTemp[sameCallIndex],
+				called: true
+			};
+			else skipCallsTemp.push({
+				id,
+				importer,
+				plugin: this._plugin
+			});
+			skipCalls = skipCallsTemp;
+		} else skipCalls = [{
+			id,
+			importer,
+			plugin: this._plugin
+		}];
+		let out = await this._container.resolveId(id, importer, {
+			attributes: options?.attributes,
+			custom: options?.custom,
+			isEntry: !!options?.isEntry,
+			skip: this._resolveSkips,
+			skipCalls,
+			scan: this._scan
+		});
+		if (typeof out === "string") out = { id: out };
+		return out;
+	}
+	async load(options) {
+		await this._container.moduleGraph?.ensureEntryFromUrl(unwrapId(options.id));
+		this._updateModuleInfo(options.id, options);
+		const loadResult = await this._container.load(options.id);
+		const code = typeof loadResult === "object" ? loadResult?.code : loadResult;
+		if (code != null) await this._container.transform(code, options.id);
+		const moduleInfo = this.getModuleInfo(options.id);
+		if (!moduleInfo) throw Error(`Failed to load module with id ${options.id}`);
+		return moduleInfo;
+	}
+	getModuleInfo(id) {
+		return this._container.getModuleInfo(id);
+	}
+	_updateModuleInfo(id, { meta }) {
+		if (meta) {
+			const moduleInfo = this.getModuleInfo(id);
+			if (moduleInfo) moduleInfo.meta = {
+				...moduleInfo.meta,
+				...meta
+			};
+		}
+	}
+	getModuleIds() {
+		return this._container.moduleGraph ? this._container.moduleGraph.idToModuleMap.keys() : Array.prototype[Symbol.iterator]();
+	}
+	addWatchFile(id) {
+		this._container.watchFiles.add(id);
+		if (this._container.watcher) ensureWatchedFile(this._container.watcher, id, this.environment.config.root);
+	}
+	getWatchFiles() {
+		return [...this._container.watchFiles];
+	}
+	emitFile(_assetOrFile) {
+		this._warnIncompatibleMethod(`emitFile`);
+		return "";
+	}
+	setAssetSource() {
+		this._warnIncompatibleMethod(`setAssetSource`);
+	}
+	getFileName() {
+		this._warnIncompatibleMethod(`getFileName`);
+		return "";
+	}
+	debug(log) {
+		const err = this._formatLog(typeof log === "function" ? log() : log);
+		super.debug(err);
+	}
+	info(log) {
+		const err = this._formatLog(typeof log === "function" ? log() : log);
+		super.info(err);
+	}
+	warn(log, position) {
+		const err = this._formatLog(typeof log === "function" ? log() : log, position);
+		super.warn(err);
+	}
+	error(e, position) {
+		throw this._formatLog(e, position);
+	}
+	_formatLog(e, position) {
+		const err = typeof e === "string" ? new Error(e) : e;
+		if (err.pluginCode) return err;
+		err.plugin = this._plugin.name;
+		if (this._activeId && !err.id) err.id = this._activeId;
+		if (this._activeCode) {
+			err.pluginCode = this._activeCode;
+			const pos = position ?? err.pos ?? err.position;
+			if (pos != null) {
+				let errLocation;
+				try {
+					errLocation = numberToPos(this._activeCode, pos);
+				} catch (err2) {
+					this.environment.logger.error(import_picocolors.default.red(`Error in error handler:\n${err2.stack || err2.message}\n`), { error: err2 });
+					throw err;
+				}
+				err.loc = err.loc || {
+					file: err.id,
+					...errLocation
+				};
+				err.frame = err.frame || generateCodeFrame(this._activeCode, pos);
+			} else if (err.loc) {
+				if (!err.frame) {
+					let code = this._activeCode;
+					if (err.loc.file) {
+						err.id = normalizePath(err.loc.file);
+						try {
+							code = fs.readFileSync(err.loc.file, "utf-8");
+						} catch {}
+					}
+					err.frame = generateCodeFrame(code, err.loc);
+				}
+			} else if (err.line && err.column) {
+				err.loc = {
+					file: err.id,
+					line: err.line,
+					column: err.column
+				};
+				err.frame = err.frame || generateCodeFrame(this._activeCode, err.loc);
+			}
+			if (this instanceof TransformPluginContext && typeof err.loc?.line === "number" && typeof err.loc.column === "number") {
+				const rawSourceMap = this._getCombinedSourcemap();
+				if (rawSourceMap && "version" in rawSourceMap) {
+					const { source, line, column } = originalPositionFor$2(new TraceMap(rawSourceMap), {
+						line: Number(err.loc.line),
+						column: Number(err.loc.column)
+					});
+					if (source) err.loc = {
+						file: source,
+						line,
+						column
+					};
+				}
+			}
+		} else if (err.loc) {
+			if (!err.frame) {
+				let code = err.pluginCode;
+				if (err.loc.file) {
+					err.id = normalizePath(err.loc.file);
+					if (!code) try {
+						code = fs.readFileSync(err.loc.file, "utf-8");
+					} catch {}
+				}
+				if (code) err.frame = generateCodeFrame(`${code}`, err.loc);
+			}
+		}
+		if (typeof err.loc?.column !== "number" && typeof err.loc?.line !== "number" && !err.loc?.file) delete err.loc;
+		return err;
+	}
+	_warnIncompatibleMethod(method) {
+		this.environment.logger.warn(import_picocolors.default.cyan(`[plugin:${this._plugin.name}] `) + import_picocolors.default.yellow(`context method ${import_picocolors.default.bold(`${method}()`)} is not supported in serve mode. This plugin is likely not vite-compatible.`));
+	}
+};
+var ResolveIdContext = class extends PluginContext {
+	constructor(container, skip, skipCalls, scan) {
+		super(null, container);
+		this._resolveSkips = skip;
+		this._resolveSkipCalls = skipCalls;
+		this._scan = scan;
+	}
+};
+var LoadPluginContext = class extends PluginContext {
+	_addedImports = null;
+	constructor(container) {
+		super(null, container);
+	}
+	addWatchFile(id) {
+		if (!this._addedImports) this._addedImports = /* @__PURE__ */ new Set();
+		this._addedImports.add(id);
+		super.addWatchFile(id);
+	}
+};
+var TransformPluginContext = class extends LoadPluginContext {
+	filename;
+	originalCode;
+	originalSourcemap = null;
+	sourcemapChain = [];
+	combinedMap = null;
+	constructor(container, id, code, inMap) {
+		super(container);
+		this.filename = id;
+		this.originalCode = code;
+		if (inMap) {
+			if (debugSourcemapCombine) inMap.name = "$inMap";
+			this.sourcemapChain.push(inMap);
+		}
+	}
+	_getCombinedSourcemap() {
+		if (debugSourcemapCombine && debugSourcemapCombineFilter && this.filename.includes(debugSourcemapCombineFilter)) {
+			debugSourcemapCombine("----------", this.filename);
+			debugSourcemapCombine(this.combinedMap);
+			debugSourcemapCombine(this.sourcemapChain);
+			debugSourcemapCombine("----------");
+		}
+		let combinedMap = this.combinedMap;
+		if (combinedMap && !("version" in combinedMap) && combinedMap.mappings === "") {
+			this.sourcemapChain.length = 0;
+			return combinedMap;
+		}
+		for (let m of this.sourcemapChain) {
+			if (typeof m === "string") m = JSON.parse(m);
+			if (!("version" in m)) {
+				if (m.mappings === "") {
+					combinedMap = { mappings: "" };
+					break;
+				}
+				combinedMap = null;
+				break;
+			}
+			if (!combinedMap) {
+				const sm = m;
+				if (sm.sources.length === 1 && !sm.sources[0]) combinedMap = {
+					...sm,
+					sources: [this.filename],
+					sourcesContent: [this.originalCode]
+				};
+				else combinedMap = sm;
+			} else combinedMap = combineSourcemaps(cleanUrl(this.filename), [m, combinedMap]);
+		}
+		if (combinedMap !== this.combinedMap) {
+			this.combinedMap = combinedMap;
+			this.sourcemapChain.length = 0;
+		}
+		return this.combinedMap;
+	}
+	getCombinedSourcemap() {
+		const map = this._getCombinedSourcemap();
+		if (!map || !("version" in map) && map.mappings === "") return new MagicString(this.originalCode).generateMap({
+			includeContent: true,
+			hires: "boundary",
+			source: cleanUrl(this.filename)
+		});
+		return map;
+	}
+	_updateActiveInfo(plugin, id, code) {
+		this._plugin = plugin;
+		this._activeId = id;
+		this._activeCode = code;
+	}
+};
+var PluginContainer = class {
+	environments;
+	constructor(environments) {
+		this.environments = environments;
+	}
+	_getEnvironment(options) {
+		return options?.environment ? options.environment : this.environments[options?.ssr ? "ssr" : "client"];
+	}
+	_getPluginContainer(options) {
+		return this._getEnvironment(options).pluginContainer;
+	}
+	getModuleInfo(id) {
+		const clientModuleInfo = this.environments.client.pluginContainer.getModuleInfo(id);
+		const ssrModuleInfo = this.environments.ssr.pluginContainer.getModuleInfo(id);
+		if (clientModuleInfo == null && ssrModuleInfo == null) return null;
+		return new Proxy({}, { get: (_, key) => {
+			if (key === "meta") {
+				const meta = {};
+				if (ssrModuleInfo) Object.assign(meta, ssrModuleInfo.meta);
+				if (clientModuleInfo) Object.assign(meta, clientModuleInfo.meta);
+				return meta;
+			}
+			if (clientModuleInfo) {
+				if (key in clientModuleInfo) return clientModuleInfo[key];
+			}
+			if (ssrModuleInfo) {
+				if (key in ssrModuleInfo) return ssrModuleInfo[key];
+			}
+		} });
+	}
+	get options() {
+		return this.environments.client.pluginContainer.options;
+	}
+	async buildStart(_options) {
+		return this.environments.client.pluginContainer.buildStart(_options);
+	}
+	async watchChange(id, change) {
+		return this.environments.client.pluginContainer.watchChange(id, change);
+	}
+	async resolveId(rawId, importer, options) {
+		return this._getPluginContainer(options).resolveId(rawId, importer, options);
+	}
+	async load(id, options) {
+		return this._getPluginContainer(options).load(id);
+	}
+	async transform(code, id, options) {
+		return this._getPluginContainer(options).transform(code, id, options);
+	}
+	async close() {}
+};
+/**
+* server.pluginContainer compatibility
+*
+* The default environment is in buildStart, buildEnd, watchChange, and closeBundle hooks,
+* which are called once for all environments, or when no environment is passed in other hooks.
+* The ssrEnvironment is needed for backward compatibility when the ssr flag is passed without
+* an environment. The defaultEnvironment in the main pluginContainer in the server should be
+* the client environment for backward compatibility.
+**/
+function createPluginContainer(environments) {
+	return new PluginContainer(environments);
+}
+//#endregion
+//#region src/node/optimizer/scan.ts
+var ScanEnvironment = class extends BaseEnvironment {
+	mode = "scan";
+	get pluginContainer() {
+		if (!this._pluginContainer) throw new Error(`${this.name} environment.pluginContainer called before initialized`);
+		return this._pluginContainer;
+	}
+	/**
+	* @internal
+	*/
+	_pluginContainer;
+	async init() {
+		if (this._initiated) return;
+		this._initiated = true;
+		this._pluginContainer = await createEnvironmentPluginContainer(this, this.plugins, void 0, false);
+	}
+};
+function devToScanEnvironment(environment) {
+	return {
+		mode: "scan",
+		get name() {
+			return environment.name;
+		},
+		getTopLevelConfig() {
+			return environment.getTopLevelConfig();
+		},
+		get config() {
+			return environment.config;
+		},
+		get logger() {
+			return environment.logger;
+		},
+		get pluginContainer() {
+			return environment.pluginContainer;
+		},
+		get plugins() {
+			return environment.plugins;
+		}
+	};
+}
+const debug$3 = createDebugger("vite:deps");
+const htmlTypesRE = /\.(?:html|vue|svelte|astro|imba)$/;
+const importsRE = /(?<!\/\/.*)(?<=^|;|\*\/)\s*import(?!\s+type)(?:[\w*{}\n\r\t, ]+from)?\s*("[^"]+"|'[^']+')\s*(?=$|;|\/\/|\/\*)/gm;
+function scanImports(environment) {
+	const start = performance$1.now();
+	const { config } = environment;
+	const scanContext = { cancelled: false };
+	async function cancel() {
+		scanContext.cancelled = true;
+	}
+	async function scan() {
+		const entries = await computeEntries(environment);
+		if (!entries.length) {
+			if (!config.optimizeDeps.entries && !config.optimizeDeps.include) environment.logger.warn(import_picocolors.default.yellow("(!) Could not auto-determine entry point from rolldownOptions or html files and there are no explicit optimizeDeps.include patterns. Skipping dependency pre-bundling."));
+			return;
+		}
+		if (scanContext.cancelled) return;
+		debug$3?.(`Crawling dependencies using entries: ${entries.map((entry) => `\n  ${import_picocolors.default.dim(entry)}`).join("")}`);
+		const deps = {};
+		const missing = {};
+		const context = await prepareRolldownScanner(environment, entries, deps, missing);
+		if (scanContext.cancelled) return;
+		try {
+			await context.build();
+			return {
+				deps: orderedDependencies(deps),
+				missing
+			};
+		} catch (e) {
+			e.message = import_picocolors.default.red(`\
+  Failed to scan for dependencies from entries:
+  ${entries.join("\n")}
+
+  `) + e.message;
+			throw e;
+		} finally {
+			if (debug$3) debug$3(`Scan completed in ${(performance$1.now() - start).toFixed(2)}ms: ${Object.keys(orderedDependencies(deps)).sort().map((id) => `\n  ${import_picocolors.default.cyan(id)} -> ${import_picocolors.default.dim(deps[id])}`).join("") || import_picocolors.default.dim("no dependencies found")}`);
+		}
+	}
+	return {
+		cancel,
+		result: scan().then((res) => res ?? {
+			deps: {},
+			missing: {}
+		})
+	};
+}
+async function computeEntries(environment) {
+	let entries = [];
+	const explicitEntryPatterns = environment.config.optimizeDeps.entries;
+	const buildInput = environment.config.build.rollupOptions.input;
+	if (explicitEntryPatterns) entries = await globEntries(explicitEntryPatterns, environment);
+	else if (buildInput) {
+		const resolvePath = async (p) => {
+			const id = (await environment.pluginContainer.resolveId(p, path.join(process.cwd(), "*"), {
+				isEntry: true,
+				scan: true
+			}))?.id;
+			if (id === void 0) throw new Error(`failed to resolve rolldownOptions.input value: ${JSON.stringify(p)}.`);
+			return id;
+		};
+		if (typeof buildInput === "string") entries = [await resolvePath(buildInput)];
+		else if (Array.isArray(buildInput)) entries = await Promise.all(buildInput.map(resolvePath));
+		else if (isObject$1(buildInput)) entries = await Promise.all(Object.values(buildInput).map(resolvePath));
+		else throw new Error("invalid rolldownOptions.input value.");
+	} else entries = await globEntries("**/*.html", environment);
+	entries = entries.filter((entry) => isScannable(entry, environment.config.optimizeDeps.extensions) && fs.existsSync(entry));
+	return entries;
+}
+async function prepareRolldownScanner(environment, entries, deps, missing) {
+	const { plugins: pluginsFromConfig = [], ...rolldownOptions } = environment.config.optimizeDeps.rolldownOptions ?? {};
+	const plugins = await asyncFlatten(arraify(pluginsFromConfig));
+	plugins.push(...rolldownScanPlugin(environment, deps, missing, entries));
+	const transformOptions = deepClone(rolldownOptions.transform) ?? {};
+	if (transformOptions.jsx === void 0) transformOptions.jsx = {};
+	else if (transformOptions.jsx === "react" || transformOptions.jsx === "react-jsx") transformOptions.jsx = getRollupJsxPresets(transformOptions.jsx);
+	if (typeof transformOptions.jsx === "object") transformOptions.jsx.development ??= !environment.config.isProduction;
+	async function build() {
+		await scan({
+			...rolldownOptions,
+			transform: transformOptions,
+			input: entries,
+			logLevel: "silent",
+			plugins
+		});
+	}
+	return { build };
+}
+function orderedDependencies(deps) {
+	const depsList = Object.entries(deps);
+	depsList.sort((a, b) => a[0].localeCompare(b[0]));
+	return Object.fromEntries(depsList);
+}
+async function globEntries(patterns, environment) {
+	const nodeModulesPatterns = [];
+	const regularPatterns = [];
+	for (const pattern of arraify(patterns)) if (pattern.includes("node_modules")) nodeModulesPatterns.push(pattern);
+	else regularPatterns.push(pattern);
+	const sharedOptions = {
+		absolute: true,
+		cwd: environment.config.root,
+		ignore: [`**/${environment.config.build.outDir}/**`, ...environment.config.optimizeDeps.entries ? [] : [`**/__tests__/**`, `**/coverage/**`]]
+	};
+	return (await Promise.all([glob(nodeModulesPatterns, sharedOptions), glob(regularPatterns, {
+		...sharedOptions,
+		ignore: [...sharedOptions.ignore, "**/node_modules/**"]
+	})])).flat();
+}
+const scriptRE = /(<script(?:\s+[a-z_:][-\w:]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^"'<>=\s]+))?)*\s*>)(.*?)<\/script>/gis;
+const commentRE = /<!--.*?-->/gs;
+const srcRE = /\bsrc\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const langRE = /\blang\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const svelteScriptModuleRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const svelteModuleRE = /\smodule\b/i;
+function rolldownScanPlugin(environment, depImports, missing, entries) {
+	const seen = /* @__PURE__ */ new Map();
+	async function resolveId(id, importer, options) {
+		return environment.pluginContainer.resolveId(id, importer && normalizePath(importer), {
+			scan: true,
+			...options
+		});
+	}
+	const resolve = async (id, importer, options) => {
+		const key = JSON.stringify([
+			id,
+			importer && path.dirname(importer),
+			options
+		]);
+		if (seen.has(key)) return seen.get(key);
+		const res = (await resolveId(id, importer, options))?.id;
+		seen.set(key, res);
+		return res;
+	};
+	const optimizeDepsOptions = environment.config.optimizeDeps;
+	const include = optimizeDepsOptions.include;
+	const exclude = [
+		...optimizeDepsOptions.exclude ?? [],
+		"@vite/client",
+		"@vite/env"
+	];
+	const externalUnlessEntry = ({ path }) => ({
+		id: path,
+		external: !entries.includes(path)
+	});
+	const doTransformGlobImport = async (contents, id, loader) => {
+		let transpiledContents;
+		if (loader !== "js") {
+			const result = transformSync(id, contents, {
+				lang: loader,
+				tsconfig: false
+			});
+			if (result.errors.length > 0) throw new AggregateError(result.errors, "oxc transform error");
+			transpiledContents = result.code;
+		} else transpiledContents = contents;
+		return (await transformGlobImport(transpiledContents, id, environment.config.root, resolve))?.s.toString() || transpiledContents;
+	};
+	const scripts = {};
+	const htmlTypeOnLoadCallback = async (id) => {
+		let raw = await fsp.readFile(id, "utf-8");
+		raw = raw.replace(commentRE, "<!---->");
+		const isHtml = id.endsWith(".html");
+		let js = "";
+		let scriptId = 0;
+		const matches = raw.matchAll(scriptRE);
+		for (const [, openTag, content] of matches) {
+			const typeMatch = typeRE.exec(openTag);
+			const type = typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3]);
+			const langMatch = langRE.exec(openTag);
+			const lang = langMatch && (langMatch[1] || langMatch[2] || langMatch[3]);
+			if (isHtml && type !== "module") continue;
+			if (type && !(type.includes("javascript") || type.includes("ecmascript") || type === "module")) continue;
+			let loader = "js";
+			if (lang === "ts" || lang === "tsx" || lang === "jsx") loader = lang;
+			else if (id.endsWith(".astro")) loader = "ts";
+			const srcMatch = srcRE.exec(openTag);
+			if (srcMatch) js += `import ${JSON.stringify(srcMatch[1] || srcMatch[2] || srcMatch[3])}\n`;
+			else if (content.trim()) {
+				const contents = content + (loader.startsWith("ts") ? extractImportPaths(content) : "");
+				const key = `${id}?id=${scriptId++}`;
+				if (contents.includes("import.meta.glob")) scripts[key] = {
+					loader: "js",
+					contents: await doTransformGlobImport(contents, id, loader)
+				};
+				else scripts[key] = {
+					loader,
+					contents
+				};
+				const virtualModulePath = JSON.stringify(virtualModulePrefix + key);
+				let addedImport = false;
+				if (id.endsWith(".svelte")) {
+					let isModule = svelteModuleRE.test(openTag);
+					if (!isModule) {
+						const contextMatch = svelteScriptModuleRE.exec(openTag);
+						isModule = (contextMatch && (contextMatch[1] || contextMatch[2] || contextMatch[3])) === "module";
+					}
+					if (!isModule) {
+						addedImport = true;
+						js += `import ${virtualModulePath}\n`;
+					}
+				}
+				if (!addedImport) js += `export * from ${virtualModulePath}\n`;
+			}
+		}
+		if (!id.endsWith(".vue") || !js.includes("export default")) js += "\nexport default {}";
+		return js;
+	};
+	const ASSET_TYPE_RE = new RegExp(`\\.(${KNOWN_ASSET_TYPES.join("|")})$`);
+	return [
+		{
+			name: "vite:dep-scan:resolve-external-url",
+			resolveId: {
+				filter: { id: externalRE },
+				handler: (id) => ({
+					id,
+					external: true
+				})
+			}
+		},
+		{
+			name: "vite:dep-scan:resolve-data-url",
+			resolveId: {
+				filter: { id: dataUrlRE },
+				handler: (id) => ({
+					id,
+					external: true
+				})
+			}
+		},
+		{
+			name: "vite:dep-scan:local-scripts",
+			resolveId: {
+				filter: { id: virtualModuleRE },
+				handler: (id) => ({ id })
+			},
+			load: {
+				filter: { id: virtualModuleRE },
+				handler(id) {
+					const script = scripts[id.replace(virtualModulePrefix, "")];
+					return {
+						code: script.contents,
+						moduleType: script.loader
+					};
+				}
+			}
+		},
+		{
+			name: "vite:dep-scan:resolve",
+			async resolveId(id, importer) {
+				importer = importer && virtualModuleRE.test(importer) ? importer.replace(virtualModulePrefix, "") : importer;
+				if (htmlTypesRE.test(id)) {
+					const resolved = await resolve(id, importer);
+					if (!resolved) return;
+					if (isInNodeModules(resolved) && isOptimizable(resolved, optimizeDepsOptions)) return;
+					if (shouldExternalizeDep(resolved, id)) return externalUnlessEntry({ path: id });
+					return resolved;
+				}
+				if (/^[\w@][^:]/.test(id)) {
+					if (moduleListContains(exclude, id)) return externalUnlessEntry({ path: id });
+					if (depImports[id]) return externalUnlessEntry({ path: id });
+					const resolved = await resolve(id, importer);
+					if (resolved) {
+						if (shouldExternalizeDep(resolved, id)) return externalUnlessEntry({ path: id });
+						if (isInNodeModules(resolved) || include?.includes(id)) {
+							if (isOptimizable(resolved, optimizeDepsOptions)) depImports[id] = resolved;
+							return externalUnlessEntry({ path: id });
+						} else if (isScannable(resolved, optimizeDepsOptions.extensions)) return path.resolve(resolved);
+						else return externalUnlessEntry({ path: id });
+					} else missing[id] = normalizePath(importer);
+				}
+				if (CSS_LANGS_RE.test(id)) return externalUnlessEntry({ path: id });
+				if (/\.(?:json|json5|wasm)$/.test(id)) return externalUnlessEntry({ path: id });
+				if (ASSET_TYPE_RE.test(id)) return externalUnlessEntry({ path: id });
+				if (SPECIAL_QUERY_RE.test(id)) return {
+					id,
+					external: true
+				};
+				const resolved = await resolve(id, importer);
+				if (resolved) {
+					if (shouldExternalizeDep(resolved, id) || !isScannable(resolved, optimizeDepsOptions.extensions)) return externalUnlessEntry({ path: id });
+					return path.resolve(cleanUrl(resolved));
+				}
+				return externalUnlessEntry({ path: id });
+			}
+		},
+		{
+			name: "vite:dep-scan:load:html",
+			load: {
+				filter: { id: htmlTypesRE },
+				async handler(id) {
+					return {
+						code: await htmlTypeOnLoadCallback(id),
+						moduleType: "js"
+					};
+				}
+			}
+		},
+		...environment.config.esbuild && environment.config.esbuild.jsxInject ? [{
+			name: "vite:dep-scan:transform:jsx-inject",
+			transform: {
+				filter: { id: /\.[jt]sx$/ },
+				handler(code) {
+					const esbuildConfig = environment.config.esbuild;
+					if (esbuildConfig && esbuildConfig.jsxInject) code = esbuildConfig.jsxInject + `\n` + code;
+					return code;
+				}
+			}
+		}] : [],
+		{
+			name: "vite:dep-scan:transform:js-glob",
+			transform: {
+				filter: { code: "import.meta.glob" },
+				async handler(code, id) {
+					if (JS_TYPES_RE.test(id)) {
+						let ext = path.extname(id).slice(1);
+						if (ext === "mjs") ext = "js";
+						return {
+							moduleType: "js",
+							code: await doTransformGlobImport(code, id, ext)
+						};
+					}
+				}
+			}
+		}
+	];
+}
+/**
+* when using TS + (Vue + `<script setup>`) or Svelte, imports may seem
+* unused to esbuild and dropped in the build output, which prevents
+* esbuild from crawling further.
+* the solution is to add `import 'x'` for every source to force
+* esbuild to keep crawling due to potential side effects.
+*/
+function extractImportPaths(code) {
+	code = code.replace(multilineCommentsRE, "/* */").replace(singlelineCommentsRE, "");
+	let js = "";
+	let m;
+	importsRE.lastIndex = 0;
+	while ((m = importsRE.exec(code)) != null) js += `\nimport ${m[1]}`;
+	return js;
+}
+function shouldExternalizeDep(resolvedId, rawId) {
+	if (!path.isAbsolute(resolvedId)) return true;
+	if (resolvedId === rawId || resolvedId.includes("\0")) return true;
+	return false;
+}
+function isScannable(id, extensions) {
+	return JS_TYPES_RE.test(id) || htmlTypesRE.test(id) || extensions?.includes(path.extname(id)) || false;
+}
+//#endregion
+//#region src/node/optimizer/resolve.ts
+function createOptimizeDepsIncludeResolver(environment) {
+	const topLevelConfig = environment.getTopLevelConfig();
+	const resolve = createBackCompatIdResolver(topLevelConfig, {
+		asSrc: false,
+		scan: true,
+		packageCache: /* @__PURE__ */ new Map()
+	});
+	return async (id) => {
+		const lastArrowIndex = id.lastIndexOf(">");
+		if (lastArrowIndex === -1) return await resolve(environment, id, void 0);
+		const nestedRoot = id.substring(0, lastArrowIndex).trim();
+		const nestedPath = id.substring(lastArrowIndex + 1).trim();
+		const basedir = nestedResolveBasedir(nestedRoot, topLevelConfig.root, topLevelConfig.resolve.preserveSymlinks);
+		return await resolve(environment, nestedPath, path.resolve(basedir, "package.json"));
+	};
+}
+/**
+* Expand the glob syntax in `optimizeDeps.include` to proper import paths
+*/
+function expandGlobIds(id, config) {
+	const pkgName = getNpmPackageName(id);
+	if (!pkgName) return [];
+	const pkgData = resolvePackageData(pkgName, config.root, config.resolve.preserveSymlinks, config.packageCache);
+	if (!pkgData) return [];
+	const pattern = "." + id.slice(pkgName.length);
+	const exports = pkgData.data.exports;
+	if (exports) {
+		if (typeof exports === "string" || Array.isArray(exports)) return [pkgName];
+		const possibleExportPaths = [];
+		for (const key in exports) if (key[0] === ".") if (key.includes("*")) {
+			const exportsValue = getFirstExportStringValue(exports[key]);
+			if (!exportsValue) continue;
+			const exportValuePattern = exportsValue.replace(/\*/g, "**/*");
+			const exportsValueGlobRe = new RegExp(exportsValue.split("*").map(escapeRegex).join("(.*)"));
+			possibleExportPaths.push(...globSync(exportValuePattern, {
+				cwd: pkgData.dir,
+				expandDirectories: false,
+				ignore: ["node_modules"]
+			}).map((filePath) => {
+				if (exportsValue.startsWith("./")) filePath = "./" + filePath;
+				const matched = exportsValueGlobRe.exec(slash(filePath));
+				if (matched) {
+					let allGlobSame = matched.length === 2;
+					if (!allGlobSame) {
+						allGlobSame = true;
+						for (let i = 2; i < matched.length; i++) if (matched[i] !== matched[i - 1]) {
+							allGlobSame = false;
+							break;
+						}
+					}
+					if (allGlobSame) return key.replace("*", matched[1]).slice(2);
+				}
+				return "";
+			}).filter(Boolean));
+		} else possibleExportPaths.push(key.slice(2));
+		const isMatch = picomatch(pattern);
+		const matched = possibleExportPaths.filter((p) => isMatch(p)).map((match) => path.posix.join(pkgName, match));
+		matched.unshift(pkgName);
+		return matched;
+	} else {
+		const matched = globSync(pattern, {
+			cwd: pkgData.dir,
+			expandDirectories: false,
+			ignore: ["node_modules"]
+		}).map((match) => path.posix.join(pkgName, slash(match)));
+		matched.unshift(pkgName);
+		return matched;
+	}
+}
+function getFirstExportStringValue(obj) {
+	if (typeof obj === "string") return obj;
+	else if (Array.isArray(obj)) return obj[0];
+	else for (const key in obj) return getFirstExportStringValue(obj[key]);
+}
+/**
+* Continuously resolve the basedir of packages separated by '>'
+*/
+function nestedResolveBasedir(id, basedir, preserveSymlinks = false) {
+	const pkgs = id.split(">").map((pkg) => pkg.trim());
+	for (const pkg of pkgs) basedir = resolvePackageData(pkg, basedir, preserveSymlinks)?.dir || basedir;
+	return basedir;
+}
+//#endregion
+//#region src/node/optimizer/rolldownDepPlugin.ts
+const externalWithConversionNamespace = "vite:dep-pre-bundle:external-conversion";
+const convertedExternalPrefix = "vite-dep-pre-bundle-external:";
+const cjsExternalFacadeNamespace = "vite:cjs-external-facade";
+const nonFacadePrefix = "vite-cjs-external-facade:";
+const externalTypes = [
+	"css",
+	"less",
+	"sass",
+	"scss",
+	"styl",
+	"stylus",
+	"pcss",
+	"postcss",
+	"wasm",
+	"vue",
+	"svelte",
+	"marko",
+	"astro",
+	"imba",
+	"jsx",
+	"tsx",
+	...KNOWN_ASSET_TYPES
+];
+const optionalPeerDepNamespace = "optional-peer-dep:";
+const browserExternalNamespace = "browser-external:";
+function rolldownDepPlugin(environment, qualified, external) {
+	const { isProduction } = environment.config;
+	const { extensions } = environment.config.optimizeDeps;
+	const allExternalTypes = extensions ? externalTypes.filter((type) => !extensions.includes("." + type)) : externalTypes;
+	const esmPackageCache = /* @__PURE__ */ new Map();
+	const cjsPackageCache = /* @__PURE__ */ new Map();
+	const resolveAssets = (resolved, kind) => {
+		if (kind === "require-call") return { id: externalWithConversionNamespace + resolved };
+		return {
+			id: resolved,
+			external: "absolute"
+		};
+	};
+	const _resolve = createBackCompatIdResolver(environment.getTopLevelConfig(), {
+		asSrc: false,
+		scan: true,
+		packageCache: esmPackageCache
+	});
+	const _resolveRequire = createBackCompatIdResolver(environment.getTopLevelConfig(), {
+		asSrc: false,
+		isRequire: true,
+		scan: true,
+		packageCache: cjsPackageCache
+	});
+	const resolve = (id, importer, kind) => {
+		const _importer = importer && importer in qualified ? qualified[importer] : importer;
+		return (kind.startsWith("require") ? _resolveRequire : _resolve)(environment, id, _importer);
+	};
+	const resolveResult = (id, resolved, kind) => {
+		if (resolved.startsWith("__vite-browser-external")) return { id: browserExternalNamespace + id };
+		if (resolved.startsWith("__vite-optional-peer-dep")) return { id: optionalPeerDepNamespace + resolved };
+		if (allExternalTypesReg.test(resolved)) return resolveAssets(resolved, kind);
+		if (isBuiltin(environment.config.resolve.builtins, resolved)) return;
+		if (isExternalUrl(resolved)) return {
+			id: resolved,
+			external: "absolute"
+		};
+		return { id: path.resolve(resolved) };
+	};
+	const allExternalTypesReg = new RegExp(`\\.(` + allExternalTypes.join("|") + `)(\\?.*)?$`);
+	function resolveEntry(id) {
+		const flatId = flattenId(id);
+		if (flatId in qualified) return { id: qualified[flatId] };
+	}
+	const bundleOutputDir = path.join(environment.config.cacheDir, "deps");
+	return [{
+		name: "vite:dep-pre-bundle-assets",
+		resolveId: {
+			filter: { id: allExternalTypesReg },
+			async handler(id, importer, options) {
+				const kind = options.kind;
+				if (id.startsWith(convertedExternalPrefix)) return {
+					id: id.slice(29),
+					external: "absolute"
+				};
+				const resolved = await resolve(id, importer, kind);
+				if (resolved) {
+					if (JS_TYPES_RE.test(resolved)) return {
+						id: isWindows ? resolved.replaceAll("/", "\\") : resolved,
+						external: false
+					};
+					return resolveAssets(resolved, kind);
+				}
+			}
+		},
+		load: {
+			filter: { id: prefixRegex(externalWithConversionNamespace) },
+			handler(id) {
+				const path = id.slice(39);
+				const modulePath = `"${convertedExternalPrefix}${path}"`;
+				return { code: isCSSRequest(path) && !isModuleCSSRequest(path) ? `import ${modulePath};` : `export { default } from ${modulePath};export * from ${modulePath};` };
+			}
+		}
+	}, {
+		name: "vite:dep-pre-bundle",
+		buildEnd() {
+			esmPackageCache.clear();
+			cjsPackageCache.clear();
+		},
+		resolveId: {
+			filter: { id: /^[\w@][^:]/ },
+			async handler(id, importer, options) {
+				const kind = options.kind;
+				if (moduleListContains(external, id)) return {
+					id,
+					external: "absolute"
+				};
+				let entry;
+				if (!importer) {
+					if (entry = resolveEntry(id)) return entry;
+					const aliased = await _resolve(environment, id, void 0, true);
+					if (aliased && (entry = resolveEntry(aliased))) return entry;
+				}
+				const resolved = await resolve(id, importer, kind);
+				if (resolved) return resolveResult(id, resolved, kind);
+			}
+		},
+		load: {
+			filter: { id: [prefixRegex(browserExternalNamespace), prefixRegex(optionalPeerDepNamespace)] },
+			handler(id) {
+				if (id.startsWith(browserExternalNamespace)) {
+					const path = id.slice(17);
+					if (isProduction) return { code: "module.exports = {}" };
+					else return { code: `\
+    module.exports = Object.create(new Proxy({}, {
+        get(_, key) {
+        if (
+            key !== '__esModule' &&
+            key !== '__proto__' &&
+            key !== 'constructor' &&
+            key !== 'splice'
+        ) {
+            console.warn(\`Module "${path}" has been externalized for browser compatibility. Cannot access "${path}.\${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
+        }
+        }
+    }))` };
+				}
+				if (id.startsWith(optionalPeerDepNamespace)) {
+					const [, peerDep, parentDep] = id.slice(18).split(":");
+					return { code: `module.exports = {};throw new Error(\`Could not resolve "${peerDep}" imported by "${parentDep}". Is it installed?\`)` };
+				}
+			}
+		},
+		transform: {
+			filter: { code: assetImportMetaUrlRE },
+			handler(code, id) {
+				let s;
+				const re = new RegExp(assetImportMetaUrlRE);
+				const cleanString = stripLiteral(code);
+				let match;
+				while (match = re.exec(cleanString)) {
+					const [[startIndex, endIndex], [urlStart, urlEnd]] = match.indices;
+					if (hasViteIgnoreRE.test(code.slice(startIndex, urlStart))) continue;
+					const rawUrl = code.slice(urlStart, urlEnd);
+					if (rawUrl[0] === "`" && rawUrl.includes("${")) continue;
+					const url = rawUrl.slice(1, -1);
+					if (isDataUrl(url) || isExternalUrl(url) || url.startsWith("/")) continue;
+					if (!s) s = new MagicString(code);
+					const absolutePath = path.resolve(path.dirname(id), url);
+					const normalizedRelativePath = normalizePath(path.relative(bundleOutputDir, absolutePath));
+					s.update(startIndex, endIndex, `new URL('' + ${JSON.stringify(normalizedRelativePath)}, import.meta.url)`);
+				}
+				if (s) return {
+					code: s.toString(),
+					map: s.generateMap({ hires: "boundary" })
+				};
+			}
+		}
+	}];
+}
+const matchesEntireLine = (text) => `^${escapeRegex(text)}$`;
+function rolldownCjsExternalPlugin(externals, platform) {
+	if (platform === "node") return;
+	if (platform === "neutral") return;
+	const filter = new RegExp(externals.map(matchesEntireLine).join("|"));
+	return {
+		name: "cjs-external",
+		resolveId: {
+			filter: { id: [prefixRegex(nonFacadePrefix), filter] },
+			handler(id, _importer, options) {
+				if (id.startsWith(nonFacadePrefix)) return {
+					id: id.slice(25),
+					external: "absolute"
+				};
+				if (options.kind === "require-call") return { id: cjsExternalFacadeNamespace + id };
+				return {
+					id,
+					external: "absolute"
+				};
+			}
+		},
+		load: {
+			filter: { id: prefixRegex(cjsExternalFacadeNamespace) },
+			handler(id) {
+				const idWithoutNamespace = id.slice(24);
+				return { code: `\
+import * as m from ${JSON.stringify(nonFacadePrefix + idWithoutNamespace)};
+module.exports = ${isNodeBuiltin(idWithoutNamespace) ? "m.default" : "{ ...m }"};
+` };
+			}
+		}
+	};
+}
+//#endregion
+//#region src/node/optimizer/index.ts
+var optimizer_exports = /* @__PURE__ */ __exportAll({
+	addManuallyIncludedOptimizeDeps: () => addManuallyIncludedOptimizeDeps,
+	addOptimizedDepInfo: () => addOptimizedDepInfo,
+	cleanupDepsCacheStaleDirs: () => cleanupDepsCacheStaleDirs,
+	createIsOptimizedDepFile: () => createIsOptimizedDepFile,
+	createIsOptimizedDepUrl: () => createIsOptimizedDepUrl,
+	depsFromOptimizedDepInfo: () => depsFromOptimizedDepInfo,
+	depsLogString: () => depsLogString,
+	discoverProjectDependencies: () => discoverProjectDependencies,
+	extractExportsData: () => extractExportsData,
+	getDepsCacheDir: () => getDepsCacheDir,
+	getOptimizedDepPath: () => getOptimizedDepPath,
+	initDepsOptimizerMetadata: () => initDepsOptimizerMetadata,
+	isDepOptimizationDisabled: () => isDepOptimizationDisabled,
+	loadCachedDepOptimizationMetadata: () => loadCachedDepOptimizationMetadata,
+	optimizeDeps: () => optimizeDeps,
+	optimizeExplicitEnvironmentDeps: () => optimizeExplicitEnvironmentDeps,
+	optimizedDepInfoFromFile: () => optimizedDepInfoFromFile,
+	optimizedDepInfoFromId: () => optimizedDepInfoFromId,
+	optimizedDepNeedsInterop: () => optimizedDepNeedsInterop,
+	runOptimizeDeps: () => runOptimizeDeps,
+	toDiscoveredDependencies: () => toDiscoveredDependencies
+});
+const debug$2 = createDebugger("vite:deps");
+const jsExtensionRE = /\.js$/i;
+function isDepOptimizationDisabled(optimizeDeps) {
+	return optimizeDeps.disabled === true || optimizeDeps.disabled === "dev" || !!optimizeDeps.noDiscovery && !optimizeDeps.include?.length;
+}
+/**
+* Scan and optimize dependencies within a project.
+* Used by Vite CLI when running `vite optimize`.
+*
+* @deprecated the optimization process runs automatically and does not need to be called
+*/
+async function optimizeDeps(config, force = config.optimizeDeps.force, asCommand = false) {
+	const log = asCommand ? config.logger.info : debug$2;
+	config.logger.warn(import_picocolors.default.yellow("manually calling optimizeDeps is deprecated. This is done automatically and does not need to be called manually."));
+	const environment = new ScanEnvironment("client", config);
+	await environment.init();
+	const cachedMetadata = await loadCachedDepOptimizationMetadata(environment, force, asCommand);
+	if (cachedMetadata) return cachedMetadata;
+	const deps = await discoverProjectDependencies(environment).result;
+	await addManuallyIncludedOptimizeDeps(environment, deps);
+	const depsString = depsLogString(Object.keys(deps));
+	log?.(import_picocolors.default.green(`Optimizing dependencies:\n  ${depsString}`));
+	const result = await runOptimizeDeps(environment, toDiscoveredDependencies(environment, deps)).result;
+	await result.commit();
+	return result.metadata;
+}
+async function optimizeExplicitEnvironmentDeps(environment) {
+	const cachedMetadata = await loadCachedDepOptimizationMetadata(environment, environment.config.optimizeDeps.force ?? false, false);
+	if (cachedMetadata) return cachedMetadata;
+	const deps = {};
+	await addManuallyIncludedOptimizeDeps(environment, deps);
+	const result = await runOptimizeDeps(environment, toDiscoveredDependencies(environment, deps)).result;
+	await result.commit();
+	return result.metadata;
+}
+function initDepsOptimizerMetadata(environment, timestamp) {
+	const { lockfileHash, configHash, hash } = getDepHash(environment);
+	return {
+		hash,
+		lockfileHash,
+		configHash,
+		browserHash: getOptimizedBrowserHash(hash, {}, timestamp),
+		optimized: {},
+		chunks: {},
+		discovered: {},
+		depInfoList: []
+	};
+}
+function addOptimizedDepInfo(metadata, type, depInfo) {
+	metadata[type][depInfo.id] = depInfo;
+	metadata.depInfoList.push(depInfo);
+	return depInfo;
+}
+let firstLoadCachedDepOptimizationMetadata = true;
+/**
+* Creates the initial dep optimization metadata, loading it from the deps cache
+* if it exists and pre-bundling isn't forced
+*/
+async function loadCachedDepOptimizationMetadata(environment, force = environment.config.optimizeDeps.force ?? false, asCommand = false) {
+	const log = asCommand ? environment.logger.info : debug$2;
+	if (firstLoadCachedDepOptimizationMetadata) {
+		firstLoadCachedDepOptimizationMetadata = false;
+		setTimeout(() => cleanupDepsCacheStaleDirs(environment.getTopLevelConfig()), 0).unref();
+	}
+	const depsCacheDir = getDepsCacheDir(environment);
+	if (!force) {
+		let cachedMetadata;
+		try {
+			const cachedMetadataPath = path.join(depsCacheDir, METADATA_FILENAME);
+			cachedMetadata = parseDepsOptimizerMetadata(await fsp.readFile(cachedMetadataPath, "utf-8"), depsCacheDir);
+		} catch {}
+		if (cachedMetadata) if (cachedMetadata.lockfileHash !== getLockfileHash(environment)) environment.logger.info("Re-optimizing dependencies because lockfile has changed", { timestamp: true });
+		else if (cachedMetadata.configHash !== getConfigHash(environment)) environment.logger.info("Re-optimizing dependencies because vite config has changed", { timestamp: true });
+		else {
+			log?.(`(${environment.name}) Hash is consistent. Skipping. Use --force to override.`);
+			return cachedMetadata;
+		}
+	} else environment.logger.info("Forced re-optimization of dependencies", { timestamp: true });
+	debug$2?.(`(${environment.name}) ${import_picocolors.default.green(`removing old cache dir ${depsCacheDir}`)}`);
+	await fsp.rm(depsCacheDir, {
+		recursive: true,
+		force: true
+	});
+}
+/**
+* Initial optimizeDeps at server start. Perform a fast scan using esbuild to
+* find deps to pre-bundle and include user hard-coded dependencies
+*/
+function discoverProjectDependencies(environment) {
+	const { cancel, result } = scanImports(environment);
+	return {
+		cancel,
+		result: result.then(({ deps, missing }) => {
+			const missingIds = Object.keys(missing);
+			if (missingIds.length) throw new Error(`The following dependencies are imported but could not be resolved:\n\n  ${missingIds.map((id) => `${import_picocolors.default.cyan(id)} ${import_picocolors.default.white(import_picocolors.default.dim(`(imported by ${missing[id]})`))}`).join(`\n  `)}\n\nAre they installed?`);
+			return deps;
+		})
+	};
+}
+function toDiscoveredDependencies(environment, deps, timestamp) {
+	const browserHash = getOptimizedBrowserHash(getDepHash(environment).hash, deps, timestamp);
+	const discovered = {};
+	for (const id in deps) {
+		const src = deps[id];
+		discovered[id] = {
+			id,
+			file: getOptimizedDepPath(environment, id),
+			src,
+			browserHash,
+			exportsData: extractExportsData(environment, src)
+		};
+	}
+	return discovered;
+}
+function depsLogString(qualifiedIds) {
+	return import_picocolors.default.yellow(qualifiedIds.join(`, `));
+}
+/**
+* Internally, Vite uses this function to prepare a optimizeDeps run. When Vite starts, we can get
+* the metadata and start the server without waiting for the optimizeDeps processing to be completed
+*/
+function runOptimizeDeps(environment, depsInfo) {
+	const optimizerContext = { cancelled: false };
+	const depsCacheDir = getDepsCacheDir(environment);
+	const processingCacheDir = getProcessingDepsCacheDir(environment);
+	fs.mkdirSync(processingCacheDir, { recursive: true });
+	debug$2?.(import_picocolors.default.green(`creating package.json in ${processingCacheDir}`));
+	fs.writeFileSync(path.resolve(processingCacheDir, "package.json"), `{\n  "type": "module"\n}\n`);
+	const metadata = initDepsOptimizerMetadata(environment);
+	metadata.browserHash = getOptimizedBrowserHash(metadata.hash, depsFromOptimizedDepInfo(depsInfo));
+	const qualifiedIds = Object.keys(depsInfo);
+	let cleaned = false;
+	let committed = false;
+	const cleanUp = () => {
+		if (!cleaned && !committed) {
+			cleaned = true;
+			debug$2?.(import_picocolors.default.green(`removing cache dir ${processingCacheDir}`));
+			try {
+				fs.rmSync(processingCacheDir, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		}
+	};
+	const successfulResult = {
+		metadata,
+		cancel: cleanUp,
+		commit: async () => {
+			if (cleaned) throw new Error("Can not commit a Deps Optimization run as it was cancelled");
+			committed = true;
+			const dataPath = path.join(processingCacheDir, METADATA_FILENAME);
+			debug$2?.(import_picocolors.default.green(`creating ${METADATA_FILENAME} in ${processingCacheDir}`));
+			fs.writeFileSync(dataPath, stringifyDepsOptimizerMetadata(metadata, depsCacheDir));
+			const temporaryPath = depsCacheDir + getTempSuffix();
+			const depsCacheDirPresent = fs.existsSync(depsCacheDir);
+			if (isWindows) {
+				if (depsCacheDirPresent) {
+					debug$2?.(import_picocolors.default.green(`renaming ${depsCacheDir} to ${temporaryPath}`));
+					await safeRename(depsCacheDir, temporaryPath);
+				}
+				debug$2?.(import_picocolors.default.green(`renaming ${processingCacheDir} to ${depsCacheDir}`));
+				await safeRename(processingCacheDir, depsCacheDir);
+			} else {
+				if (depsCacheDirPresent) {
+					debug$2?.(import_picocolors.default.green(`renaming ${depsCacheDir} to ${temporaryPath}`));
+					fs.renameSync(depsCacheDir, temporaryPath);
+				}
+				debug$2?.(import_picocolors.default.green(`renaming ${processingCacheDir} to ${depsCacheDir}`));
+				fs.renameSync(processingCacheDir, depsCacheDir);
+			}
+			if (depsCacheDirPresent) {
+				debug$2?.(import_picocolors.default.green(`removing cache temp dir ${temporaryPath}`));
+				fsp.rm(temporaryPath, {
+					recursive: true,
+					force: true
+				});
+			}
+		}
+	};
+	if (!qualifiedIds.length) return {
+		cancel: async () => cleanUp(),
+		result: Promise.resolve(successfulResult)
+	};
+	const cancelledResult = {
+		metadata,
+		commit: async () => cleanUp(),
+		cancel: cleanUp
+	};
+	const start = performance$1.now();
+	const bundleTimer = setTimeout(() => {
+		environment.logger.info("[optimizer] bundling dependencies...", { timestamp: true });
+	}, 1e3);
+	const preparedRun = prepareRolldownOptimizerRun(environment, depsInfo, processingCacheDir, optimizerContext);
+	const runResult = preparedRun.then(({ context, idToExports }) => {
+		if (!context || optimizerContext.cancelled) {
+			clearTimeout(bundleTimer);
+			return cancelledResult;
+		}
+		return context.build().then((result) => {
+			const depForEntryFileName = {};
+			for (const dep of Object.values(depsInfo)) {
+				const entryFileName = flattenId(dep.id) + ".js";
+				depForEntryFileName[entryFileName] = dep;
+			}
+			for (const chunk of result.output) {
+				if (chunk.type !== "chunk") continue;
+				if (chunk.isEntry) {
+					const { exportsData, file, id, ...info } = depForEntryFileName[chunk.fileName];
+					addOptimizedDepInfo(metadata, "optimized", {
+						id,
+						file,
+						...info,
+						fileHash: getHash(metadata.hash + file + JSON.stringify(chunk.imports)),
+						browserHash: metadata.browserHash,
+						needsInterop: needsInterop(environment, id, idToExports[id], chunk)
+					});
+				} else {
+					const id = chunk.fileName.replace(jsExtensionRE, "");
+					const file = normalizePath(path.resolve(getDepsCacheDir(environment), chunk.fileName));
+					if (!findOptimizedDepInfoInRecord(metadata.optimized, (depInfo) => depInfo.file === file)) addOptimizedDepInfo(metadata, "chunks", {
+						id,
+						file,
+						needsInterop: false,
+						browserHash: metadata.browserHash,
+						isDynamicEntry: chunk.isDynamicEntry
+					});
+				}
+			}
+			clearTimeout(bundleTimer);
+			debug$2?.(`Dependencies bundled in ${(performance$1.now() - start).toFixed(2)}ms`);
+			return successfulResult;
+		}).catch((e) => {
+			clearTimeout(bundleTimer);
+			if (e.errors && e.message.includes("The build was canceled")) return cancelledResult;
+			e.message = import_picocolors.default.red("Error during dependency optimization:\n\n") + e.message;
+			throw e;
+		});
+	});
+	runResult.catch(() => {
+		cleanUp();
+	});
+	return {
+		async cancel() {
+			optimizerContext.cancelled = true;
+			const { context } = await preparedRun;
+			context?.cancel();
+			cleanUp();
+		},
+		result: runResult
+	};
+}
+async function prepareRolldownOptimizerRun(environment, depsInfo, processingCacheDir, optimizerContext) {
+	const flatIdDeps = {};
+	const idToExports = {};
+	const { optimizeDeps } = environment.config;
+	const { plugins: pluginsFromConfig = [], ...rolldownOptions } = optimizeDeps.rolldownOptions ?? {};
+	let jsxLoader = false;
+	await Promise.all(Object.keys(depsInfo).map(async (id) => {
+		const src = depsInfo[id].src;
+		const exportsData = await (depsInfo[id].exportsData ?? extractExportsData(environment, src));
+		if (exportsData.jsxLoader) jsxLoader = true;
+		const flatId = flattenId(id);
+		flatIdDeps[flatId] = isWindows ? src.replaceAll("/", "\\") : src;
+		idToExports[id] = exportsData;
+	}));
+	if (optimizerContext.cancelled) return {
+		context: void 0,
+		idToExports
+	};
+	const define = {
+		"process.env.NODE_ENV": environment.config.keepProcessEnv ? "process.env.NODE_ENV" : JSON.stringify(process.env.NODE_ENV || environment.config.mode),
+		...rolldownOptions.transform?.define
+	};
+	const platform = optimizeDeps.rolldownOptions?.platform ?? (environment.config.consumer === "client" || environment.config.ssr.target === "webworker" ? "browser" : "node");
+	const external = [...optimizeDeps.exclude ?? []];
+	const plugins = await asyncFlatten(arraify(pluginsFromConfig));
+	if (external.length) plugins.push(rolldownCjsExternalPlugin(external, platform));
+	plugins.push(...rolldownDepPlugin(environment, flatIdDeps, external));
+	let canceled = false;
+	async function build() {
+		const bundle = await rolldown({
+			...rolldownOptions,
+			input: flatIdDeps,
+			logLevel: "silent",
+			plugins,
+			platform,
+			transform: {
+				target: ESBUILD_BASELINE_WIDELY_AVAILABLE_TARGET,
+				...rolldownOptions.transform,
+				define
+			},
+			resolve: {
+				extensions: [
+					".tsx",
+					".ts",
+					".jsx",
+					".js",
+					".css",
+					".json"
+				],
+				...rolldownOptions.resolve
+			},
+			moduleTypes: {
+				".css": "js",
+				...rolldownOptions.moduleTypes,
+				...jsxLoader ? { ".js": "jsx" } : {}
+			}
+		});
+		if (canceled) {
+			await bundle.close();
+			throw new Error("The build was canceled");
+		}
+		const result = await bundle.write({
+			...rolldownOptions.output,
+			format: "esm",
+			sourcemap: true,
+			dir: processingCacheDir,
+			entryFileNames: "[name].js"
+		});
+		await bundle.close();
+		return result;
+	}
+	function cancel() {
+		canceled = true;
+	}
+	return {
+		context: {
+			build,
+			cancel
+		},
+		idToExports
+	};
+}
+async function addManuallyIncludedOptimizeDeps(environment, deps) {
+	const { logger } = environment;
+	const { optimizeDeps } = environment.config;
+	const optimizeDepsInclude = optimizeDeps.include ?? [];
+	if (optimizeDepsInclude.length) {
+		const unableToOptimize = (id, msg) => {
+			if (optimizeDepsInclude.includes(id)) logger.warn(`${msg}: ${import_picocolors.default.cyan(id)}, present in ${environment.name} 'optimizeDeps.include'`);
+		};
+		const includes = [...optimizeDepsInclude];
+		for (let i = 0; i < includes.length; i++) {
+			const id = includes[i];
+			if (isDynamicPattern(id)) {
+				const globIds = expandGlobIds(id, environment.getTopLevelConfig());
+				includes.splice(i, 1, ...globIds);
+				i += globIds.length - 1;
+			}
+		}
+		const resolve = createOptimizeDepsIncludeResolver(environment);
+		for (const id of includes) {
+			const normalizedId = normalizeId(id);
+			if (!deps[normalizedId]) {
+				const entry = await resolve(id);
+				if (entry) if (isOptimizable(entry, optimizeDeps)) deps[normalizedId] = entry;
+				else unableToOptimize(id, "Cannot optimize dependency");
+				else unableToOptimize(id, "Failed to resolve dependency");
+			}
+		}
+	}
+}
+function depsFromOptimizedDepInfo(depsInfo) {
+	const obj = {};
+	for (const key in depsInfo) obj[key] = depsInfo[key].src;
+	return obj;
+}
+function getOptimizedDepPath(environment, id) {
+	return normalizePath(path.resolve(getDepsCacheDir(environment), flattenId(id) + ".js"));
+}
+function getDepsCacheSuffix(environment) {
+	return environment.name === "client" ? "" : `_${environment.name}`;
+}
+function getDepsCacheDir(environment) {
+	return getDepsCacheDirPrefix(environment) + getDepsCacheSuffix(environment);
+}
+function getProcessingDepsCacheDir(environment) {
+	return getDepsCacheDirPrefix(environment) + getDepsCacheSuffix(environment) + getTempSuffix();
+}
+function getTempSuffix() {
+	return "_temp_" + getHash(`${process.pid}:${Date.now().toString()}:${Math.random().toString(16).slice(2)}`);
+}
+function getDepsCacheDirPrefix(environment) {
+	return normalizePath(path.resolve(environment.config.cacheDir, "deps"));
+}
+function createIsOptimizedDepFile(environment) {
+	const depsCacheDirPrefix = getDepsCacheDirPrefix(environment);
+	return (id) => id.startsWith(depsCacheDirPrefix);
+}
+function createIsOptimizedDepUrl(environment) {
+	const { root } = environment.config;
+	const depsCacheDir = getDepsCacheDirPrefix(environment);
+	const depsCacheDirRelative = normalizePath(path.relative(root, depsCacheDir));
+	const depsCacheDirPrefix = depsCacheDirRelative.startsWith("../") ? `/@fs/${removeLeadingSlash(normalizePath(depsCacheDir))}` : `/${depsCacheDirRelative}`;
+	return function isOptimizedDepUrl(url) {
+		return url.startsWith(depsCacheDirPrefix);
+	};
+}
+function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
+	const { hash, lockfileHash, configHash, browserHash, optimized, chunks } = JSON.parse(jsonMetadata, (key, value) => {
+		if (key === "file" || key === "src") return normalizePath(path.resolve(depsCacheDir, value));
+		return value;
+	});
+	if (!chunks || Object.values(optimized).some((depInfo) => !depInfo.fileHash)) return;
+	const metadata = {
+		hash,
+		lockfileHash,
+		configHash,
+		browserHash,
+		optimized: {},
+		discovered: {},
+		chunks: {},
+		depInfoList: []
+	};
+	for (const id of Object.keys(optimized)) addOptimizedDepInfo(metadata, "optimized", {
+		...optimized[id],
+		id,
+		browserHash
+	});
+	for (const id of Object.keys(chunks)) addOptimizedDepInfo(metadata, "chunks", {
+		...chunks[id],
+		id,
+		browserHash,
+		needsInterop: false
+	});
+	return metadata;
+}
+/**
+* Stringify metadata for deps cache. Remove processing promises
+* and individual dep info browserHash. Once the cache is reload
+* the next time the server start we need to use the global
+* browserHash to allow long term caching
+*/
+function stringifyDepsOptimizerMetadata(metadata, depsCacheDir) {
+	const { hash, configHash, lockfileHash, browserHash, optimized, chunks } = metadata;
+	return JSON.stringify({
+		hash,
+		configHash,
+		lockfileHash,
+		browserHash,
+		optimized: Object.fromEntries(Object.values(optimized).map(({ id, src, file, fileHash, needsInterop, isDynamicEntry }) => [id, {
+			src,
+			file,
+			fileHash,
+			needsInterop,
+			isDynamicEntry
+		}])),
+		chunks: Object.fromEntries(Object.values(chunks).map(({ id, file, isDynamicEntry }) => [id, {
+			file,
+			isDynamicEntry
+		}]))
+	}, (key, value) => {
+		if (key === "file" || key === "src") return normalizePath(path.relative(depsCacheDir, value));
+		return value;
+	}, 2);
+}
+async function extractExportsData(environment, filePath) {
+	await init;
+	const { optimizeDeps } = environment.config;
+	const rolldownOptions = optimizeDeps.rolldownOptions ?? {};
+	if (optimizeDeps.extensions?.some((ext) => filePath.endsWith(ext))) {
+		const { plugins: pluginsFromConfig = [], ...remainingRolldownOptions } = rolldownOptions;
+		const plugins = await asyncFlatten(arraify(pluginsFromConfig));
+		plugins.unshift({
+			name: "externalize",
+			resolveId(id, importer) {
+				if (importer !== void 0) return {
+					id,
+					external: true
+				};
+			}
+		});
+		const [, exports, , hasModuleSyntax] = parse$2((await (await rolldown({
+			...remainingRolldownOptions,
+			plugins,
+			input: [filePath],
+			moduleTypes: {
+				".css": "js",
+				...remainingRolldownOptions.moduleTypes
+			}
+		})).generate({
+			...rolldownOptions.output,
+			format: "esm",
+			sourcemap: false
+		})).output[0].code);
+		return {
+			hasModuleSyntax,
+			exports: exports.map((e) => e.n)
+		};
+	}
+	let parseResult;
+	let usedJsxLoader = false;
+	const entryContent = fs.readFileSync(filePath, "utf-8");
+	try {
+		parseResult = parse$2(entryContent);
+	} catch {
+		const lang = rolldownOptions.moduleTypes?.[path.extname(filePath)] || "jsx";
+		debug$2?.(`Unable to parse: ${filePath}.\n Trying again with a ${lang} transform.`);
+		if (lang !== "jsx" && lang !== "tsx" && lang !== "ts") throw new Error(`Unable to parse : ${filePath}.`);
+		parseResult = parse$2((await transformWithOxc(entryContent, filePath, { lang }, void 0, environment.config)).code);
+		usedJsxLoader = true;
+	}
+	const [, exports, , hasModuleSyntax] = parseResult;
+	return {
+		hasModuleSyntax,
+		exports: exports.map((e) => e.n),
+		jsxLoader: usedJsxLoader
+	};
+}
+function needsInterop(environment, id, exportsData, output) {
+	if (environment.config.optimizeDeps.needsInterop?.includes(id)) return true;
+	const { hasModuleSyntax, exports } = exportsData;
+	if (!hasModuleSyntax) return true;
+	if (output) {
+		const generatedExports = output.exports;
+		if (isSingleDefaultExport(generatedExports) && !isSingleDefaultExport(exports)) return true;
+	}
+	return false;
+}
+function isSingleDefaultExport(exports) {
+	return exports.length === 1 && exports[0] === "default";
+}
+const lockfileFormats = [
+	{
+		path: "node_modules/.package-lock.json",
+		checkPatchesDir: "patches",
+		manager: "npm"
+	},
+	{
+		path: "node_modules/.yarn-state.yml",
+		checkPatchesDir: false,
+		manager: "yarn"
+	},
+	{
+		path: ".pnp.cjs",
+		checkPatchesDir: ".yarn/patches",
+		manager: "yarn"
+	},
+	{
+		path: ".pnp.js",
+		checkPatchesDir: ".yarn/patches",
+		manager: "yarn"
+	},
+	{
+		path: "node_modules/.yarn-integrity",
+		checkPatchesDir: "patches",
+		manager: "yarn"
+	},
+	{
+		path: "node_modules/.pnpm/lock.yaml",
+		checkPatchesDir: false,
+		manager: "pnpm"
+	},
+	{
+		path: ".rush/temp/shrinkwrap-deps.json",
+		checkPatchesDir: false,
+		manager: "pnpm"
+	},
+	{
+		path: "bun.lock",
+		checkPatchesDir: "patches",
+		manager: "bun"
+	},
+	{
+		path: "bun.lockb",
+		checkPatchesDir: "patches",
+		manager: "bun"
+	}
+].sort((_, { manager }) => {
+	return process.env.npm_config_user_agent?.startsWith(manager) ? 1 : -1;
+});
+const lockfilePaths = lockfileFormats.map((l) => l.path);
+function getConfigHash(environment) {
+	const { config } = environment;
+	const { optimizeDeps } = config;
+	return getHash(JSON.stringify({
+		define: !config.keepProcessEnv ? process.env.NODE_ENV || config.mode : null,
+		root: config.root,
+		resolve: config.resolve,
+		assetsInclude: config.assetsInclude,
+		plugins: config.plugins.map((p) => p.name),
+		optimizeDeps: {
+			include: optimizeDeps.include ? unique(optimizeDeps.include).sort() : void 0,
+			exclude: optimizeDeps.exclude ? unique(optimizeDeps.exclude).sort() : void 0,
+			rolldownOptions: {
+				...optimizeDeps.rolldownOptions,
+				plugins: void 0,
+				onLog: void 0,
+				onwarn: void 0,
+				checks: void 0,
+				output: {
+					...optimizeDeps.rolldownOptions?.output,
+					plugins: void 0
+				}
+			}
+		},
+		optimizeDepsPluginNames: config.optimizeDepsPluginNames
+	}, (_, value) => {
+		if (typeof value === "function" || value instanceof RegExp) return value.toString();
+		return value;
+	}));
+}
+function getLockfileHash(environment) {
+	const lockfilePath = lookupFile(environment.config.root, lockfilePaths);
+	let content = lockfilePath ? fs.readFileSync(lockfilePath, "utf-8") : "";
+	if (lockfilePath) {
+		const normalizedLockfilePath = lockfilePath.replaceAll("\\", "/");
+		const lockfileFormat = lockfileFormats.find((f) => normalizedLockfilePath.endsWith(f.path));
+		if (lockfileFormat.checkPatchesDir) {
+			const baseDir = lockfilePath.slice(0, -lockfileFormat.path.length);
+			const stat = tryStatSync(path.join(baseDir, lockfileFormat.checkPatchesDir));
+			if (stat?.isDirectory()) content += stat.mtimeMs.toString();
+		}
+	}
+	return getHash(content);
+}
+function getDepHash(environment) {
+	const lockfileHash = getLockfileHash(environment);
+	const configHash = getConfigHash(environment);
+	return {
+		hash: getHash(lockfileHash + configHash),
+		lockfileHash,
+		configHash
+	};
+}
+function getOptimizedBrowserHash(hash, deps, timestamp = "") {
+	return getHash(hash + JSON.stringify(deps) + timestamp);
+}
+function optimizedDepInfoFromId(metadata, id) {
+	return metadata.optimized[id] || metadata.discovered[id] || metadata.chunks[id];
+}
+function optimizedDepInfoFromFile(metadata, file) {
+	return metadata.depInfoList.find((depInfo) => depInfo.file === file);
+}
+function findOptimizedDepInfoInRecord(dependenciesInfo, callbackFn) {
+	for (const o of Object.keys(dependenciesInfo)) {
+		const info = dependenciesInfo[o];
+		if (callbackFn(info, o)) return info;
+	}
+}
+async function optimizedDepNeedsInterop(environment, metadata, file) {
+	const depInfo = optimizedDepInfoFromFile(metadata, file);
+	if (depInfo?.src && depInfo.needsInterop === void 0) {
+		depInfo.exportsData ??= extractExportsData(environment, depInfo.src);
+		depInfo.needsInterop = needsInterop(environment, depInfo.id, await depInfo.exportsData);
+	}
+	return depInfo?.needsInterop;
+}
+const MAX_TEMP_DIR_AGE_MS = 1440 * 60 * 1e3;
+async function cleanupDepsCacheStaleDirs(config) {
+	try {
+		const cacheDir = path.resolve(config.cacheDir);
+		if (fs.existsSync(cacheDir)) {
+			const dirents = await fsp.readdir(cacheDir, { withFileTypes: true });
+			for (const dirent of dirents) if (dirent.isDirectory() && dirent.name.includes("_temp_")) {
+				const tempDirPath = path.resolve(config.cacheDir, dirent.name);
+				const stats = await fsp.stat(tempDirPath).catch(() => null);
+				if (stats?.mtime && Date.now() - stats.mtime.getTime() > MAX_TEMP_DIR_AGE_MS) {
+					debug$2?.(`removing stale cache temp dir ${tempDirPath}`);
+					await fsp.rm(tempDirPath, {
+						recursive: true,
+						force: true
+					});
+				}
+			}
+		}
+	} catch (err) {
+		config.logger.error(err);
+	}
+}
+const GRACEFUL_RENAME_TIMEOUT = 5e3;
+const safeRename = promisify(function gracefulRename(from, to, cb) {
+	const start = Date.now();
+	let backoff = 0;
+	fs.rename(from, to, function CB(er) {
+		if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < GRACEFUL_RENAME_TIMEOUT) {
+			setTimeout(function() {
+				fs.stat(to, function(stater, _st) {
+					if (stater && stater.code === "ENOENT") fs.rename(from, to, CB);
+					else CB(er);
+				});
+			}, backoff);
+			if (backoff < 100) backoff += 10;
+			return;
+		}
+		cb(er);
+	});
+});
+//#endregion
+//#region src/node/plugins/resolve.ts
+const normalizedClientEntry = normalizePath(CLIENT_ENTRY);
+const normalizedEnvEntry = normalizePath(ENV_ENTRY);
+const ERR_RESOLVE_PACKAGE_ENTRY_FAIL = "ERR_RESOLVE_PACKAGE_ENTRY_FAIL";
+const browserExternalId = "__vite-browser-external";
+const optionalPeerDepId = "__vite-optional-peer-dep";
+const subpathImportsPrefix = "#";
+const relativePrefixRE = /^\.\.?(?:[/\\]|$)/;
+const startsWithWordCharRE = /^\w/;
+const debug$1 = createDebugger("vite:resolve-details", { onlyWhenFocused: true });
+const perEnvironmentOrWorkerPlugin = (name, overrideEnvConfig, f) => {
+	const envs = {};
+	const getEnvironmentPlugin = {
+		name: `${name}:get-environment`,
+		buildStart() {
+			envs[this.environment.name] = this.environment;
+		},
+		perEnvironmentStartEndDuringDev: true
+	};
+	const createGetEnvironment = (name) => () => envs[name];
+	if (overrideEnvConfig) return [getEnvironmentPlugin, f({
+		name: "client",
+		config: overrideEnvConfig
+	}, createGetEnvironment("client"))];
+	return [getEnvironmentPlugin, {
+		name,
+		applyToEnvironment(environment) {
+			return f(environment, createGetEnvironment(environment.name));
+		}
+	}];
+};
+function oxcResolvePlugin(resolveOptions, overrideEnvConfig) {
+	return [...resolveOptions.optimizeDeps && !resolveOptions.isBuild ? [optimizerResolvePlugin(resolveOptions)] : [], ...perEnvironmentOrWorkerPlugin("vite:resolve-builtin", overrideEnvConfig, (partialEnv, getEnv) => {
+		const depsOptimizerEnabled = resolveOptions.optimizeDeps && !resolveOptions.isBuild && !partialEnv.config.isBundled && !isDepOptimizationDisabled(partialEnv.config.optimizeDeps);
+		const getDepsOptimizer = () => {
+			const env = getEnv();
+			if (env.mode !== "dev") throw new Error("The environment mode should be dev");
+			if (!env.depsOptimizer) throw new Error("The environment should have a depsOptimizer");
+			return env.depsOptimizer;
+		};
+		const options = {
+			...partialEnv.config.resolve,
+			...resolveOptions
+		};
+		const noExternal = Array.isArray(options.noExternal) || options.noExternal === true ? options.noExternal : [options.noExternal];
+		const plugin = viteResolvePlugin({
+			resolveOptions: {
+				isBuild: options.isBuild,
+				isProduction: options.isProduction,
+				asSrc: options.asSrc ?? false,
+				preferRelative: options.preferRelative ?? false,
+				isRequire: options.isRequire,
+				root: options.root,
+				scan: options.scan ?? false,
+				mainFields: options.skipMainField ? options.mainFields : options.mainFields.concat(["main"]),
+				conditions: options.conditions,
+				externalConditions: options.externalConditions,
+				extensions: options.extensions,
+				tryIndex: options.tryIndex ?? true,
+				tryPrefix: options.tryPrefix,
+				preserveSymlinks: options.preserveSymlinks,
+				tsconfigPaths: options.tsconfigPaths
+			},
+			environmentConsumer: partialEnv.config.consumer,
+			environmentName: partialEnv.name,
+			builtins: partialEnv.config.resolve.builtins,
+			external: options.external,
+			noExternal,
+			dedupe: options.dedupe,
+			disableCache: partialEnv.config.command === "serve" && partialEnv.config.server.watch === null,
+			legacyInconsistentCjsInterop: options.legacyInconsistentCjsInterop,
+			finalizeBareSpecifier: !depsOptimizerEnabled ? void 0 : (resolvedId, rawId, importer) => {
+				const depsOptimizer = getDepsOptimizer();
+				const isJsType = isOptimizable(resolvedId, depsOptimizer.options);
+				const exclude = depsOptimizer?.options.exclude;
+				const deepMatch = deepImportRE.exec(rawId);
+				const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : cleanUrl(rawId);
+				const skipOptimization = depsOptimizer.options.noDiscovery || !isJsType || importer && isInNodeModules(importer) || exclude?.includes(pkgId) || exclude?.includes(rawId) || SPECIAL_QUERY_RE.test(resolvedId);
+				let newId = resolvedId;
+				if (skipOptimization) {
+					const versionHash = depsOptimizer.metadata.browserHash;
+					if (versionHash && isJsType) newId = injectQuery(newId, `v=${versionHash}`);
+				} else {
+					const optimizedInfo = depsOptimizer.registerMissingImport(rawId, newId);
+					newId = depsOptimizer.getOptimizedDepId(optimizedInfo);
+				}
+				return newId;
+			},
+			finalizeOtherSpecifiers: !depsOptimizerEnabled ? void 0 : (resolvedId, rawId) => {
+				const newResolvedId = ensureVersionQuery(resolvedId, rawId, options, getDepsOptimizer());
+				return newResolvedId === resolvedId ? void 0 : newResolvedId;
+			},
+			resolveSubpathImports(id, importer, isRequire, scan) {
+				return resolveSubpathImports(id, importer, {
+					...options,
+					isRequire: resolveOptions.isRequire ?? isRequire,
+					scan
+				});
+			},
+			...partialEnv.config.command === "serve" ? { async onWarn(msg) {
+				getEnv().logger.warn(`warning: ${msg}`, {
+					clear: true,
+					timestamp: true
+				});
+			} } : {},
+			...debug$1 ? { async onDebug(message) {
+				debug$1(message);
+			} } : {}
+		});
+		plugin.perEnvironmentWatchChangeDuringDev = true;
+		return plugin;
+	})];
+}
+function optimizerResolvePlugin(resolveOptions) {
+	const { root, asSrc } = resolveOptions;
+	return {
+		name: "vite:resolve-dev",
+		applyToEnvironment(environment) {
+			return !environment.config.isBundled && !isDepOptimizationDisabled(environment.config.optimizeDeps);
+		},
+		resolveId: {
+			filter: { id: { exclude: [
+				/^\0/,
+				/^virtual:/,
+				/^\/virtual:/,
+				/^__vite-/
+			] } },
+			async handler(id, importer, resolveOpts) {
+				const depsOptimizer = resolveOptions.optimizeDeps && this.environment.mode === "dev" ? this.environment.depsOptimizer : void 0;
+				if (!depsOptimizer) return;
+				const options = {
+					isRequire: resolveOpts.kind === "require-call",
+					...this.environment.config.resolve,
+					...resolveOptions,
+					scan: resolveOpts.scan ?? resolveOptions.scan
+				};
+				options.preferRelative ||= importer?.endsWith(".html");
+				if (asSrc && depsOptimizer.isOptimizedDepUrl(id)) return id.startsWith(FS_PREFIX) ? fsPathFromId(id) : normalizePath(path.resolve(root, id.slice(1)));
+				if (!isDataUrl(id) && !isExternalUrl(id)) {
+					if (id[0] === "." || options.preferRelative && startsWithWordCharRE.test(id)) {
+						const basedir = importer ? path.dirname(importer) : root;
+						const normalizedFsPath = normalizePath(path.resolve(basedir, id));
+						if (depsOptimizer.isOptimizedDepFile(normalizedFsPath)) {
+							if (!DEP_VERSION_RE.test(normalizedFsPath)) {
+								const browserHash = optimizedDepInfoFromFile(depsOptimizer.metadata, normalizedFsPath)?.browserHash;
+								if (browserHash) return injectQuery(normalizedFsPath, `v=${browserHash}`);
+							}
+							return normalizedFsPath;
+						}
+					}
+					if (bareImportRE.test(id)) {
+						let res;
+						if (asSrc && !options.scan && (res = await tryOptimizedResolve(depsOptimizer, id, importer, options.preserveSymlinks, options.packageCache))) return res;
+					}
+				}
+			}
+		}
+	};
+}
+function resolveSubpathImports(id, importer, options) {
+	if (!importer || !id.startsWith(subpathImportsPrefix)) return;
+	const basedir = path.dirname(importer);
+	const pkgData = findNearestPackageData(basedir, options.packageCache);
+	if (!pkgData) return;
+	let { file: idWithoutPostfix, postfix } = splitFileAndPostfix(id.slice(1));
+	idWithoutPostfix = "#" + idWithoutPostfix;
+	let importsPath = resolveExportsOrImports(pkgData.data, idWithoutPostfix, options, "imports");
+	if (importsPath?.[0] === ".") {
+		importsPath = path.relative(basedir, path.join(pkgData.dir, importsPath));
+		if (!relativePrefixRE.test(importsPath)) importsPath = `./${importsPath}`;
+	}
+	if (importsPath == null) return;
+	return importsPath + postfix;
+}
+function ensureVersionQuery(resolved, id, options, depsOptimizer) {
+	if (!options.isBuild && !options.scan && depsOptimizer && !(resolved === normalizedClientEntry || resolved === normalizedEnvEntry)) {
+		if ((isInNodeModules(id) || isInNodeModules(resolved)) && !DEP_VERSION_RE.test(resolved)) {
+			const versionHash = depsOptimizer.metadata.browserHash;
+			if (versionHash && isOptimizable(resolved, depsOptimizer.options)) resolved = injectQuery(resolved, `v=${versionHash}`);
+		}
+	}
+	return resolved;
+}
+function tryFsResolve(fsPath, options, tryIndex = true, skipPackageJson = false) {
+	const hashIndex = fsPath.indexOf("#");
+	if (hashIndex >= 0 && isInNodeModules(fsPath)) {
+		const queryIndex = fsPath.indexOf("?");
+		if (queryIndex < 0 || queryIndex > hashIndex) {
+			const file = queryIndex > hashIndex ? fsPath.slice(0, queryIndex) : fsPath;
+			const res = tryCleanFsResolve(file, options, tryIndex, skipPackageJson);
+			if (res) return res + fsPath.slice(file.length);
+		}
+	}
+	const { file, postfix } = splitFileAndPostfix(fsPath);
+	const res = tryCleanFsResolve(file, options, tryIndex, skipPackageJson);
+	if (res) return res + postfix;
+}
+const knownTsOutputRE = /\.(?:js|mjs|cjs|jsx)$/;
+const isPossibleTsOutput = (url) => knownTsOutputRE.test(url);
+function tryCleanFsResolve(file, options, tryIndex = true, skipPackageJson = false) {
+	const { tryPrefix, extensions, preserveSymlinks } = options;
+	const fileResult = tryResolveRealFileOrType(file, options.preserveSymlinks);
+	if (fileResult?.path) return fileResult.path;
+	let res;
+	const possibleJsToTs = isPossibleTsOutput(file);
+	if (possibleJsToTs || options.extensions.length || tryPrefix) {
+		const dirPath = path.dirname(file);
+		if (isDirectory(dirPath)) {
+			if (possibleJsToTs) {
+				const fileExt = path.extname(file);
+				const fileName = file.slice(0, -fileExt.length);
+				if (res = tryResolveRealFile(fileName + fileExt.replace("js", "ts"), preserveSymlinks)) return res;
+				if (fileExt === ".js" && (res = tryResolveRealFile(fileName + ".tsx", preserveSymlinks))) return res;
+			}
+			if (res = tryResolveRealFileWithExtensions(file, extensions, preserveSymlinks)) return res;
+			if (tryPrefix) {
+				const prefixed = `${dirPath}/${options.tryPrefix}${path.basename(file)}`;
+				if (res = tryResolveRealFile(prefixed, preserveSymlinks)) return res;
+				if (res = tryResolveRealFileWithExtensions(prefixed, extensions, preserveSymlinks)) return res;
+			}
+		}
+	}
+	if (tryIndex && fileResult?.type === "directory") {
+		const dirPath = file;
+		if (!skipPackageJson) {
+			let pkgPath = `${dirPath}/package.json`;
+			try {
+				if (fs.existsSync(pkgPath)) {
+					if (!options.preserveSymlinks) pkgPath = safeRealpathSync(pkgPath);
+					return resolvePackageEntry(dirPath, loadPackageData(pkgPath), options);
+				}
+			} catch (e) {
+				if (e.code !== ERR_RESOLVE_PACKAGE_ENTRY_FAIL && e.code !== "ENOENT") throw e;
+			}
+		}
+		if (res = tryResolveRealFileWithExtensions(`${dirPath}/index`, extensions, preserveSymlinks)) return res;
+		if (tryPrefix) {
+			if (res = tryResolveRealFileWithExtensions(`${dirPath}/${options.tryPrefix}index`, extensions, preserveSymlinks)) return res;
+		}
+	}
+}
+function tryNodeResolve(id, importer, options, depsOptimizer, externalize) {
+	const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
+	const deepMatch = deepImportRE.exec(id);
+	const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : cleanUrl(id);
+	let basedir;
+	if (dedupe.includes(pkgId)) basedir = root;
+	else if (importer && path.isAbsolute(importer) && (importer.endsWith("*") || fs.existsSync(cleanUrl(importer)))) basedir = path.dirname(importer);
+	else basedir = root;
+	const isModuleBuiltin = (id) => isBuiltin(options.builtins, id);
+	let selfPkg = null;
+	if (!isModuleBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
+		const selfPackageData = findNearestPackageData(basedir, packageCache);
+		selfPkg = selfPackageData?.data.exports && selfPackageData.data.name === pkgId ? selfPackageData : null;
+	}
+	const pkg = selfPkg || resolvePackageData(pkgId, basedir, preserveSymlinks, packageCache);
+	if (!pkg) {
+		if (!options.disableOptionalPeerDepHandling && basedir !== root && !isModuleBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
+			const mainPkg = findNearestMainPackageData(basedir, packageCache)?.data;
+			if (mainPkg) {
+				const pkgName = getNpmPackageName(id);
+				if (pkgName != null && mainPkg.peerDependencies?.[pkgName] && mainPkg.peerDependenciesMeta?.[pkgName]?.optional) return { id: `${optionalPeerDepId}:${id}:${mainPkg.name}` };
+			}
+		}
+		return;
+	}
+	let resolved = (deepMatch ? resolveDeepImport : resolvePackageEntry)(deepMatch ? "." + id.slice(pkgId.length) : id, pkg, options, externalize);
+	if (!resolved) return;
+	const processResult = (resolved) => {
+		if (!externalize) return resolved;
+		if (!canExternalizeFile(resolved.id)) return resolved;
+		let resolvedId = id;
+		if (deepMatch && !pkg.data.exports && path.extname(id) !== path.extname(resolved.id)) {
+			const index = resolved.id.indexOf(id);
+			if (index > -1) {
+				resolvedId = resolved.id.slice(index);
+				debug$1?.(`[processResult] ${import_picocolors.default.cyan(id)} -> ${import_picocolors.default.dim(resolvedId)}`);
+			}
+		}
+		return {
+			...resolved,
+			id: resolvedId,
+			external: true
+		};
+	};
+	if (!options.idOnly && (!options.scan && isBuild || externalize)) return processResult({
+		id: resolved,
+		moduleSideEffects: pkg.hasSideEffects(resolved),
+		packageJsonPath: findNearestPackagePath(resolved, options.legacyInconsistentCjsInterop, options.packageCache, isBuild)
+	});
+	if (!isInNodeModules(resolved) || !depsOptimizer || options.scan) return { id: resolved };
+	const isJsType = isOptimizable(resolved, depsOptimizer.options);
+	const exclude = depsOptimizer.options.exclude;
+	if (depsOptimizer.options.noDiscovery || !isJsType || importer && isInNodeModules(importer) || exclude?.includes(pkgId) || exclude?.includes(id) || SPECIAL_QUERY_RE.test(resolved)) {
+		const versionHash = depsOptimizer.metadata.browserHash;
+		if (versionHash && isJsType) resolved = injectQuery(resolved, `v=${versionHash}`);
+	} else {
+		const optimizedInfo = depsOptimizer.registerMissingImport(id, resolved);
+		resolved = depsOptimizer.getOptimizedDepId(optimizedInfo);
+	}
+	return { id: resolved };
+}
+async function tryOptimizedResolve(depsOptimizer, id, importer, preserveSymlinks, packageCache) {
+	await depsOptimizer.scanProcessing;
+	const metadata = depsOptimizer.metadata;
+	const depInfo = optimizedDepInfoFromId(metadata, id);
+	if (depInfo) return depsOptimizer.getOptimizedDepId(depInfo);
+	if (!importer) return;
+	let idPkgDir;
+	const nestedIdMatch = `> ${id}`;
+	for (const optimizedData of metadata.depInfoList) {
+		if (!optimizedData.src) continue;
+		if (!optimizedData.id.endsWith(nestedIdMatch)) continue;
+		if (idPkgDir == null) {
+			const pkgName = getNpmPackageName(id);
+			if (!pkgName) break;
+			idPkgDir = resolvePackageData(pkgName, importer, preserveSymlinks, packageCache)?.dir;
+			if (idPkgDir == null) break;
+			idPkgDir = normalizePath(idPkgDir);
+		}
+		if (optimizedData.src.startsWith(withTrailingSlash(idPkgDir))) return depsOptimizer.getOptimizedDepId(optimizedData);
+	}
+}
+function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache }, options, externalize) {
+	const { file: idWithoutPostfix, postfix } = splitFileAndPostfix(id);
+	const cached = getResolvedCache(".", options);
+	if (cached) return cached + postfix;
+	try {
+		let entryPoint;
+		if (data.exports) entryPoint = resolveExportsOrImports(data, ".", options, "exports", externalize);
+		if (!entryPoint) {
+			for (const field of options.mainFields) if (typeof data[field] === "string") {
+				entryPoint = data[field];
+				break;
+			} else if (field === "browser") {
+				const browser = data[field];
+				if (isObject$1(browser) && browser["."]) {
+					entryPoint = browser["."];
+					break;
+				}
+			}
+		}
+		entryPoint ||= data.main;
+		const entryPoints = entryPoint ? [entryPoint] : [
+			"index.js",
+			"index.json",
+			"index.node"
+		];
+		for (let entry of entryPoints) {
+			let skipPackageJson = false;
+			if (options.mainFields[0] === "sass" && !options.extensions.includes(path.extname(entry))) {
+				entry = "";
+				skipPackageJson = true;
+			} else {
+				const { browser: browserField } = data;
+				if (options.mainFields.includes("browser") && isObject$1(browserField)) entry = mapWithBrowserField(entry, browserField) || entry;
+			}
+			const resolvedEntryPoint = tryFsResolve(path.join(dir, entry), options, true, skipPackageJson);
+			if (resolvedEntryPoint) {
+				debug$1?.(`[package entry] ${import_picocolors.default.cyan(idWithoutPostfix)} -> ${import_picocolors.default.dim(resolvedEntryPoint)}${postfix !== "" ? ` (postfix: ${postfix})` : ""}`);
+				setResolvedCache(".", resolvedEntryPoint, options);
+				return resolvedEntryPoint + postfix;
+			}
+		}
+	} catch (e) {
+		packageEntryFailure(id, e.message);
+	}
+	packageEntryFailure(id);
+}
+function packageEntryFailure(id, details) {
+	const err = /* @__PURE__ */ new Error(`Failed to resolve entry for package "${id}". The package may have incorrect main/module/exports specified in its package.json` + (details ? ": " + details : "."));
+	err.code = ERR_RESOLVE_PACKAGE_ENTRY_FAIL;
+	throw err;
+}
+function getConditions(conditions, isProduction, isRequire) {
+	const resolvedConditions = conditions.map((condition) => {
+		if (condition === DEV_PROD_CONDITION) return isProduction ? "production" : "development";
+		return condition;
+	});
+	if (isRequire) resolvedConditions.push("require");
+	else resolvedConditions.push("import");
+	return resolvedConditions;
+}
+function resolveExportsOrImports(pkg, key, options, type, externalize) {
+	const conditions = getConditions(externalize ? options.externalConditions : options.conditions, options.isProduction, options.isRequire);
+	const result = (type === "imports" ? f : o)(pkg, key, {
+		conditions,
+		unsafe: true
+	});
+	return result ? result[0] : void 0;
+}
+function resolveDeepImport(id, { setResolvedCache, getResolvedCache, dir, data }, options, externalize) {
+	const cache = getResolvedCache(id, options);
+	if (cache) return cache;
+	let relativeId = id;
+	const { exports: exportsField, browser: browserField } = data;
+	if (exportsField) {
+		if (isObject$1(exportsField) && !Array.isArray(exportsField)) {
+			const { file, postfix } = splitFileAndPostfix(relativeId);
+			const exportsId = resolveExportsOrImports(data, file, options, "exports", externalize);
+			if (exportsId !== void 0) relativeId = exportsId + postfix;
+			else relativeId = void 0;
+		} else relativeId = void 0;
+		if (!relativeId) throw new Error(`Package subpath '${relativeId}' is not defined by "exports" in ${path.join(dir, "package.json")}.`);
+	} else if (options.mainFields.includes("browser") && isObject$1(browserField)) {
+		const { file, postfix } = splitFileAndPostfix(relativeId);
+		const mapped = mapWithBrowserField(file, browserField);
+		if (mapped) relativeId = mapped + postfix;
+		else if (mapped === false) {
+			setResolvedCache(id, browserExternalId, options);
+			return browserExternalId;
+		}
+	}
+	if (relativeId) {
+		const resolved = tryFsResolve(path.join(dir, relativeId), options, !exportsField);
+		if (resolved) {
+			debug$1?.(`[node/deep-import] ${import_picocolors.default.cyan(id)} -> ${import_picocolors.default.dim(resolved)}`);
+			setResolvedCache(id, resolved, options);
+			return resolved;
+		}
+	}
+}
+/**
+* given a relative path in pkg dir,
+* return a relative path in pkg dir,
+* mapped with the "map" object
+*
+* - Returning `undefined` means there is no browser mapping for this id
+* - Returning `false` means this id is explicitly externalized for browser
+*/
+function mapWithBrowserField(relativePathInPkgDir, map) {
+	const normalizedPath = path.posix.normalize(relativePathInPkgDir);
+	for (const key in map) {
+		const normalizedKey = path.posix.normalize(key);
+		if (normalizedPath === normalizedKey || equalWithoutSuffix(normalizedPath, normalizedKey, ".js") || equalWithoutSuffix(normalizedPath, normalizedKey, "/index.js")) return map[key];
+	}
+}
+function equalWithoutSuffix(path, key, suffix) {
+	return key.endsWith(suffix) && key.slice(0, -suffix.length) === path;
+}
+function tryResolveRealFile(file, preserveSymlinks) {
+	if (tryStatSync(file)?.isFile()) return getRealPath(file, preserveSymlinks);
+}
+function tryResolveRealFileWithExtensions(filePath, extensions, preserveSymlinks) {
+	for (const ext of extensions) {
+		const res = tryResolveRealFile(filePath + ext, preserveSymlinks);
+		if (res) return res;
+	}
+}
+function tryResolveRealFileOrType(file, preserveSymlinks) {
+	const fileStat = tryStatSync(file);
+	if (fileStat?.isFile()) return {
+		path: getRealPath(file, preserveSymlinks),
+		type: "file"
+	};
+	if (fileStat?.isDirectory()) return { type: "directory" };
+}
+function getRealPath(resolved, preserveSymlinks) {
+	if (!preserveSymlinks) resolved = safeRealpathSync(resolved);
+	return normalizePath(resolved);
+}
+function isDirectory(path) {
+	return tryStatSync(path)?.isDirectory() ?? false;
+}
+function findNearestPackagePath(file, legacyInconsistentCjsInterop, packageCache, isBuild) {
+	if (!isBuild || legacyInconsistentCjsInterop) return;
+	const pkgData = findNearestPackageData(file, packageCache);
+	return pkgData ? path.join(pkgData.dir, "package.json") : null;
+}
+//#endregion
+//#region src/node/nodeResolve.ts
+/**
+* Resolve like Node.js using Vite's resolution algorithm with preconfigured options.
+*/
+function nodeResolveWithVite(id, importer, options) {
+	return tryNodeResolve(id, importer, {
+		root: options.root,
+		isBuild: true,
+		isProduction: true,
+		preferRelative: false,
+		tryIndex: true,
+		mainFields: [],
+		conditions: ["node", ...isModuleSyncConditionEnabled ? ["module-sync"] : []],
+		externalConditions: [],
+		external: [],
+		noExternal: [],
+		dedupe: [],
+		extensions: DEFAULT_EXTENSIONS,
+		preserveSymlinks: false,
+		tsconfigPaths: false,
+		packageCache: void 0,
+		isRequire: options.isRequire,
+		builtins: nodeLikeBuiltins,
+		disableOptionalPeerDepHandling: true
+	})?.id;
+}
+//#endregion
+//#region src/node/plugins/terser.ts
+let terserPath;
+function loadTerserPath(root) {
+	if (terserPath) return terserPath;
+	const resolved = nodeResolveWithVite("terser", void 0, { root }) ?? nodeResolveWithVite("terser", _dirname, { root });
+	if (resolved) return terserPath = resolved;
+	throw new Error("terser not found. Since Vite v3, terser has become an optional dependency. You need to install it.");
+}
+function terserPlugin(config) {
+	const { maxWorkers, ...terserOptions } = config.build.terserOptions;
+	const makeWorker = () => new WorkerWithFallback(() => async (terserPath, code, options) => {
+		const terser = await import(terserPath);
+		try {
+			return await terser.minify(code, options);
+		} catch (e) {
+			throw {
+				stack: e.stack,
+				...e
+			};
+		}
+	}, {
+		shouldUseFake(_terserPath, _code, options) {
+			return !!(typeof options.mangle === "object" && (options.mangle.nth_identifier?.get || typeof options.mangle.properties === "object" && options.mangle.properties.nth_identifier?.get) || typeof options.format?.comments === "function" || typeof options.output?.comments === "function" || options.nameCache);
+		},
+		max: maxWorkers
+	});
+	let worker;
+	return {
+		name: "vite:terser",
+		applyToEnvironment(environment) {
+			return !!environment.config.build.minify;
+		},
+		async renderChunk(code, chunk, outputOptions) {
+			if (config.build.minify !== "terser" && !this.environment.config.isOutputOptionsForLegacyChunks?.(outputOptions)) return null;
+			worker ||= makeWorker();
+			const terserPath = pathToFileURL(loadTerserPath(config.root)).href;
+			try {
+				const res = await worker.run(terserPath, code, {
+					safari10: true,
+					...terserOptions,
+					format: {
+						...terserOptions.format,
+						preserve_annotations: config.build.lib && outputOptions.format === "es" ? true : terserOptions.format?.preserve_annotations
+					},
+					sourceMap: !!outputOptions.sourcemap,
+					module: outputOptions.format.startsWith("es"),
+					toplevel: outputOptions.format === "cjs"
+				});
+				return {
+					code: res.code,
+					map: res.map
+				};
+			} catch (e) {
+				if (e.line !== void 0 && e.col !== void 0) e.loc = {
+					file: chunk.fileName,
+					line: e.line,
+					column: e.col
+				};
+				if (e.pos !== void 0) e.frame = generateCodeFrame(code, e.pos);
+				throw e;
+			}
+		},
+		closeBundle() {
+			worker?.stop();
+		}
+	};
+}
+//#endregion
+//#region src/node/ssr/ssrManifestPlugin.ts
+function ssrManifestPlugin() {
+	const getSsrManifest = perEnvironmentState(() => {
+		return {};
+	});
+	return {
+		name: "vite:ssr-manifest",
+		applyToEnvironment(environment) {
+			return !!environment.config.build.ssrManifest;
+		},
+		generateBundle(_options, bundle) {
+			const config = this.environment.config;
+			const ssrManifest = getSsrManifest(this);
+			const { base } = config;
+			for (const file in bundle) {
+				const chunk = bundle[file];
+				if (chunk.type === "chunk") {
+					for (const id in chunk.modules) {
+						const normalizedId = normalizePath(relative(config.root, id));
+						const mappedChunks = ssrManifest[normalizedId] ?? (ssrManifest[normalizedId] = []);
+						if (!chunk.isEntry) {
+							mappedChunks.push(joinUrlSegments(base, chunk.fileName));
+							chunk.viteMetadata.importedCss.forEach((file) => {
+								mappedChunks.push(joinUrlSegments(base, file));
+							});
+						}
+						chunk.viteMetadata.importedAssets.forEach((file) => {
+							mappedChunks.push(joinUrlSegments(base, file));
+						});
+					}
+					if (chunk.code.includes(preloadMethod)) {
+						const code = chunk.code;
+						let imports = [];
+						try {
+							imports = parse$2(code)[0].filter((i) => i.n && i.d > -1);
+						} catch (_e) {
+							const e = _e;
+							const loc = numberToPos(code, e.idx);
+							this.error({
+								name: e.name,
+								message: e.message,
+								stack: e.stack,
+								cause: e.cause,
+								pos: e.idx,
+								loc: {
+									...loc,
+									file: chunk.fileName
+								},
+								frame: generateCodeFrame(code, loc)
+							});
+						}
+						if (imports.length) for (let index = 0; index < imports.length; index++) {
+							const { s: start, e: end, n: name } = imports[index];
+							const url = code.slice(start, end);
+							const deps = [];
+							const ownerFilename = chunk.fileName;
+							const analyzed = /* @__PURE__ */ new Set();
+							const addDeps = (filename) => {
+								if (filename === ownerFilename) return;
+								if (analyzed.has(filename)) return;
+								analyzed.add(filename);
+								const chunk = bundle[filename];
+								if (chunk) {
+									chunk.viteMetadata.importedCss.forEach((file) => {
+										deps.push(joinUrlSegments(base, file));
+									});
+									chunk.imports.forEach(addDeps);
+								}
+							};
+							addDeps(normalizePath(join(dirname(chunk.fileName), url.slice(1, -1))));
+							ssrManifest[basename(name)] = deps;
+						}
+					}
+				}
+			}
+			this.emitFile({
+				fileName: typeof config.build.ssrManifest === "string" ? config.build.ssrManifest : ".vite/ssr-manifest.json",
+				type: "asset",
+				source: JSON.stringify(sortObjectKeys(ssrManifest), void 0, 2)
+			});
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/license.ts
+const licenseConfigDefaults = Object.freeze({ fileName: ".vite/license.md" });
+const licenseFiles = [
+	/^license/i,
+	/^licence/i,
+	/^copying/i
+];
+function licensePlugin() {
+	return {
+		name: "vite:license",
+		generateBundle(_, bundle) {
+			const licenseOption = this.environment.config.build.license;
+			if (licenseOption === false) return;
+			const packageCache = /* @__PURE__ */ new Map();
+			const licenses = {};
+			for (const file in bundle) {
+				const chunk = bundle[file];
+				if (chunk.type === "asset") continue;
+				for (const moduleId of chunk.moduleIds) {
+					if (moduleId.startsWith("\0") || !isInNodeModules(moduleId)) continue;
+					const pkgData = findNearestMainPackageData(path.dirname(moduleId), packageCache);
+					if (!pkgData) continue;
+					const { name, version = "0.0.0", license } = pkgData.data;
+					const key = `${name}@${version}`;
+					if (licenses[key]) continue;
+					const entry = {
+						name,
+						version
+					};
+					if (license) entry.identifier = license.trim();
+					const licenseFile = findLicenseFile(pkgData.dir);
+					if (licenseFile) entry.text = fs.readFileSync(licenseFile, "utf-8").trim();
+					licenses[key] = entry;
+				}
+			}
+			const licenseEntries = Object.values(sortObjectKeys(licenses));
+			const licenseOutputFileName = typeof licenseOption === "object" ? licenseOption.fileName : licenseConfigDefaults.fileName;
+			if (licenseOutputFileName.endsWith(".json")) {
+				this.emitFile({
+					fileName: licenseOutputFileName,
+					type: "asset",
+					source: JSON.stringify(licenseEntries, null, 2)
+				});
+				return;
+			}
+			const markdown = licenseEntryToMarkdown(licenseEntries);
+			this.emitFile({
+				fileName: licenseOutputFileName,
+				type: "asset",
+				source: markdown
+			});
+		}
+	};
+}
+function licenseEntryToMarkdown(licenses) {
+	if (licenses.length === 0) return `\
+# Licenses
+
+The app does not bundle any dependencies with licenses.
+`;
+	let text = `\
+# Licenses
+
+The app bundles dependencies which contain the following licenses:
+`;
+	for (const license of licenses) {
+		const nameAndVersionText = `${license.name} - ${license.version}`;
+		const identifierText = license.identifier ? ` (${license.identifier})` : "";
+		text += `\n## ${nameAndVersionText}${identifierText}\n`;
+		if (license.text) text += `\n${license.text}\n`;
+	}
+	return text;
+}
+function findLicenseFile(pkgDir) {
+	const matchedFile = fs.readdirSync(pkgDir).find((file) => licenseFiles.some((re) => re.test(file)));
+	if (matchedFile) return path.join(pkgDir, matchedFile);
+}
+//#endregion
+//#region src/node/plugins/prepareOutDir.ts
+function prepareOutDirPlugin() {
+	const rendered = /* @__PURE__ */ new Set();
+	return {
+		name: "vite:prepare-out-dir",
+		watchChange() {
+			rendered.delete(this.environment);
+		},
+		renderStart: {
+			order: "pre",
+			handler() {
+				if (rendered.has(this.environment)) return;
+				const { config } = this.environment;
+				if (config.build.write) {
+					rendered.add(this.environment);
+					const { root, build: options } = config;
+					const resolvedOutDirs = getResolvedOutDirs(root, options.outDir, options.rollupOptions.output);
+					prepareOutDir(resolvedOutDirs, resolveEmptyOutDir(options.emptyOutDir, root, resolvedOutDirs, this.environment.logger), this.environment);
+				}
+			}
+		}
+	};
+}
+function prepareOutDir(outDirs, emptyOutDir, environment) {
+	const { publicDir } = environment.config;
+	const outDirsArray = [...outDirs];
+	for (const outDir of outDirs) {
+		if (emptyOutDir !== false && fs.existsSync(outDir)) emptyDir(outDir, [...outDirsArray.map((dir) => {
+			const relative = path.relative(outDir, dir);
+			if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) return relative;
+			return "";
+		}).filter(Boolean), ".git"]);
+		if (environment.config.build.copyPublicDir && publicDir && fs.existsSync(publicDir)) {
+			if (!areSeparateFolders(outDir, publicDir)) environment.logger.warn(import_picocolors.default.yellow(`\n${import_picocolors.default.bold(`(!)`)} The public directory feature may not work correctly. outDir ${import_picocolors.default.white(import_picocolors.default.dim(outDir))} and publicDir ${import_picocolors.default.white(import_picocolors.default.dim(publicDir))} are not separate folders.\n`));
+			copyDir(publicDir, outDir);
+		}
+	}
+}
+function areSeparateFolders(a, b) {
+	const na = normalizePath(a);
+	const nb = normalizePath(b);
+	return na !== nb && !na.startsWith(withTrailingSlash(nb)) && !nb.startsWith(withTrailingSlash(na));
+}
+//#endregion
+//#region src/node/build.ts
+var build_exports = /* @__PURE__ */ __exportAll({
+	BuildEnvironment: () => BuildEnvironment,
+	ChunkMetadataMap: () => ChunkMetadataMap,
+	build: () => build,
+	buildEnvironmentOptionsDefaults: () => buildEnvironmentOptionsDefaults,
+	builderOptionsDefaults: () => builderOptionsDefaults,
+	clearLine: () => clearLine,
+	createBuilder: () => createBuilder,
+	createToImportMetaURLBasedRelativeRuntime: () => createToImportMetaURLBasedRelativeRuntime,
+	enhanceRollupError: () => enhanceRollupError,
+	injectEnvironmentToHooks: () => injectEnvironmentToHooks,
+	onRollupLog: () => onRollupLog,
+	resolveBuildEnvironmentOptions: () => resolveBuildEnvironmentOptions,
+	resolveBuildOutputs: () => resolveBuildOutputs,
+	resolveBuildPlugins: () => resolveBuildPlugins,
+	resolveBuilderOptions: () => resolveBuilderOptions,
+	resolveLibFilename: () => resolveLibFilename,
+	resolveRolldownOptions: () => resolveRolldownOptions,
+	resolveUserExternal: () => resolveUserExternal,
+	toOutputFilePathInCss: () => toOutputFilePathInCss,
+	toOutputFilePathInHtml: () => toOutputFilePathInHtml,
+	toOutputFilePathInJS: () => toOutputFilePathInJS,
+	toOutputFilePathWithoutRuntime: () => toOutputFilePathWithoutRuntime
+});
+const _buildEnvironmentOptionsDefaults = Object.freeze({
+	target: "baseline-widely-available",
+	/** @deprecated */
+	polyfillModulePreload: true,
+	modulePreload: true,
+	outDir: "dist",
+	assetsDir: "assets",
+	assetsInlineLimit: DEFAULT_ASSETS_INLINE_LIMIT,
+	sourcemap: false,
+	terserOptions: {},
+	rolldownOptions: {},
+	commonjsOptions: {
+		include: [/node_modules/],
+		extensions: [".js", ".cjs"]
+	},
+	dynamicImportVarsOptions: { exclude: [/node_modules/] },
+	write: true,
+	emptyOutDir: null,
+	copyPublicDir: true,
+	license: false,
+	manifest: false,
+	lib: false,
+	ssrManifest: false,
+	ssrEmitAssets: false,
+	reportCompressedSize: true,
+	chunkSizeWarningLimit: 500,
+	watch: null
+});
+const buildEnvironmentOptionsDefaults = _buildEnvironmentOptionsDefaults;
+function resolveBuildEnvironmentOptions(raw, logger, consumer, isBundledDev, isSsrTargetWebworkerEnvironment) {
+	const deprecatedPolyfillModulePreload = raw.polyfillModulePreload;
+	const { polyfillModulePreload, ...rest } = raw;
+	raw = rest;
+	if (deprecatedPolyfillModulePreload !== void 0) logger.warn("polyfillModulePreload is deprecated. Use modulePreload.polyfill instead.");
+	if (deprecatedPolyfillModulePreload === false && raw.modulePreload === void 0) raw.modulePreload = { polyfill: false };
+	const merged = mergeWithDefaults({
+		..._buildEnvironmentOptionsDefaults,
+		cssCodeSplit: !raw.lib,
+		minify: consumer === "server" || isBundledDev ? false : "oxc",
+		rollupOptions: {},
+		rolldownOptions: void 0,
+		ssr: consumer === "server",
+		emitAssets: consumer === "client",
+		createEnvironment: (name, config) => new BuildEnvironment(name, config)
+	}, raw);
+	setupRollupOptionCompat(merged, "build");
+	merged.rolldownOptions = {
+		platform: consumer === "client" || isSsrTargetWebworkerEnvironment ? "browser" : "node",
+		...merged.rolldownOptions
+	};
+	if (merged.target === "baseline-widely-available") merged.target = ESBUILD_BASELINE_WIDELY_AVAILABLE_TARGET;
+	if (Array.isArray(merged.target)) merged.target = unique(merged.target);
+	if (merged.minify === "false") merged.minify = false;
+	else if (merged.minify === true) merged.minify = "oxc";
+	const defaultModulePreload = { polyfill: true };
+	return {
+		...merged,
+		cssTarget: merged.cssTarget ?? merged.target,
+		cssMinify: merged.cssMinify ?? (consumer === "server" ? "lightningcss" : !!merged.minify),
+		modulePreload: merged.modulePreload === false ? false : merged.modulePreload === true ? defaultModulePreload : {
+			...defaultModulePreload,
+			...merged.modulePreload
+		}
+	};
+}
+function resolveBuildPlugins(config) {
+	const isBuild = config.command === "build";
+	return {
+		pre: [
+			...isBuild && !config.isWorker ? [prepareOutDirPlugin()] : [],
+			perEnvironmentPlugin("vite:rollup-options-plugins", async (environment) => {
+				if (!isBuild && !environment.config.isBundled) return false;
+				return (await asyncFlatten(arraify(environment.config.build.rollupOptions.plugins))).filter(Boolean);
+			}),
+			...config.isWorker ? [webWorkerPostPlugin(config)] : []
+		],
+		post: [
+			...isBuild ? buildImportAnalysisPlugin(config) : [],
+			...isBuild && config.build.minify === "esbuild" ? [buildEsbuildPlugin()] : [],
+			...isBuild ? [terserPlugin(config)] : [],
+			...isBuild && !config.isWorker ? [
+				licensePlugin(),
+				manifestPlugin(),
+				ssrManifestPlugin(),
+				buildReporterPlugin(config)
+			] : [],
+			viteLoadFallbackPlugin()
+		]
+	};
+}
+/**
+* Bundles a single environment for production.
+* Returns a Promise containing the build result.
+*/
+async function build(inlineConfig = {}) {
+	const builder = await createBuilder(inlineConfig, true);
+	const environment = Object.values(builder.environments)[0];
+	if (!environment) throw new Error("No environment found");
+	return builder.build(environment);
+}
+function resolveConfigToBuild(inlineConfig = {}, patchConfig, patchPlugins) {
+	return resolveConfig(inlineConfig, "build", "production", "production", false, patchConfig, patchPlugins);
+}
+function resolveRolldownOptions(environment, chunkMetadataMap) {
+	const { root, packageCache, build: options } = environment.config;
+	const libOptions = options.lib;
+	const { logger } = environment;
+	const ssr = environment.config.consumer === "server";
+	const resolve = (p) => path.resolve(root, p);
+	const input = libOptions ? options.rollupOptions.input || (typeof libOptions.entry === "string" ? resolve(libOptions.entry) : Array.isArray(libOptions.entry) ? libOptions.entry.map(resolve) : Object.fromEntries(Object.entries(libOptions.entry).map(([alias, file]) => [alias, resolve(file)]))) : typeof options.ssr === "string" ? resolve(options.ssr) : options.rollupOptions.input || resolve("index.html");
+	if (ssr && typeof input === "string" && input.endsWith(".html")) throw new Error("rollupOptions.input should not be an html file when building for SSR. Please specify a dedicated SSR entry.");
+	if (options.cssCodeSplit === false) {
+		if ((typeof input === "string" ? [input] : Array.isArray(input) ? input : Object.values(input)).some((input) => input.endsWith(".css"))) throw new Error(`When "build.cssCodeSplit: false" is set, "rollupOptions.input" should not include CSS files.`);
+	}
+	const outDir = resolve(options.outDir);
+	const plugins = environment.plugins.map((p) => injectEnvironmentToHooks(environment, chunkMetadataMap, p));
+	const rollupOptions = {
+		preserveEntrySignatures: ssr ? "allow-extension" : libOptions ? "strict" : false,
+		...options.rollupOptions,
+		output: options.rollupOptions.output,
+		input,
+		plugins,
+		external: options.rollupOptions.external,
+		onLog(level, log) {
+			onRollupLog(level, log, environment);
+		},
+		transform: {
+			target: options.target === false ? void 0 : options.target,
+			...options.rollupOptions.transform,
+			define: {
+				...options.rollupOptions.transform?.define,
+				"process.env.NODE_ENV": "process.env.NODE_ENV"
+			}
+		},
+		moduleTypes: {
+			...options.rollupOptions.moduleTypes,
+			".css": "js"
+		},
+		experimental: {
+			...options.rollupOptions.experimental,
+			viteMode: true
+		}
+	};
+	const isSsrTargetWebworkerEnvironment = environment.name === "ssr" && environment.getTopLevelConfig().ssr?.target === "webworker";
+	if (isSsrTargetWebworkerEnvironment) plugins.push(esmExternalRequirePlugin());
+	const buildOutputOptions = (output = {}) => {
+		if (output.output) logger.warn("You've set \"rolldownOptions.output.output\" in your config. This is deprecated and will override all Vite.js default output options. Please use \"rolldownOptions.output\" instead.");
+		if (output.file) throw new Error("Vite does not support \"rolldownOptions.output.file\". Please use \"rolldownOptions.output.dir\" and \"rolldownOptions.output.entryFileNames\" instead.");
+		if (output.sourcemap) logger.warnOnce(import_picocolors.default.yellow("Vite does not support \"rolldownOptions.output.sourcemap\". Please use \"build.sourcemap\" instead."));
+		const format = output.format || "es";
+		const jsExt = ssr && !isSsrTargetWebworkerEnvironment || libOptions ? resolveOutputJsExtension(format, findNearestPackageData(root, packageCache)?.data.type) : "js";
+		return {
+			dir: outDir,
+			format,
+			exports: "auto",
+			sourcemap: options.sourcemap,
+			name: libOptions ? libOptions.name : void 0,
+			generatedCode: { preset: "es2015" },
+			entryFileNames: ssr ? `[name].${jsExt}` : libOptions ? ({ name }) => resolveLibFilename(libOptions, format, name, root, jsExt, packageCache) : path.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
+			chunkFileNames: libOptions ? `[name]-[hash].${jsExt}` : path.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
+			assetFileNames: libOptions ? `[name].[ext]` : path.posix.join(options.assetsDir, `[name]-[hash].[ext]`),
+			codeSplitting: output.codeSplitting ?? (output.format === "umd" || output.format === "iife" || isSsrTargetWebworkerEnvironment && (typeof input === "string" || Object.keys(input).length === 1) ? false : void 0),
+			comments: typeof output.comments === "boolean" ? output.comments : {
+				annotation: !options.minify || libOptions && (format === "es" || format === "esm"),
+				jsdoc: !options.minify,
+				legal: !options.minify,
+				...output.comments
+			},
+			minify: options.minify === "oxc" ? libOptions && (format === "es" || format === "esm") ? {
+				compress: true,
+				mangle: true,
+				codegen: false
+			} : true : options.minify === false ? "dce-only" : false,
+			topLevelVar: true,
+			...output
+		};
+	};
+	const outputs = resolveBuildOutputs(options.rollupOptions.output, libOptions, logger);
+	if (Array.isArray(outputs)) rollupOptions.output = outputs.map(buildOutputOptions);
+	else rollupOptions.output = buildOutputOptions(outputs);
+	return rollupOptions;
+}
+/**
+* Build an App environment, or a App library (if libraryOptions is provided)
+**/
+async function buildEnvironment(environment) {
+	const { logger, config } = environment;
+	const { root, build: options } = config;
+	logger.info(import_picocolors.default.cyan(`vite v${VERSION} ${import_picocolors.default.green(`building ${environment.name} environment for ${environment.config.mode}...`)}`));
+	let bundle;
+	let startTime;
+	try {
+		const chunkMetadataMap = new ChunkMetadataMap();
+		const rollupOptions = resolveRolldownOptions(environment, chunkMetadataMap);
+		if (options.watch) {
+			logger.info(import_picocolors.default.cyan(`\nwatching for file changes...`));
+			const resolvedOutDirs = getResolvedOutDirs(root, options.outDir, options.rollupOptions.output);
+			const emptyOutDir = resolveEmptyOutDir(options.emptyOutDir, root, resolvedOutDirs, logger);
+			const resolvedChokidarOptions = resolveChokidarOptions({
+				...(rollupOptions.watch || {}).chokidar,
+				...options.watch.chokidar
+			}, resolvedOutDirs, emptyOutDir, environment.config.cacheDir);
+			const { watch } = await import("rolldown");
+			const watcher = watch({
+				...rollupOptions,
+				watch: {
+					...rollupOptions.watch,
+					...options.watch,
+					watcher: convertToWatcherOptions(resolvedChokidarOptions)
+				}
+			});
+			watcher.on("event", (event) => {
+				if (event.code === "BUNDLE_START") {
+					logger.info(import_picocolors.default.cyan(`\nbuild started...`));
+					chunkMetadataMap.clearResetChunks();
+				} else if (event.code === "BUNDLE_END") {
+					event.result.close();
+					logger.info(import_picocolors.default.cyan(`built in ${event.duration}ms.`));
+				} else if (event.code === "ERROR") {
+					const e = event.error;
+					enhanceRollupError(e);
+					clearLine();
+					logger.error(e.message, { error: e });
+				}
+			});
+			return watcher;
+		}
+		const { rolldown } = await import("rolldown");
+		startTime = Date.now();
+		bundle = await rolldown(rollupOptions);
+		const res = [];
+		for (const output of arraify(rollupOptions.output)) res.push(await bundle[options.write ? "write" : "generate"](output));
+		for (const output of res) for (const chunk of output.output) injectChunkMetadata(chunkMetadataMap, chunk);
+		logger.info(`${import_picocolors.default.green(`✓ built in ${displayTime(Date.now() - startTime)}`)}`);
+		return Array.isArray(rollupOptions.output) ? res : res[0];
+	} catch (e) {
+		enhanceRollupError(e);
+		clearLine();
+		if (startTime) {
+			logger.error(`${import_picocolors.default.red("✗")} Build failed in ${displayTime(Date.now() - startTime)}`);
+			startTime = void 0;
+		}
+		throw e;
+	} finally {
+		if (bundle) await bundle.close();
+	}
+}
+function enhanceRollupError(e) {
+	const stackOnly = extractStack(e);
+	let msg = import_picocolors.default.red((e.plugin ? `[${e.plugin}] ` : "") + e.message);
+	if (e.loc && e.loc.file && e.loc.file !== e.id) msg += `\nfile: ${import_picocolors.default.cyan(`${e.loc.file}:${e.loc.line}:${e.loc.column}` + (e.id ? ` (${e.id})` : ""))}`;
+	else if (e.id) msg += `\nfile: ${import_picocolors.default.cyan(e.id + (e.loc ? `:${e.loc.line}:${e.loc.column}` : ""))}`;
+	if (e.frame) msg += `\n` + import_picocolors.default.yellow(normalizeCodeFrame(e.frame));
+	e.message = msg;
+	if (stackOnly !== void 0) e.stack = `${e.message}\n${stackOnly}`;
+}
+/**
+* The stack string usually contains a copy of the message at the start of the stack.
+* If the stack starts with the message, we remove it and just return the stack trace
+* portion. Otherwise the original stack trace is used.
+*/
+function extractStack(e) {
+	const { stack, name = "Error", message } = e;
+	if (!stack) return stack;
+	const expectedPrefix = `${name}: ${message}\n`;
+	if (stack.startsWith(expectedPrefix)) return stack.slice(expectedPrefix.length);
+	return stack;
+}
+/**
+* Esbuild code frames have newlines at the start and end of the frame, rollup doesn't
+* This function normalizes the frame to match the esbuild format which has more pleasing padding
+*/
+function normalizeCodeFrame(frame) {
+	return `\n${frame.replace(/^\n|\n$/g, "")}\n`;
+}
+function resolveOutputJsExtension(format, type = "commonjs") {
+	if (type === "module") return format === "cjs" || format === "umd" ? "cjs" : "js";
+	else return format === "es" ? "mjs" : "js";
+}
+function resolveLibFilename(libOptions, format, entryName, root, extension, packageCache) {
+	if (typeof libOptions.fileName === "function") return libOptions.fileName(format, entryName);
+	const packageJson = findNearestMainPackageData(root, packageCache)?.data;
+	const name = libOptions.fileName || (packageJson && typeof libOptions.entry === "string" ? getPkgName(packageJson.name) : entryName);
+	if (!name) throw new Error("Name in package.json is required if option \"build.lib.fileName\" is not provided.");
+	extension ??= resolveOutputJsExtension(format, packageJson?.type);
+	if (format === "cjs" || format === "es") return `${name}.${extension}`;
+	return `${name}.${format}.${extension}`;
+}
+function resolveBuildOutputs(outputs, libOptions, logger) {
+	if (libOptions) {
+		const libHasMultipleEntries = typeof libOptions.entry !== "string" && Object.values(libOptions.entry).length > 1;
+		const libFormats = libOptions.formats || (libHasMultipleEntries ? ["es", "cjs"] : ["es", "umd"]);
+		if (!Array.isArray(outputs)) {
+			if (libFormats.includes("umd") || libFormats.includes("iife")) {
+				if (libHasMultipleEntries) throw new Error("Multiple entry points are not supported when output formats include \"umd\" or \"iife\".");
+				if (!libOptions.name) throw new Error("Option \"build.lib.name\" is required when output formats include \"umd\" or \"iife\".");
+			}
+			return libFormats.map((format) => ({
+				...outputs,
+				format
+			}));
+		}
+		if (libOptions.formats) logger.warn(import_picocolors.default.yellow("\"build.lib.formats\" will be ignored because \"build.rolldownOptions.output\" is already an array format."));
+		outputs.forEach((output) => {
+			if ((output.format === "umd" || output.format === "iife") && !output.name) throw new Error("Entries in \"build.rolldownOptions.output\" must specify \"name\" when the format is \"umd\" or \"iife\".");
+		});
+	}
+	return outputs;
+}
+const warningIgnoreList = [`CIRCULAR_DEPENDENCY`, `THIS_IS_UNDEFINED`];
+const dynamicImportWarningIgnoreList = [`Unsupported expression`, `statically analyzed`];
+function clearLine() {
+	if (process.stdout.isTTY && !process.env.CI) {
+		process.stdout.clearLine(0);
+		process.stdout.cursorTo(0);
+	}
+}
+function onRollupLog(level, log, environment) {
+	const debugLogger = createDebugger("vite:build");
+	const viteLog = (logLeveling, rawLogging) => {
+		const logging = typeof rawLogging === "object" ? rawLogging : { message: rawLogging };
+		if (logging.code === "UNRESOLVED_IMPORT") {
+			const id = logging.id;
+			const exporter = logging.exporter;
+			if (!id || !id.endsWith("?commonjs-external")) throw new Error(`[vite]: Rolldown failed to resolve import "${exporter}" from "${id}".\nThis is most likely unintended because it can break your application at runtime.\nIf you do want to externalize this module explicitly add it to\n\`build.rolldownOptions.external\``);
+		}
+		if (logLeveling === "warn") {
+			if (logging.plugin === "rollup-plugin-dynamic-import-variables" && dynamicImportWarningIgnoreList.some((msg) => logging.message.includes(msg))) return;
+			if (warningIgnoreList.includes(logging.code)) return;
+		}
+		let message = logging.message;
+		if (logging.plugin) message = `[plugin ${logging.plugin}] ${message}`;
+		switch (logLeveling) {
+			case "info":
+				environment.logger.info(message);
+				return;
+			case "warn":
+				environment.logger.warn(import_picocolors.default.yellow(message));
+				return;
+			case "error":
+				environment.logger.error(import_picocolors.default.red(message));
+				return;
+			case "debug":
+				debugLogger?.(message);
+				return;
+			default:
+				environment.logger.info(message);
+				return;
+		}
+	};
+	clearLine();
+	const userOnLog = environment.config.build.rollupOptions?.onLog;
+	const userOnWarn = environment.config.build.rollupOptions?.onwarn;
+	if (userOnLog) if (userOnWarn) userOnLog(level, log, normalizeUserOnWarn(userOnWarn, viteLog));
+	else userOnLog(level, log, viteLog);
+	else if (userOnWarn) normalizeUserOnWarn(userOnWarn, viteLog)(level, log);
+	else viteLog(level, log);
+}
+function normalizeUserOnWarn(userOnWarn, defaultHandler) {
+	return (logLevel, logging) => {
+		if (logLevel === "warn") userOnWarn(normalizeLog(logging), (log) => defaultHandler("warn", typeof log === "function" ? log() : log));
+		else defaultHandler(logLevel, logging);
+	};
+}
+const normalizeLog = (log) => typeof log === "string" ? { message: log } : log;
+function resolveUserExternal(user, id, parentId, isResolved) {
+	if (typeof user === "function") return user(id, parentId, isResolved);
+	else if (Array.isArray(user)) return user.some((test) => isExternal(id, test));
+	else return isExternal(id, user);
+}
+function isExternal(id, test) {
+	if (typeof test === "string") return id === test;
+	else return test.test(id);
+}
+var ChunkMetadataMap = class {
+	_inner = /* @__PURE__ */ new Map();
+	_resetChunks = /* @__PURE__ */ new Set();
+	_getKey(chunk) {
+		return "preliminaryFileName" in chunk ? chunk.preliminaryFileName : chunk.fileName;
+	}
+	_getDefaultValue(chunk) {
+		return chunk.type === "chunk" ? {
+			importedAssets: /* @__PURE__ */ new Set(),
+			importedCss: /* @__PURE__ */ new Set(),
+			__modules: chunk.modules
+		} : {
+			importedAssets: /* @__PURE__ */ new Set(),
+			importedCss: /* @__PURE__ */ new Set()
+		};
+	}
+	get(chunk) {
+		const key = this._getKey(chunk);
+		if (!this._inner.has(key)) this._inner.set(key, this._getDefaultValue(chunk));
+		return this._inner.get(key);
+	}
+	reset(chunk) {
+		const key = this._getKey(chunk);
+		if (this._resetChunks.has(key)) return;
+		this._resetChunks.add(key);
+		this._inner.set(key, this._getDefaultValue(chunk));
+	}
+	clearResetChunks() {
+		this._resetChunks.clear();
+	}
+};
+function injectEnvironmentToHooks(environment, chunkMetadataMap, plugin) {
+	const { resolveId, load, transform } = plugin;
+	const clone = Object.assign(Object.create(Object.getPrototypeOf(plugin)), plugin);
+	for (const hook of Object.keys(clone)) switch (hook) {
+		case "resolveId":
+			clone[hook] = wrapEnvironmentResolveId(environment, resolveId, plugin.name);
+			break;
+		case "load":
+			clone[hook] = wrapEnvironmentLoad(environment, load, plugin.name);
+			break;
+		case "transform":
+			clone[hook] = wrapEnvironmentTransform(environment, transform, plugin.name);
+			break;
+		default:
+			if (ROLLUP_HOOKS.includes(hook)) clone[hook] = wrapEnvironmentHook(environment, chunkMetadataMap, plugin, hook);
+			break;
+	}
+	return clone;
+}
+const wrappedHookMap = /* @__PURE__ */ new WeakMap();
+function wrapHookObject(hook, handler) {
+	const newHook = {
+		...hook,
+		handler
+	};
+	if (!wrappedHookMap.has(hook)) {
+		wrappedHookMap.set(hook, []);
+		Object.defineProperty(hook, "filter", {
+			get() {
+				return wrappedHookMap.get(hook)[0].filter;
+			},
+			set(v) {
+				for (const h of wrappedHookMap.get(hook)) h.filter = v;
+			}
+		});
+		Object.defineProperty(hook, "order", {
+			get() {
+				return wrappedHookMap.get(hook)[0].order;
+			},
+			set(v) {
+				for (const h of wrappedHookMap.get(hook)) h.order = v;
+			}
+		});
+	}
+	wrappedHookMap.get(hook).push(newHook);
+	return newHook;
+}
+function wrapEnvironmentResolveId(environment, hook, pluginName) {
+	if (!hook) return;
+	const fn = getHookHandler(hook);
+	const handler = function(id, importer, options) {
+		return fn.call(injectEnvironmentInContext(this, environment), id, importer, injectSsrFlag(options, environment, pluginName));
+	};
+	if ("handler" in hook) return wrapHookObject(hook, handler);
+	else return handler;
+}
+function wrapEnvironmentLoad(environment, hook, pluginName) {
+	if (!hook) return;
+	const fn = getHookHandler(hook);
+	const handler = function(id, ...args) {
+		return fn.call(injectEnvironmentInContext(this, environment), id, injectSsrFlag(args[0], environment, pluginName));
+	};
+	if ("handler" in hook) return wrapHookObject(hook, handler);
+	else return handler;
+}
+function wrapEnvironmentTransform(environment, hook, pluginName) {
+	if (!hook) return;
+	const fn = getHookHandler(hook);
+	const handler = function(code, importer, ...args) {
+		return fn.call(injectEnvironmentInContext(this, environment), code, importer, injectSsrFlag(args[0], environment, pluginName));
+	};
+	if ("handler" in hook) return wrapHookObject(hook, handler);
+	else return handler;
+}
+function wrapEnvironmentHook(environment, chunkMetadataMap, plugin, hookName) {
+	const hook = plugin[hookName];
+	if (!hook) return;
+	const fn = getHookHandler(hook);
+	if (typeof fn !== "function") return hook;
+	const handler = function(...args) {
+		if (hookName === "renderChunk") injectChunkMetadata(chunkMetadataMap, args[1], true);
+		if (hookName === "augmentChunkHash") injectChunkMetadata(chunkMetadataMap, args[0]);
+		if (hookName === "generateBundle" || hookName === "writeBundle") {
+			const bundle = args[1];
+			for (const chunk of Object.values(bundle)) injectChunkMetadata(chunkMetadataMap, chunk);
+		}
+		return fn.call(injectEnvironmentInContext(this, environment), ...args);
+	};
+	if ("handler" in hook) return wrapHookObject(hook, handler);
+	else return handler;
+}
+function injectChunkMetadata(chunkMetadataMap, chunk, resetChunkMetadata = false) {
+	if (resetChunkMetadata) chunkMetadataMap.reset(chunk);
+	Object.defineProperty(chunk, "viteMetadata", {
+		value: chunkMetadataMap.get(chunk),
+		enumerable: true
+	});
+	if (chunk.type === "chunk") Object.defineProperty(chunk, "modules", {
+		get() {
+			return chunk.viteMetadata.__modules;
+		},
+		enumerable: true
+	});
+}
+function injectEnvironmentInContext(context, environment) {
+	context.meta.viteVersion ??= VERSION;
+	context.environment ??= environment;
+	return context;
+}
+function injectSsrFlag(options, environment, pluginName) {
+	let ssr = environment.config.consumer === "server";
+	const newOptions = {
+		...options ?? {},
+		ssr
+	};
+	if (isFutureDeprecationEnabled(environment?.getTopLevelConfig(), "removePluginHookSsrArgument")) Object.defineProperty(newOptions, "ssr", {
+		get() {
+			warnFutureDeprecation(environment?.getTopLevelConfig(), "removePluginHookSsrArgument", `Used in plugin "${pluginName}".`);
+			return ssr;
+		},
+		set(v) {
+			ssr = v;
+		}
+	});
+	return newOptions;
+}
+const needsEscapeRegEx = /[\n\r'\\\u2028\u2029]/;
+const quoteNewlineRegEx = /([\n\r'\u2028\u2029])/g;
+const backSlashRegEx = /\\/g;
+function escapeId(id) {
+	if (!needsEscapeRegEx.test(id)) return id;
+	return id.replace(backSlashRegEx, "\\\\").replace(quoteNewlineRegEx, "\\$1");
+}
+const getResolveUrl = (path, URL = "URL") => `new ${URL}(${path}).href`;
+const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(`'${escapeId(partialEncodeURIPath(relativePath))}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ""}document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || document.baseURI`);
+const getFileUrlFromFullPath = (path) => `require('u' + 'rl').pathToFileURL(${path}).href`;
+const getFileUrlFromRelativePath = (path) => getFileUrlFromFullPath(`__dirname + '/${escapeId(path)}'`);
+const customRelativeUrlMechanisms = {
+	cjs: (relativePath) => `(typeof document === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath)})`,
+	es: (relativePath) => getResolveUrl(`'${escapeId(partialEncodeURIPath(relativePath))}', import.meta.url`),
+	iife: (relativePath) => getRelativeUrlFromDocument(relativePath),
+	umd: (relativePath) => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath, true)})`,
+	"worker-iife": (relativePath) => getResolveUrl(`'${escapeId(partialEncodeURIPath(relativePath))}', self.location.href`)
+};
+function toOutputFilePathInJS(environment, filename, type, hostId, hostType, toRelative) {
+	const { experimental, base, decodedBase } = environment.config;
+	const ssr = environment.config.consumer === "server";
+	const { renderBuiltUrl } = experimental;
+	let relative = base === "" || base === "./";
+	if (renderBuiltUrl) {
+		const result = renderBuiltUrl(filename, {
+			hostId,
+			hostType,
+			type,
+			ssr
+		});
+		if (typeof result === "object") {
+			if (result.runtime) return { runtime: result.runtime };
+			if (typeof result.relative === "boolean") relative = result.relative;
+		} else if (result) return result;
+	}
+	if (relative && !ssr) return toRelative(filename, hostId);
+	return joinUrlSegments(decodedBase, filename);
+}
+function createToImportMetaURLBasedRelativeRuntime(format, isWorker) {
+	const toRelativePath = customRelativeUrlMechanisms[isWorker && format === "iife" ? "worker-iife" : format];
+	return (filename, importer) => ({ runtime: toRelativePath(path.posix.relative(path.dirname(importer), filename)) });
+}
+function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config, toRelative) {
+	const { renderBuiltUrl } = config.experimental;
+	let relative = config.base === "" || config.base === "./";
+	if (renderBuiltUrl) {
+		const result = renderBuiltUrl(filename, {
+			hostId,
+			hostType,
+			type,
+			ssr: !!config.build.ssr
+		});
+		if (typeof result === "object") {
+			if (result.runtime) throw new Error(`{ runtime: "${result.runtime}" } is not supported for assets in ${hostType} files: ${filename}`);
+			if (typeof result.relative === "boolean") relative = result.relative;
+		} else if (result) return result;
+	}
+	if (relative && !config.build.ssr) return toRelative(filename, hostId);
+	else return joinUrlSegments(config.decodedBase, filename);
+}
+const toOutputFilePathInCss = toOutputFilePathWithoutRuntime;
+const toOutputFilePathInHtml = toOutputFilePathWithoutRuntime;
+var BuildEnvironment = class extends BaseEnvironment {
+	mode = "build";
+	isBuilt = false;
+	constructor(name, config, setup) {
+		let options = config.environments[name];
+		if (!options) throw new Error(`Environment "${name}" is not defined in the config.`);
+		if (setup?.options) options = mergeConfig(options, setup.options);
+		super(name, config, options);
+	}
+	async init() {
+		if (this._initiated) return;
+		this._initiated = true;
+	}
+};
+const _builderOptionsDefaults = Object.freeze({
+	sharedConfigBuild: false,
+	sharedPlugins: false
+});
+const builderOptionsDefaults = _builderOptionsDefaults;
+function resolveBuilderOptions(options) {
+	if (!options) return;
+	return mergeWithDefaults({
+		..._builderOptionsDefaults,
+		buildApp: async () => {}
+	}, options);
+}
+/**
+* Creates a ViteBuilder to orchestrate building multiple environments.
+* @experimental
+*/
+async function createBuilder(inlineConfig = {}, useLegacyBuilder = false) {
+	const patchConfig = (resolved) => {
+		if (!(useLegacyBuilder ?? !resolved.builder)) return;
+		resolved.build = { ...resolved.environments[resolved.build.ssr ? "ssr" : "client"].build };
+	};
+	const config = await resolveConfigToBuild(inlineConfig, patchConfig);
+	useLegacyBuilder ??= !config.builder;
+	const configBuilder = config.builder ?? resolveBuilderOptions({});
+	const environments = {};
+	const builder = {
+		environments,
+		config,
+		async buildApp() {
+			const pluginContext = new BasicMinimalPluginContext({
+				...basePluginContextMeta,
+				watchMode: false
+			}, config.logger);
+			let configBuilderBuildAppCalled = false;
+			for (const p of config.getSortedPlugins("buildApp")) {
+				const hook = p.buildApp;
+				if (!configBuilderBuildAppCalled && typeof hook === "object" && hook.order === "post") {
+					configBuilderBuildAppCalled = true;
+					await configBuilder.buildApp(builder);
+				}
+				await getHookHandler(hook).call(pluginContext, builder);
+			}
+			if (!configBuilderBuildAppCalled) await configBuilder.buildApp(builder);
+			if (Object.values(builder.environments).every((environment) => !environment.isBuilt)) for (const environment of Object.values(builder.environments)) await builder.build(environment);
+		},
+		async build(environment) {
+			const output = await buildEnvironment(environment);
+			environment.isBuilt = true;
+			return output;
+		},
+		async runDevTools() {
+			if (config.devtools.enabled) try {
+				const { runDevTools } = await import("@vitejs/devtools/integration");
+				await runDevTools(builder);
+			} catch (e) {
+				config.logger.error(import_picocolors.default.red(`Failed to run Vite DevTools: ${e?.message || e?.stack}`), { error: e });
+			}
+		}
+	};
+	async function setupEnvironment(name, config) {
+		const environment = await config.build.createEnvironment(name, config);
+		await environment.init();
+		environments[name] = environment;
+	}
+	if (useLegacyBuilder) await setupEnvironment(config.build.ssr ? "ssr" : "client", config);
+	else {
+		const environmentConfigs = [];
+		for (const environmentName of Object.keys(config.environments)) {
+			let environmentConfig = config;
+			if (!configBuilder.sharedConfigBuild) {
+				const patchConfig = (resolved) => {
+					resolved.build = { ...resolved.environments[environmentName].build };
+				};
+				const patchPlugins = (resolvedPlugins) => {
+					let j = 0;
+					for (let i = 0; i < resolvedPlugins.length; i++) {
+						const environmentPlugin = resolvedPlugins[i];
+						if (configBuilder.sharedPlugins || environmentPlugin.sharedDuringBuild) {
+							for (let k = j; k < config.plugins.length; k++) if (environmentPlugin.name === config.plugins[k].name) {
+								resolvedPlugins[i] = config.plugins[k];
+								j = k + 1;
+								break;
+							}
+						}
+					}
+				};
+				environmentConfig = await resolveConfigToBuild(inlineConfig, patchConfig, patchPlugins);
+			}
+			environmentConfigs.push([environmentName, environmentConfig]);
+		}
+		await Promise.all(environmentConfigs.map(async ([environmentName, environmentConfig]) => await setupEnvironment(environmentName, environmentConfig)));
+	}
+	return builder;
+}
+//#endregion
+//#region src/node/server/environments/runnableEnvironment.ts
+function createRunnableDevEnvironment(name, config, context = {}) {
+	if (context.transport == null) context.transport = createServerHotChannel();
+	if (context.hot == null) context.hot = true;
+	return new RunnableDevEnvironment(name, config, context);
+}
+function isRunnableDevEnvironment(environment) {
+	return environment instanceof RunnableDevEnvironment;
+}
+var RunnableDevEnvironment = class extends DevEnvironment {
+	_runner;
+	_runnerFactory;
+	_runnerOptions;
+	constructor(name, config, context) {
+		super(name, config, context);
+		this._runnerFactory = context.runner;
+		this._runnerOptions = context.runnerOptions;
+	}
+	get runner() {
+		if (this._runner) return this._runner;
+		const factory = this._runnerFactory || createServerModuleRunner;
+		this._runner = factory(this, this._runnerOptions);
+		return this._runner;
+	}
+	async close() {
+		await super.close();
+		if (this._runner) await this._runner.close();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@polka+compression@1.0.0-next.25/node_modules/@polka/compression/build.mjs
+const NOOP = () => {};
+const MIMES = /text|javascript|\/json|xml/i;
+/**
+* @param {any} chunk
+* @param {BufferEncoding} enc
+* @returns {number}
+*/
+function getChunkSize(chunk, enc) {
+	return chunk ? Buffer.byteLength(chunk, enc) : 0;
+}
+/**
+* @param {import('./index.d.mts').Options} [options]
+* @returns {import('./index.d.mts').Middleware}
+*/
+function build_default({ threshold = 1024, level = -1, brotli = false, gzip = true, mimes = MIMES } = {}) {
+	const brotliOpts = typeof brotli === "object" && brotli || {};
+	const gzipOpts = typeof gzip === "object" && gzip || {};
+	if (!zlib.createBrotliCompress) brotli = false;
+	return (req, res, next = NOOP) => {
+		const accept = req.headers["accept-encoding"] + "";
+		const encoding = (brotli && accept.match(/\bbr\b/) || gzip && accept.match(/\bgzip\b/) || [])[0];
+		if (req.method === "HEAD" || !encoding) return next();
+		/** @type {zlib.Gzip | zlib.BrotliCompress} */
+		let compress;
+		/** @type {Array<[string, function]>?} */
+		let pendingListeners = [];
+		let pendingStatus = 0;
+		let started = false;
+		let size = 0;
+		function start() {
+			started = true;
+			size = res.getHeader("Content-Length") | 0 || size;
+			const compressible = mimes.test(String(res.getHeader("Content-Type") || "text/plain"));
+			const cleartext = !res.getHeader("Content-Encoding");
+			const listeners = pendingListeners || [];
+			if (compressible && cleartext && size >= threshold) {
+				res.setHeader("Content-Encoding", encoding);
+				res.removeHeader("Content-Length");
+				if (encoding === "br") compress = zlib.createBrotliCompress({ params: Object.assign({
+					[zlib.constants.BROTLI_PARAM_QUALITY]: level,
+					[zlib.constants.BROTLI_PARAM_SIZE_HINT]: size
+				}, brotliOpts) });
+				else compress = zlib.createGzip(Object.assign({ level }, gzipOpts));
+				compress.on("data", (chunk) => write.call(res, chunk) || compress.pause());
+				on.call(res, "drain", () => compress.resume());
+				compress.on("end", () => end.call(res));
+				listeners.forEach((p) => compress.on.apply(compress, p));
+			} else {
+				pendingListeners = null;
+				listeners.forEach((p) => on.apply(res, p));
+			}
+			writeHead.call(res, pendingStatus || res.statusCode);
+		}
+		const { end, write, on, writeHead } = res;
+		res.writeHead = function(status, reason, headers) {
+			if (typeof reason !== "string") [headers, reason] = [reason, headers];
+			if (headers) for (let k in headers) res.setHeader(k, headers[k]);
+			pendingStatus = status;
+			return this;
+		};
+		res.write = function(chunk, enc) {
+			size += getChunkSize(chunk, enc);
+			if (!started) start();
+			if (!compress) return write.apply(this, arguments);
+			return compress.write.apply(compress, arguments);
+		};
+		res.end = function(chunk, enc) {
+			if (arguments.length > 0 && typeof chunk !== "function") size += getChunkSize(chunk, enc);
+			if (!started) start();
+			if (!compress) return end.apply(this, arguments);
+			return compress.end.apply(compress, arguments);
+		};
+		res.on = function(type, listener) {
+			if (!pendingListeners) on.call(this, type, listener);
+			else if (compress) compress.on(type, listener);
+			else pendingListeners.push([type, listener]);
+			return this;
+		};
+		next();
+	};
+}
+//#endregion
+//#region src/node/preview.ts
+var preview_exports = /* @__PURE__ */ __exportAll({
+	preview: () => preview,
+	resolvePreviewOptions: () => resolvePreviewOptions
+});
+function resolvePreviewOptions(preview, server) {
+	return {
+		port: preview?.port ?? 4173,
+		strictPort: preview?.strictPort ?? server.strictPort,
+		host: preview?.host ?? server.host,
+		allowedHosts: preview?.allowedHosts ?? server.allowedHosts,
+		https: preview?.https ?? server.https,
+		open: preview?.open ?? server.open,
+		proxy: preview?.proxy ?? server.proxy,
+		cors: preview?.cors ?? server.cors,
+		headers: preview?.headers ?? server.headers
+	};
+}
+/**
+* Starts the Vite server in preview mode, to simulate a production deployment
+*/
+async function preview(inlineConfig = {}) {
+	const config = await resolveConfig(inlineConfig, "serve", "production", "production", true);
+	const clientOutDir = config.environments.client.build.outDir;
+	const distDir = path.resolve(config.root, clientOutDir);
+	if (!fs.existsSync(distDir) && config.plugins.every((plugin) => !plugin.configurePreviewServer) && process.argv[1]?.endsWith(path.normalize("bin/vite.js")) && process.argv[2] === "preview") throw new Error(`The directory "${clientOutDir}" does not exist. Did you build your project?`);
+	const httpsOptions = await resolveHttpsConfig(config.preview.https);
+	const app = (0, import_connect.default)();
+	const httpServer = await resolveHttpServer(app, httpsOptions);
+	setClientErrorHandler(httpServer, config.logger);
+	const options = config.preview;
+	const logger = config.logger;
+	const closeHttpServer = createServerCloseFn(httpServer);
+	let closeServerPromise;
+	const closeServer = async () => {
+		teardownSIGTERMListener(closeServerAndExit);
+		await closeHttpServer();
+		server.resolvedUrls = null;
+	};
+	const server = {
+		config,
+		middlewares: app,
+		httpServer,
+		async close() {
+			if (!closeServerPromise) closeServerPromise = closeServer();
+			return closeServerPromise;
+		},
+		resolvedUrls: null,
+		printUrls() {
+			if (server.resolvedUrls) printServerUrls(server.resolvedUrls, options.host, logger.info);
+			else throw new Error("cannot print server URLs before server is listening.");
+		},
+		bindCLIShortcuts(options) {
+			bindCLIShortcuts(server, options);
+		}
+	};
+	const closeServerAndExit = async (_, exitCode) => {
+		try {
+			await server.close();
+		} finally {
+			process.exitCode ??= exitCode ? 128 + exitCode : void 0;
+			process.exit();
+		}
+	};
+	setupSIGTERMListener(closeServerAndExit);
+	const { cors } = config.preview;
+	if (cors !== false) app.use((0, import_lib.default)(typeof cors === "boolean" ? {} : cors));
+	const { allowedHosts } = config.preview;
+	if (allowedHosts !== true && !config.preview.https) app.use(hostValidationMiddleware(allowedHosts, true));
+	const configurePreviewServerContext = new BasicMinimalPluginContext({
+		...basePluginContextMeta,
+		watchMode: false
+	}, config.logger);
+	const postHooks = [];
+	for (const hook of config.getSortedPluginHooks("configurePreviewServer")) postHooks.push(await hook.call(configurePreviewServerContext, server));
+	const { proxy } = config.preview;
+	if (proxy) app.use(proxyMiddleware(httpServer, proxy, config));
+	app.use(build_default());
+	if (config.base !== "/") app.use(baseMiddleware(config.rawBase, false));
+	const headers = config.preview.headers;
+	const viteAssetMiddleware = (...args) => build_default$1(distDir, {
+		etag: true,
+		dev: true,
+		extensions: [],
+		ignores: false,
+		setHeaders(res) {
+			if (headers) for (const name in headers) res.setHeader(name, headers[name]);
+		},
+		shouldServe(filePath) {
+			return shouldServeFile(filePath, distDir);
+		}
+	})(...args);
+	app.use(viteAssetMiddleware);
+	if (config.appType === "spa" || config.appType === "mpa") app.use(htmlFallbackMiddleware(distDir, config.appType === "spa"));
+	postHooks.forEach((fn) => fn && fn());
+	if (config.appType === "spa" || config.appType === "mpa") {
+		const normalizedDistDir = normalizePath(distDir);
+		app.use(indexHtmlMiddleware(normalizedDistDir, server));
+		app.use(notFoundMiddleware());
+	}
+	const hostname = await resolveHostname(options.host);
+	await httpServerStart(httpServer, {
+		port: options.port,
+		strictPort: options.strictPort,
+		host: hostname.host,
+		logger
+	});
+	server.resolvedUrls = resolveServerUrls(httpServer, config.preview, hostname, httpsOptions, config);
+	if (options.open) {
+		const url = getServerUrlByHost(server.resolvedUrls, options.host);
+		if (url) openBrowser(typeof options.open === "string" ? new URL(options.open, url).href : url, true, logger);
+	}
+	return server;
+}
+//#endregion
+//#region src/node/ssr/index.ts
+const _ssrConfigDefaults = Object.freeze({
+	target: "node",
+	optimizeDeps: {}
+});
+const ssrConfigDefaults = _ssrConfigDefaults;
+function resolveSSROptions(ssr, preserveSymlinks) {
+	return mergeWithDefaults(mergeWithDefaults(_ssrConfigDefaults, { optimizeDeps: { esbuildOptions: { preserveSymlinks } } }), ssr ?? {});
+}
+//#endregion
+//#region src/node/ssr/runnerImport.ts
+/**
+* Import any file using the default Vite environment.
+* @experimental
+*/
+async function runnerImport(moduleId, inlineConfig) {
+	const isModuleSyncConditionEnabled = (await import("#module-sync-enabled")).default;
+	const environment = createRunnableDevEnvironment("inline", await resolveConfig(mergeConfig(inlineConfig || {}, {
+		configFile: false,
+		envDir: false,
+		cacheDir: process.cwd(),
+		environments: { inline: {
+			consumer: "server",
+			dev: { moduleRunnerTransform: true },
+			resolve: {
+				external: true,
+				mainFields: [],
+				conditions: ["node", ...isModuleSyncConditionEnabled ? ["module-sync"] : []]
+			}
+		} }
+	}), "serve"), {
+		runnerOptions: { hmr: { logger: false } },
+		hot: false
+	});
+	await environment.init();
+	try {
+		const module = await environment.runner.import(moduleId);
+		return {
+			module,
+			dependencies: [...environment.runner.evaluatedModules.urlToIdModuleMap.values()].filter((m) => {
+				if (!m.meta || "externalize" in m.meta) return false;
+				return m.exports !== module;
+			}).map((m) => m.file)
+		};
+	} finally {
+		await environment.close();
+	}
+}
+//#endregion
+//#region src/node/optimizer/pluginConverter.ts
+function convertEsbuildPluginToRolldownPlugin(esbuildPlugin) {
+	const onStartCallbacks = [];
+	const onEndCallbacks = [];
+	const onDisposeCallbacks = [];
+	let resolveIdHandlers;
+	let loadHandlers;
+	let isSetupDone = false;
+	const setup = async (plugins, platform) => {
+		const onResolveCallbacks = [];
+		const onLoadCallbacks = [];
+		const pluginBuild = {
+			initialOptions: new Proxy({
+				platform,
+				plugins: plugins?.flatMap((p) => p && "name" in p ? [{
+					name: p.name,
+					setup() {}
+				}] : []) ?? []
+			}, { get(target, p, _receiver) {
+				if (p in target) return target[p];
+				throw new Error("Not implemented");
+			} }),
+			resolve() {
+				throw new Error("Not implemented");
+			},
+			onStart(callback) {
+				onStartCallbacks.push(callback);
+			},
+			onEnd(callback) {
+				onEndCallbacks.push(callback);
+			},
+			onResolve(options, callback) {
+				onResolveCallbacks.push([options, callback]);
+			},
+			onLoad(options, callback) {
+				onLoadCallbacks.push([options, callback]);
+			},
+			onDispose(callback) {
+				onDisposeCallbacks.push(callback);
+			},
+			get esbuild() {
+				throw new Error("Not implemented");
+			},
+			set esbuild(_) {
+				throw new Error("Not implemented");
+			}
+		};
+		await esbuildPlugin.setup(pluginBuild);
+		resolveIdHandlers = onResolveCallbacks.map(([options, callback]) => createResolveIdHandler(options, callback));
+		loadHandlers = onLoadCallbacks.map(([options, callback]) => createLoadHandler(options, callback));
+		isSetupDone = true;
+	};
+	const usedNamespaces = /* @__PURE__ */ new Set();
+	return {
+		name: esbuildPlugin.name,
+		async options(inputOptions) {
+			await setup(inputOptions.plugins, inputOptions.platform ?? "node");
+		},
+		async buildStart(inputOptions) {
+			if (!isSetupDone) await setup([{ name: "vite:dep-scan" }], inputOptions.platform ?? "node");
+			for (const cb of onStartCallbacks) cb();
+		},
+		generateBundle(_outputOpts, _bundle, isWrite) {
+			const buildResult = new Proxy({
+				metafile: void 0,
+				mangleCache: void 0,
+				...isWrite ? { outputFiles: void 0 } : {}
+			}, { get(_target, prop) {
+				if (prop in _target || typeof prop === "symbol") return _target[prop];
+				throw new Error("Not implemented property: " + prop);
+			} });
+			for (const cb of onEndCallbacks) cb(buildResult);
+		},
+		async resolveId(id, importer, opts) {
+			for (const handler of resolveIdHandlers) {
+				const result = await handler.call(this, id, importer, opts);
+				if (result) {
+					if (typeof result === "object" && result.namespace) usedNamespaces.add(result.namespace);
+					return result;
+				}
+			}
+			if (usedNamespaces.size) {
+				const [importerWithoutNamespace, namespaceFromImporter] = idToPathAndNamespace(importer);
+				if (usedNamespaces.has(namespaceFromImporter)) return await this.resolve(id, importerWithoutNamespace, opts);
+			}
+		},
+		async load(id) {
+			for (const handler of loadHandlers) {
+				const result = await handler.call(this, id);
+				if (result) return result;
+			}
+		},
+		closeBundle() {
+			if (!this.meta.watchMode) for (const cb of onDisposeCallbacks) cb();
+		},
+		closeWatcher() {
+			for (const cb of onDisposeCallbacks) cb();
+		}
+	};
+}
+function createResolveIdHandler(options, callback) {
+	return async function(id, importer, opts) {
+		const [importerWithoutNamespace, importerNamespace] = idToPathAndNamespace(importer);
+		if (options.namespace !== void 0 && options.namespace !== importerNamespace) return;
+		if (options.filter !== void 0 && !options.filter.test(id)) return;
+		const result = await callback({
+			path: id,
+			importer: importerWithoutNamespace ?? "",
+			namespace: importerNamespace,
+			resolveDir: dirname(importerWithoutNamespace ?? ""),
+			kind: importerWithoutNamespace === void 0 ? "entry-point" : opts.kind === "new-url" || opts.kind === "hot-accept" ? "dynamic-import" : opts.kind,
+			pluginData: {},
+			with: {}
+		});
+		if (!result) return;
+		if (result.errors && result.errors.length > 0) throw new AggregateError(result.errors);
+		if (result.warnings && result.warnings.length > 0 || result.watchDirs && result.watchDirs.length > 0 || !result.path) throw new Error("not implemented");
+		for (const file of result.watchFiles ?? []) this.addWatchFile(file);
+		return {
+			id: result.namespace ? `${result.namespace}:${result.path}` : result.path,
+			external: result.external,
+			moduleSideEffects: result.sideEffects,
+			namespace: result.namespace
+		};
+	};
+}
+function createLoadHandler(options, callback) {
+	const textDecoder = new TextDecoder();
+	return async function(id) {
+		const [idWithoutNamespace, idNamespace] = idToPathAndNamespace(id);
+		if (options.namespace !== void 0 && options.namespace !== "file" && options.namespace !== idNamespace) return;
+		if (options.filter !== void 0 && !options.filter.test(id)) return;
+		const result = await callback.call(this, {
+			path: idWithoutNamespace,
+			namespace: idNamespace,
+			suffix: "",
+			pluginData: {},
+			with: {}
+		});
+		if (!result) return;
+		if (result.errors && result.errors.length > 0) throw new AggregateError(result.errors);
+		if (result.warnings && result.warnings.length > 0 || result.watchDirs && result.watchDirs.length > 0 || result.contents == null) throw new Error("not implemented");
+		for (const file of result.watchFiles ?? []) this.addWatchFile(file);
+		return {
+			code: typeof result.contents === "string" ? result.contents : textDecoder.decode(result.contents),
+			moduleType: result.loader
+		};
+	};
+}
+function idToPathAndNamespace(id) {
+	if (id === void 0) return [void 0, "file"];
+	const namespaceIndex = id.indexOf(":");
+	if (namespaceIndex >= 0) return [id.slice(namespaceIndex + 1), id.slice(0, namespaceIndex)];
+	else return [id, "file"];
+}
+//#endregion
+//#region src/node/config.ts
+var config_exports = /* @__PURE__ */ __exportAll({
+	defineConfig: () => defineConfig,
+	getDefaultEnvironmentOptions: () => getDefaultEnvironmentOptions,
+	isResolvedConfig: () => isResolvedConfig,
+	loadConfigFromFile: () => loadConfigFromFile,
+	resolveBaseUrl: () => resolveBaseUrl,
+	resolveConfig: () => resolveConfig,
+	resolveDevEnvironmentOptions: () => resolveDevEnvironmentOptions,
+	resolveDevToolsConfig: () => resolveDevToolsConfig,
+	sortUserPlugins: () => sortUserPlugins
+});
+const debug = createDebugger("vite:config", { depth: 10 });
+const promisifiedRealpath = promisify(fs.realpath);
+const SYMBOL_RESOLVED_CONFIG = Symbol("vite:resolved-config");
+function defineConfig(config) {
+	return config;
+}
+function defaultCreateClientDevEnvironment(name, config, context) {
+	if (config.experimental.bundledDev) return new FullBundleDevEnvironment(name, config, {
+		hot: true,
+		transport: context.ws
+	});
+	return new DevEnvironment(name, config, {
+		hot: true,
+		transport: context.ws,
+		disableFetchModule: true
+	});
+}
+function defaultCreateDevEnvironment(name, config) {
+	return createRunnableDevEnvironment(name, config);
+}
+async function resolveDevToolsConfig(config, host, logger) {
+	const isEnabled = config === true || !!(config && config.enabled);
+	const fallbackHostname = (await resolveHostname(host)).host ?? "localhost";
+	const fallbackConfig = {
+		config: { host: fallbackHostname },
+		enabled: false
+	};
+	if (!isEnabled) return fallbackConfig;
+	try {
+		const { normalizeDevToolsConfig } = await import("@vitejs/devtools/config");
+		return normalizeDevToolsConfig(config, fallbackHostname);
+	} catch (e) {
+		logger.error(import_picocolors.default.red(`Failed to load Vite DevTools config: ${e.message || e.stack}`), { error: e });
+		return fallbackConfig;
+	}
+}
+const configDefaults = Object.freeze({
+	define: {},
+	dev: {
+		warmup: [],
+		/** @experimental */
+		sourcemap: { js: true },
+		sourcemapIgnoreList: void 0
+	},
+	build: buildEnvironmentOptionsDefaults,
+	resolve: {
+		externalConditions: [...DEFAULT_EXTERNAL_CONDITIONS],
+		extensions: DEFAULT_EXTENSIONS,
+		dedupe: [],
+		/** @experimental */
+		noExternal: [],
+		external: [],
+		preserveSymlinks: false,
+		tsconfigPaths: false,
+		alias: []
+	},
+	base: "/",
+	publicDir: "public",
+	plugins: [],
+	html: { cspNonce: void 0 },
+	css: cssConfigDefaults,
+	json: {
+		namedExports: true,
+		stringify: "auto"
+	},
+	assetsInclude: void 0,
+	/** @experimental */
+	builder: builderOptionsDefaults,
+	server: serverConfigDefaults,
+	preview: { port: DEFAULT_PREVIEW_PORT },
+	/** @experimental */
+	experimental: {
+		importGlobRestoreExtension: false,
+		renderBuiltUrl: void 0,
+		hmrPartialAccept: false,
+		bundledDev: false
+	},
+	future: {
+		removePluginHookHandleHotUpdate: void 0,
+		removePluginHookSsrArgument: void 0,
+		removeServerModuleGraph: void 0,
+		removeServerHot: void 0,
+		removeServerTransformRequest: void 0,
+		removeServerWarmupRequest: void 0,
+		removeSsrLoadModule: void 0
+	},
+	legacy: { skipWebSocketTokenCheck: false },
+	logLevel: "info",
+	customLogger: void 0,
+	clearScreen: true,
+	envDir: void 0,
+	envPrefix: "VITE_",
+	worker: {
+		format: "iife",
+		plugins: () => []
+	},
+	optimizeDeps: {
+		include: [],
+		exclude: [],
+		needsInterop: [],
+		rolldownOptions: {},
+		/** @experimental */
+		extensions: [],
+		/** @deprecated @experimental */
+		disabled: "build",
+		/** @experimental */
+		holdUntilCrawlEnd: true,
+		/** @experimental */
+		force: false,
+		/** @experimental */
+		ignoreOutdatedRequests: false
+	},
+	ssr: ssrConfigDefaults,
+	environments: {},
+	appType: "spa"
+});
+function resolveDevEnvironmentOptions(dev, environmentName, consumer, preTransformRequest) {
+	const resolved = mergeWithDefaults({
+		...configDefaults.dev,
+		sourcemapIgnoreList: isInNodeModules,
+		preTransformRequests: preTransformRequest ?? consumer === "client",
+		createEnvironment: environmentName === "client" ? defaultCreateClientDevEnvironment : defaultCreateDevEnvironment,
+		recoverable: consumer === "client",
+		moduleRunnerTransform: consumer === "server"
+	}, dev ?? {});
+	return {
+		...resolved,
+		sourcemapIgnoreList: resolved.sourcemapIgnoreList === false ? () => false : resolved.sourcemapIgnoreList
+	};
+}
+function resolveEnvironmentOptions(options, alias, preserveSymlinks, forceOptimizeDeps, logger, environmentName, isBuild, isBundledDev, isSsrTargetWebworkerSet, preTransformRequests) {
+	const isClientEnvironment = environmentName === "client";
+	const consumer = options.consumer ?? (isClientEnvironment ? "client" : "server");
+	const isSsrTargetWebworkerEnvironment = isSsrTargetWebworkerSet && environmentName === "ssr";
+	const isBundled = options.isBundled ?? (isBuild || isClientEnvironment && isBundledDev);
+	if (options.define?.["process.env"]) {
+		const processEnvDefine = options.define["process.env"];
+		if (typeof processEnvDefine === "object") {
+			const pathKey = Object.entries(processEnvDefine).find(([key, value]) => key.toLowerCase() === "path" && !!value)?.[0];
+			if (pathKey) logger.warnOnce(import_picocolors.default.yellow(`The \`define\` option contains an object with ${JSON.stringify(pathKey)} for "process.env" key. It looks like you may have passed the entire \`process.env\` object to \`define\`, which can unintentionally expose all environment variables. This poses a security risk and is discouraged.`));
+		}
+	}
+	const resolve = resolveEnvironmentResolveOptions(options.resolve, alias, preserveSymlinks, logger, consumer, isSsrTargetWebworkerEnvironment);
+	return {
+		define: options.define,
+		resolve,
+		keepProcessEnv: options.keepProcessEnv ?? (isSsrTargetWebworkerEnvironment ? false : consumer === "server"),
+		consumer,
+		optimizeDeps: resolveDepOptimizationOptions(options.optimizeDeps, resolve.preserveSymlinks, forceOptimizeDeps, consumer, logger),
+		dev: resolveDevEnvironmentOptions(options.dev, environmentName, consumer, preTransformRequests),
+		build: resolveBuildEnvironmentOptions(options.build ?? {}, logger, consumer, isBundled && !isBuild, isSsrTargetWebworkerEnvironment),
+		isBundled,
+		plugins: void 0,
+		optimizeDepsPluginNames: void 0
+	};
+}
+function getDefaultEnvironmentOptions(config) {
+	return {
+		define: config.define,
+		resolve: {
+			...config.resolve,
+			mainFields: void 0,
+			conditions: void 0
+		},
+		dev: config.dev,
+		build: config.build
+	};
+}
+/**
+* Check and warn if `path` includes characters that don't work well in Vite,
+* such as `#` and `?` and `*`.
+*/
+function checkBadCharactersInPath(name, type, path, logger) {
+	const badChars = [];
+	if (path.includes("#")) badChars.push("#");
+	if (path.includes("?")) badChars.push("?");
+	if (path.includes("*")) badChars.push("*");
+	if (badChars.length > 0) {
+		const charString = badChars.map((c) => `"${c}"`).join(" and ");
+		logger.warn(import_picocolors.default.yellow(`${name} contains the ${charString} ${badChars.length > 1 ? "characters" : "character"} (${import_picocolors.default.cyan(path)}), which may not work when running Vite. Consider renaming the ${type} without the characters.`));
+	}
+}
+const clientAlias = [{
+	find: /^\/?@vite\/env/,
+	replacement: path.posix.join(FS_PREFIX, normalizePath(ENV_ENTRY))
+}, {
+	find: /^\/?@vite\/client/,
+	replacement: path.posix.join(FS_PREFIX, normalizePath(CLIENT_ENTRY))
+}];
+/**
+* alias and preserveSymlinks are not per-environment options, but they are
+* included in the resolved environment options for convenience.
+*/
+function resolveEnvironmentResolveOptions(resolve, alias, preserveSymlinks, logger, consumer, isSsrTargetWebworkerEnvironment) {
+	const resolvedResolve = mergeWithDefaults({
+		...configDefaults.resolve,
+		mainFields: consumer === void 0 || consumer === "client" || isSsrTargetWebworkerEnvironment ? DEFAULT_CLIENT_MAIN_FIELDS : DEFAULT_SERVER_MAIN_FIELDS,
+		conditions: consumer === void 0 || consumer === "client" || isSsrTargetWebworkerEnvironment ? DEFAULT_CLIENT_CONDITIONS : DEFAULT_SERVER_CONDITIONS.filter((c) => c !== "browser"),
+		builtins: resolve?.builtins ?? (consumer === "server" ? isSsrTargetWebworkerEnvironment && resolve?.noExternal === true ? [] : nodeLikeBuiltins : [])
+	}, resolve ?? {});
+	resolvedResolve.preserveSymlinks = preserveSymlinks;
+	resolvedResolve.alias = alias;
+	if (resolve?.browserField === false && resolvedResolve.mainFields.includes("browser")) logger.warn(import_picocolors.default.yellow("`resolve.browserField` is set to false, but the option is removed in favour of the 'browser' string in `resolve.mainFields`. You may want to update `resolve.mainFields` to remove the 'browser' string and preserve the previous browser behaviour."));
+	return resolvedResolve;
+}
+function resolveResolveOptions(resolve, logger) {
+	const alias = normalizeAlias(mergeAlias(clientAlias, resolve?.alias || configDefaults.resolve.alias));
+	const preserveSymlinks = resolve?.preserveSymlinks ?? configDefaults.resolve.preserveSymlinks;
+	if (alias.some((a) => a.find === "/")) logger.warn(import_picocolors.default.yellow("`resolve.alias` contains an alias that maps `/`. This is not recommended as it can cause unexpected behavior when resolving paths."));
+	if (alias.some((a) => a.customResolver)) logger.warn(import_picocolors.default.yellow("`resolve.alias` contains an alias with `customResolver` option. This is deprecated and will be removed in Vite 9. Please use a custom plugin with a resolveId hook and `enforce: 'pre'` instead."));
+	return resolveEnvironmentResolveOptions(resolve, alias, preserveSymlinks, logger, void 0);
+}
+function resolveDepOptimizationOptions(optimizeDeps, preserveSymlinks, forceOptimizeDeps, consumer, logger) {
+	if (optimizeDeps?.rolldownOptions && optimizeDeps?.rolldownOptions === optimizeDeps?.rollupOptions) delete optimizeDeps?.rollupOptions;
+	const merged = mergeWithDefaults({
+		...configDefaults.optimizeDeps,
+		disabled: void 0,
+		noDiscovery: consumer !== "client",
+		force: forceOptimizeDeps ?? configDefaults.optimizeDeps.force
+	}, optimizeDeps ?? {});
+	setupRollupOptionCompat(merged, "optimizeDeps");
+	const rolldownOptions = merged.rolldownOptions;
+	if (merged.esbuildOptions && Object.keys(merged.esbuildOptions).length > 0) {
+		logger.warn(import_picocolors.default.yellow("You or a plugin you are using have set `optimizeDeps.esbuildOptions` but this option is now deprecated. Vite now uses Rolldown to optimize the dependencies. Please use `optimizeDeps.rolldownOptions` instead."));
+		rolldownOptions.resolve ??= {};
+		rolldownOptions.output ??= {};
+		rolldownOptions.transform ??= {};
+		const setResolveOptions = (key, value) => {
+			if (value !== void 0 && rolldownOptions.resolve[key] === void 0) rolldownOptions.resolve[key] = value;
+		};
+		if (merged.esbuildOptions.minify !== void 0 && rolldownOptions.output.minify === void 0) rolldownOptions.output.minify = merged.esbuildOptions.minify;
+		if (merged.esbuildOptions.treeShaking !== void 0 && rolldownOptions.treeshake === void 0) rolldownOptions.treeshake = merged.esbuildOptions.treeShaking;
+		if (merged.esbuildOptions.define !== void 0 && rolldownOptions.transform.define === void 0) rolldownOptions.transform.define = merged.esbuildOptions.define;
+		if (merged.esbuildOptions.loader !== void 0) {
+			const loader = merged.esbuildOptions.loader;
+			rolldownOptions.moduleTypes ??= {};
+			for (const [key, value] of Object.entries(loader)) if (rolldownOptions.moduleTypes[key] === void 0 && value !== "copy" && value !== "css" && value !== "default" && value !== "file" && value !== "local-css") rolldownOptions.moduleTypes[key] = value;
+		}
+		if (merged.esbuildOptions.preserveSymlinks !== void 0 && rolldownOptions.resolve.symlinks === void 0) rolldownOptions.resolve.symlinks = !merged.esbuildOptions.preserveSymlinks;
+		setResolveOptions("extensions", merged.esbuildOptions.resolveExtensions);
+		setResolveOptions("mainFields", merged.esbuildOptions.mainFields);
+		setResolveOptions("conditionNames", merged.esbuildOptions.conditions);
+		if (merged.esbuildOptions.keepNames !== void 0 && rolldownOptions.output.keepNames === void 0) rolldownOptions.output.keepNames = merged.esbuildOptions.keepNames;
+		if (merged.esbuildOptions.platform !== void 0 && rolldownOptions.platform === void 0) rolldownOptions.platform = merged.esbuildOptions.platform;
+	}
+	merged.esbuildOptions ??= {};
+	merged.esbuildOptions.preserveSymlinks ??= preserveSymlinks;
+	rolldownOptions.resolve ??= {};
+	rolldownOptions.resolve.symlinks ??= !preserveSymlinks;
+	rolldownOptions.output ??= {};
+	rolldownOptions.output.topLevelVar ??= true;
+	return merged;
+}
+async function setOptimizeDepsPluginNames(resolvedConfig) {
+	await Promise.all(Object.values(resolvedConfig.environments).map(async (environment) => {
+		const flattenedPlugins = await asyncFlatten([environment.optimizeDeps.rolldownOptions?.plugins ?? [], environment.optimizeDeps.rolldownOptions?.output?.plugins ?? []]);
+		const pluginNames = [];
+		for (const plugin of flattenedPlugins) if (plugin && "name" in plugin) pluginNames.push(plugin.name);
+		environment.optimizeDepsPluginNames = pluginNames;
+	}));
+}
+function applyDepOptimizationOptionCompat(resolvedConfig) {
+	if (resolvedConfig.optimizeDeps.esbuildOptions?.plugins && resolvedConfig.optimizeDeps.esbuildOptions.plugins.length > 0) {
+		resolvedConfig.optimizeDeps.rolldownOptions ??= {};
+		resolvedConfig.optimizeDeps.rolldownOptions.plugins ||= [];
+		resolvedConfig.optimizeDeps.rolldownOptions.plugins.push(...resolvedConfig.optimizeDeps.esbuildOptions.plugins.map((plugin) => convertEsbuildPluginToRolldownPlugin(plugin)));
+	}
+}
+function isResolvedConfig(inlineConfig) {
+	return SYMBOL_RESOLVED_CONFIG in inlineConfig && inlineConfig[SYMBOL_RESOLVED_CONFIG];
+}
+async function resolveConfig(inlineConfig, command, defaultMode = "development", defaultNodeEnv = "development", isPreview = false, patchConfig = void 0, patchPlugins = void 0) {
+	let config = inlineConfig;
+	config.build ??= {};
+	setupRollupOptionCompat(config.build, "build");
+	config.worker ??= {};
+	setupRollupOptionCompat(config.worker, "worker");
+	config.optimizeDeps ??= {};
+	setupRollupOptionCompat(config.optimizeDeps, "optimizeDeps");
+	if (config.ssr) {
+		config.ssr.optimizeDeps ??= {};
+		setupRollupOptionCompat(config.ssr.optimizeDeps, "ssr.optimizeDeps");
+	}
+	let configFileDependencies = [];
+	let mode = inlineConfig.mode || defaultMode;
+	const isNodeEnvSet = !!process.env.NODE_ENV;
+	const packageCache = /* @__PURE__ */ new Map();
+	if (!isNodeEnvSet) process.env.NODE_ENV = defaultNodeEnv;
+	const configEnv = {
+		mode,
+		command,
+		isSsrBuild: command === "build" && !!config.build?.ssr,
+		isPreview
+	};
+	let { configFile } = config;
+	if (configFile !== false) {
+		const loadResult = await loadConfigFromFile(configEnv, configFile, config.root, config.logLevel, config.customLogger, config.configLoader);
+		if (loadResult) {
+			config = mergeConfig(loadResult.config, config);
+			configFile = loadResult.path;
+			configFileDependencies = loadResult.dependencies;
+		}
+	}
+	mode = inlineConfig.mode || config.mode || mode;
+	configEnv.mode = mode;
+	const filterPlugin = (p) => {
+		if (!p) return false;
+		else if (!p.apply) return true;
+		else if (typeof p.apply === "function") return p.apply({
+			...config,
+			mode
+		}, configEnv);
+		else return p.apply === command;
+	};
+	const [prePlugins, normalPlugins, postPlugins] = sortUserPlugins((await asyncFlatten(config.plugins || [])).filter(filterPlugin));
+	const isBuild = command === "build";
+	const userPlugins = [
+		...prePlugins,
+		...normalPlugins,
+		...postPlugins
+	];
+	config = await runConfigHook(config, userPlugins, configEnv);
+	config.environments ??= {};
+	if (!config.environments.ssr && (!isBuild || config.ssr || config.build?.ssr)) config.environments = {
+		ssr: {},
+		...config.environments
+	};
+	if (!config.environments.client) config.environments = {
+		client: {},
+		...config.environments
+	};
+	const logger = createLogger(config.logLevel, {
+		allowClearScreen: config.clearScreen,
+		customLogger: config.customLogger
+	});
+	const tsconfigPathsPlugin = userPlugins.find((p) => p.name === "vite-tsconfig-paths" || p.name === "vite-plugin-tsconfig-paths");
+	if (tsconfigPathsPlugin) logger.warnOnce(import_picocolors.default.yellow(`The plugin ${JSON.stringify(tsconfigPathsPlugin.name)} is detected. Vite now supports tsconfig paths resolution natively via the ${import_picocolors.default.bold("resolve.tsconfigPaths")} option. You can remove the plugin and set ${import_picocolors.default.bold("resolve.tsconfigPaths: true")} in your Vite config instead.`));
+	const resolvedRoot = normalizePath(config.root ? path.resolve(config.root) : process.cwd());
+	checkBadCharactersInPath("The project root", "directory", resolvedRoot, logger);
+	const configEnvironmentsClient = config.environments.client;
+	configEnvironmentsClient.dev ??= {};
+	const deprecatedSsrOptimizeDepsConfig = config.ssr?.optimizeDeps ?? {};
+	let configEnvironmentsSsr = config.environments.ssr;
+	const warmupOptions = config.server?.warmup;
+	if (warmupOptions?.clientFiles) configEnvironmentsClient.dev.warmup = warmupOptions.clientFiles;
+	if (warmupOptions?.ssrFiles) {
+		configEnvironmentsSsr ??= {};
+		configEnvironmentsSsr.dev ??= {};
+		configEnvironmentsSsr.dev.warmup = warmupOptions.ssrFiles;
+	}
+	if (configEnvironmentsSsr) {
+		configEnvironmentsSsr.optimizeDeps = mergeConfig(deprecatedSsrOptimizeDepsConfig, configEnvironmentsSsr.optimizeDeps ?? {});
+		configEnvironmentsSsr.resolve = mergeConfig({ resolve: {
+			conditions: config.ssr?.resolve?.conditions,
+			externalConditions: config.ssr?.resolve?.externalConditions,
+			mainFields: config.ssr?.resolve?.mainFields,
+			external: config.ssr?.external,
+			noExternal: config.ssr?.noExternal
+		} }, { resolve: configEnvironmentsSsr.resolve ?? {} }).resolve;
+	}
+	if (config.build?.ssrEmitAssets !== void 0) {
+		configEnvironmentsSsr ??= {};
+		configEnvironmentsSsr.build ??= {};
+		configEnvironmentsSsr.build.emitAssets = config.build.ssrEmitAssets;
+	}
+	if (!config.environments.client || !config.environments.ssr && !isBuild) throw new Error("Required environments configuration were stripped out in the config hook");
+	const defaultEnvironmentOptions = getDefaultEnvironmentOptions(config);
+	const defaultClientEnvironmentOptions = {
+		...defaultEnvironmentOptions,
+		resolve: config.resolve,
+		optimizeDeps: config.optimizeDeps
+	};
+	const defaultNonClientEnvironmentOptions = {
+		...defaultEnvironmentOptions,
+		dev: {
+			...defaultEnvironmentOptions.dev,
+			createEnvironment: void 0,
+			warmup: void 0
+		},
+		build: {
+			...defaultEnvironmentOptions.build,
+			createEnvironment: void 0
+		}
+	};
+	for (const name of Object.keys(config.environments)) config.environments[name] = mergeConfig(name === "client" ? defaultClientEnvironmentOptions : deepClone(defaultNonClientEnvironmentOptions), config.environments[name]);
+	await runConfigEnvironmentHook(config.environments, userPlugins, logger, configEnv, config.ssr?.target === "webworker");
+	const isBundledDev = command === "serve" && !!config.experimental?.bundledDev;
+	config.resolve ??= {};
+	config.resolve.conditions = config.environments.client.resolve?.conditions;
+	config.resolve.mainFields = config.environments.client.resolve?.mainFields;
+	const resolvedDefaultResolve = resolveResolveOptions(config.resolve, logger);
+	const resolvedEnvironments = {};
+	for (const environmentName of Object.keys(config.environments)) resolvedEnvironments[environmentName] = resolveEnvironmentOptions(config.environments[environmentName], resolvedDefaultResolve.alias, resolvedDefaultResolve.preserveSymlinks, inlineConfig.forceOptimizeDeps, logger, environmentName, isBuild, isBundledDev, config.ssr?.target === "webworker", config.server?.preTransformRequests);
+	const backwardCompatibleOptimizeDeps = resolvedEnvironments.client.optimizeDeps;
+	const resolvedDevEnvironmentOptions = resolveDevEnvironmentOptions(config.dev, void 0, void 0);
+	const resolvedBuildOptions = resolveBuildEnvironmentOptions(config.build ?? {}, logger, void 0, isBundledDev);
+	const ssr = resolveSSROptions({
+		...config.ssr,
+		external: resolvedEnvironments.ssr?.resolve.external,
+		noExternal: resolvedEnvironments.ssr?.resolve.noExternal,
+		optimizeDeps: resolvedEnvironments.ssr?.optimizeDeps,
+		resolve: {
+			...config.ssr?.resolve,
+			conditions: resolvedEnvironments.ssr?.resolve.conditions,
+			externalConditions: resolvedEnvironments.ssr?.resolve.externalConditions
+		}
+	}, resolvedDefaultResolve.preserveSymlinks);
+	let envDir = config.envFile === false ? false : config.envDir;
+	if (envDir !== false) envDir = config.envDir ? normalizePath(path.resolve(resolvedRoot, config.envDir)) : resolvedRoot;
+	const userEnv = loadEnv(mode, envDir, resolveEnvPrefix(config));
+	const userNodeEnv = process.env.VITE_USER_NODE_ENV;
+	if (!isNodeEnvSet && userNodeEnv) if (userNodeEnv === "development") process.env.NODE_ENV = "development";
+	else logger.warn(`NODE_ENV=${userNodeEnv} is not supported in the .env file. Only NODE_ENV=development is supported to create a development build of your project. If you need to set process.env.NODE_ENV, you can set it in the Vite config instead.`);
+	const isProduction = process.env.NODE_ENV === "production";
+	const resolvedBase = config.base === "" || config.base === "./" ? !isBuild || config.build?.ssr ? "/" : "./" : resolveBaseUrl(config.base, isBuild, logger);
+	const pkgDir = findNearestPackageData(resolvedRoot, packageCache)?.dir;
+	const cacheDir = normalizePath(config.cacheDir ? path.resolve(resolvedRoot, config.cacheDir) : pkgDir ? path.join(pkgDir, `node_modules/.vite`) : path.join(resolvedRoot, `.vite`));
+	const assetsFilter = config.assetsInclude && (!Array.isArray(config.assetsInclude) || config.assetsInclude.length) ? createFilter$1(config.assetsInclude) : () => false;
+	const { publicDir } = config;
+	const resolvedPublicDir = publicDir !== false && publicDir !== "" ? normalizePath(path.resolve(resolvedRoot, typeof publicDir === "string" ? publicDir : configDefaults.publicDir)) : "";
+	const server = await resolveServerOptions(resolvedRoot, config.server, logger);
+	const builder = resolveBuilderOptions(config.builder);
+	const BASE_URL = resolvedBase;
+	const resolvedConfigContext = new BasicMinimalPluginContext({
+		...basePluginContextMeta,
+		watchMode: command === "serve" && !isPreview || command === "build" && !!resolvedBuildOptions.watch
+	}, logger);
+	let resolved;
+	let createUserWorkerPlugins = config.worker?.plugins;
+	if (Array.isArray(createUserWorkerPlugins)) {
+		createUserWorkerPlugins = () => config.worker?.plugins;
+		logger.warn(import_picocolors.default.yellow("worker.plugins is now a function that returns an array of plugins. Please update your Vite config accordingly.\n"));
+	}
+	const createWorkerPlugins = async function(bundleChain) {
+		const rawWorkerUserPlugins = (await asyncFlatten(createUserWorkerPlugins?.() || [])).filter(filterPlugin);
+		let workerConfig = mergeConfig({}, config);
+		const [workerPrePlugins, workerNormalPlugins, workerPostPlugins] = sortUserPlugins(rawWorkerUserPlugins);
+		const workerUserPlugins = [
+			...workerPrePlugins,
+			...workerNormalPlugins,
+			...workerPostPlugins
+		];
+		workerConfig = await runConfigHook(workerConfig, workerUserPlugins, configEnv);
+		const workerResolved = {
+			...workerConfig,
+			...resolved,
+			isWorker: true,
+			mainConfig: resolved,
+			bundleChain
+		};
+		workerResolved.plugins = await resolvePlugins(workerResolved, workerPrePlugins, workerNormalPlugins, workerPostPlugins);
+		await Promise.all(createPluginHookUtils(workerResolved.plugins).getSortedPluginHooks("configResolved").map((hook) => hook.call(resolvedConfigContext, workerResolved)));
+		workerResolved.environments = {
+			...workerResolved.environments,
+			client: {
+				...workerResolved.environments.client,
+				plugins: await resolveEnvironmentPlugins(new PartialEnvironment("client", workerResolved))
+			}
+		};
+		return workerResolved;
+	};
+	const resolvedWorkerOptions = {
+		format: config.worker?.format || "iife",
+		plugins: createWorkerPlugins,
+		rollupOptions: config.worker?.rollupOptions || {},
+		rolldownOptions: config.worker?.rolldownOptions
+	};
+	setupRollupOptionCompat(resolvedWorkerOptions, "worker");
+	const base = withTrailingSlash(resolvedBase);
+	const preview = resolvePreviewOptions(config.preview, server);
+	const additionalAllowedHosts = getAdditionalAllowedHosts(server, preview);
+	if (Array.isArray(server.allowedHosts)) server.allowedHosts.push(...additionalAllowedHosts);
+	if (Array.isArray(preview.allowedHosts)) preview.allowedHosts.push(...additionalAllowedHosts);
+	let oxc = config.oxc;
+	if (config.esbuild) if (config.oxc) logger.warn(import_picocolors.default.yellow(`Both esbuild and oxc options were set. oxc options will be used and esbuild options will be ignored.`) + ` The following esbuild options were set: \`${inspect(config.esbuild)}\``);
+	else oxc = convertEsbuildConfigToOxcConfig(config.esbuild, logger);
+	else if (config.esbuild === false && config.oxc !== false) logger.warn(import_picocolors.default.yellow("`esbuild` option is set to false, but `oxc` option was not set to false. `esbuild: false` does not have effect any more. If you want to disable the default transformation, which is now handled by Oxc, please set `oxc: false` instead."));
+	const experimental = mergeWithDefaults(configDefaults.experimental, config.experimental ?? {});
+	if (command === "serve" && experimental.bundledDev) experimental.renderBuiltUrl = void 0;
+	const resolvedDevToolsConfig = await resolveDevToolsConfig(config.devtools, server.host, logger);
+	resolved = {
+		configFile: configFile ? normalizePath(configFile) : void 0,
+		configFileDependencies: configFileDependencies.map((name) => normalizePath(path.resolve(name))),
+		inlineConfig,
+		root: resolvedRoot,
+		base,
+		decodedBase: decodeBase(base),
+		rawBase: resolvedBase,
+		publicDir: resolvedPublicDir,
+		cacheDir,
+		command,
+		mode,
+		isWorker: false,
+		mainConfig: null,
+		bundleChain: [],
+		isProduction,
+		plugins: userPlugins,
+		css: resolveCSSOptions(config.css),
+		json: mergeWithDefaults(configDefaults.json, config.json ?? {}),
+		esbuild: config.esbuild === false ? false : {
+			jsxDev: !isProduction,
+			charset: "utf8",
+			legalComments: "none",
+			...config.esbuild
+		},
+		oxc: oxc === false ? false : {
+			...oxc,
+			jsx: typeof oxc?.jsx === "string" ? oxc.jsx : {
+				development: oxc?.jsx?.development ?? !isProduction,
+				...oxc?.jsx
+			}
+		},
+		server,
+		builder,
+		preview,
+		envDir,
+		env: {
+			...userEnv,
+			BASE_URL,
+			MODE: mode,
+			DEV: !isProduction,
+			PROD: isProduction
+		},
+		assetsInclude(file) {
+			return DEFAULT_ASSETS_RE.test(file) || assetsFilter(file);
+		},
+		rawAssetsInclude: config.assetsInclude ? arraify(config.assetsInclude) : [],
+		logger,
+		packageCache,
+		worker: resolvedWorkerOptions,
+		appType: config.appType ?? "spa",
+		experimental,
+		future: config.future === "warn" ? {
+			removePluginHookHandleHotUpdate: "warn",
+			removePluginHookSsrArgument: "warn",
+			removeServerModuleGraph: "warn",
+			removeServerReloadModule: "warn",
+			removeServerPluginContainer: "warn",
+			removeServerHot: "warn",
+			removeServerTransformRequest: "warn",
+			removeServerWarmupRequest: "warn",
+			removeSsrLoadModule: "warn"
+		} : config.future,
+		ssr,
+		optimizeDeps: backwardCompatibleOptimizeDeps,
+		resolve: resolvedDefaultResolve,
+		dev: resolvedDevEnvironmentOptions,
+		build: resolvedBuildOptions,
+		devtools: resolvedDevToolsConfig,
+		environments: resolvedEnvironments,
+		webSocketToken: Buffer.from(crypto.getRandomValues(new Uint8Array(9))).toString("base64url"),
+		getSortedPlugins: void 0,
+		getSortedPluginHooks: void 0,
+		createResolver(options) {
+			const resolve = createIdResolver(this, options);
+			const clientEnvironment = new PartialEnvironment("client", this);
+			let ssrEnvironment;
+			return async (id, importer, aliasOnly, ssr) => {
+				if (ssr) ssrEnvironment ??= new PartialEnvironment("ssr", this);
+				return await resolve(ssr ? ssrEnvironment : clientEnvironment, id, importer, aliasOnly);
+			};
+		},
+		fsDenyGlob: picomatch(server.fs.deny.map((pattern) => pattern.includes("/") ? pattern : `**/${pattern}`), {
+			matchBase: false,
+			nocase: true,
+			dot: true
+		}),
+		safeModulePaths: /* @__PURE__ */ new Set(),
+		[SYMBOL_RESOLVED_CONFIG]: true
+	};
+	resolved = {
+		...config,
+		...resolved
+	};
+	patchConfig?.(resolved);
+	const resolvedPlugins = await resolvePlugins(resolved, prePlugins, normalPlugins, postPlugins);
+	patchPlugins?.(resolvedPlugins);
+	resolved.plugins = resolvedPlugins;
+	Object.assign(resolved, createPluginHookUtils(resolved.plugins));
+	await Promise.all(resolved.getSortedPluginHooks("configResolved").map((hook) => hook.call(resolvedConfigContext, resolved)));
+	for (const name of Object.keys(resolved.environments)) resolved.environments[name].plugins = await resolveEnvironmentPlugins(new PartialEnvironment(name, resolved));
+	optimizeDepsDisabledBackwardCompatibility(resolved, resolved.optimizeDeps);
+	optimizeDepsDisabledBackwardCompatibility(resolved, resolved.ssr.optimizeDeps, "ssr.");
+	if (!resolved.builder?.sharedConfigBuild && resolved.environments.ssr) resolved.environments.ssr.build.emitAssets = resolved.build.ssrEmitAssets || resolved.build.emitAssets;
+	applyDepOptimizationOptionCompat(resolved);
+	await setOptimizeDepsPluginNames(resolved);
+	debug?.(`using resolved config: %O`, {
+		...resolved,
+		plugins: resolved.plugins.map((p) => p.name),
+		worker: {
+			...resolved.worker,
+			plugins: `() => plugins`
+		}
+	});
+	const outputOption = config.build?.rollupOptions?.output ?? [];
+	if (Array.isArray(outputOption)) {
+		const assetFileNamesList = outputOption.map((output) => output.assetFileNames);
+		if (assetFileNamesList.length > 1) {
+			const firstAssetFileNames = assetFileNamesList[0];
+			if (assetFileNamesList.some((assetFileNames) => assetFileNames !== firstAssetFileNames)) resolved.logger.warn(import_picocolors.default.yellow(`
+assetFileNames isn't equal for every build.rolldownOptions.output. A single pattern across all outputs is supported by Vite.
+`));
+		}
+	}
+	if (config.legacy?.buildSsrCjsExternalHeuristics || config.ssr?.format === "cjs") resolved.logger.warn(import_picocolors.default.yellow(`
+(!) Experimental legacy.buildSsrCjsExternalHeuristics and ssr.format were be removed in Vite 5.
+    The only SSR Output format is ESM. Find more information at https://github.com/vitejs/vite/discussions/13816.
+`));
+	const resolvedBuildOutDir = normalizePath(path.resolve(resolved.root, resolved.build.outDir));
+	if (isParentDirectory(resolvedBuildOutDir, resolved.root) || resolvedBuildOutDir === resolved.root) resolved.logger.warn(import_picocolors.default.yellow(`
+(!) build.outDir must not be the same directory of root or a parent directory of root as this could cause Vite to overwriting source files with build outputs.
+`));
+	return resolved;
+}
+/**
+* Resolve base url. Note that some users use Vite to build for non-web targets like
+* electron or expects to deploy
+*/
+function resolveBaseUrl(base = configDefaults.base, isBuild, logger) {
+	if (base[0] === ".") {
+		logger.warn(import_picocolors.default.yellow(import_picocolors.default.bold(`(!) invalid "base" option: "${base}". The value can only be an absolute URL, "./", or an empty string.`)));
+		return "/";
+	}
+	const isExternal = isExternalUrl(base);
+	if (!isExternal && base[0] !== "/") logger.warn(import_picocolors.default.yellow(import_picocolors.default.bold(`(!) "base" option should start with a slash.`)));
+	if (!isBuild || !isExternal) {
+		base = new URL(base, "http://vite.dev").pathname;
+		if (base[0] !== "/") base = "/" + base;
+	}
+	return base;
+}
+function decodeBase(base) {
+	try {
+		return decodeURI(base);
+	} catch {
+		throw new Error("The value passed to \"base\" option was malformed. It should be a valid URL.");
+	}
+}
+function sortUserPlugins(plugins) {
+	const prePlugins = [];
+	const postPlugins = [];
+	const normalPlugins = [];
+	if (plugins) plugins.flat().forEach((p) => {
+		if (p.enforce === "pre") prePlugins.push(p);
+		else if (p.enforce === "post") postPlugins.push(p);
+		else normalPlugins.push(p);
+	});
+	return [
+		prePlugins,
+		normalPlugins,
+		postPlugins
+	];
+}
+async function loadConfigFromFile(configEnv, configFile, configRoot = process.cwd(), logLevel, customLogger, configLoader = "bundle") {
+	if (configLoader !== "bundle" && configLoader !== "runner" && configLoader !== "native") throw new Error(`Unsupported configLoader: ${configLoader}. Accepted values are 'bundle', 'runner', and 'native'.`);
+	const start = performance$1.now();
+	const getTime = () => `${(performance$1.now() - start).toFixed(2)}ms`;
+	let resolvedPath;
+	if (configFile) resolvedPath = path.resolve(configFile);
+	else for (const filename of DEFAULT_CONFIG_FILES) {
+		const filePath = path.resolve(configRoot, filename);
+		if (!fs.existsSync(filePath)) continue;
+		resolvedPath = filePath;
+		break;
+	}
+	if (!resolvedPath) {
+		debug?.("no config file found.");
+		return null;
+	}
+	try {
+		const { configExport, dependencies } = await (configLoader === "bundle" ? bundleAndLoadConfigFile : configLoader === "runner" ? runnerImportConfigFile : nativeImportConfigFile)(resolvedPath);
+		debug?.(`config file loaded in ${getTime()}`);
+		const config = await (typeof configExport === "function" ? configExport(configEnv) : configExport);
+		if (!isObject$1(config)) throw new Error(`config must export or return an object.`);
+		return {
+			path: normalizePath(resolvedPath),
+			config,
+			dependencies
+		};
+	} catch (e) {
+		const logger = createLogger(logLevel, { customLogger });
+		checkBadCharactersInPath("The config path", "file", resolvedPath, logger);
+		logger.error(import_picocolors.default.red(`failed to load config from ${resolvedPath}`), { error: e });
+		throw e;
+	}
+}
+async function nativeImportConfigFile(resolvedPath) {
+	return {
+		configExport: (await import(pathToFileURL(resolvedPath).href + "?t=" + Date.now())).default,
+		dependencies: []
+	};
+}
+async function runnerImportConfigFile(resolvedPath) {
+	const { module, dependencies } = await runnerImport(resolvedPath);
+	return {
+		configExport: module.default,
+		dependencies
+	};
+}
+async function bundleAndLoadConfigFile(resolvedPath) {
+	const isESM = typeof process.versions.deno === "string" || isFilePathESM(resolvedPath);
+	const bundled = await bundleConfigFile(resolvedPath, isESM);
+	return {
+		configExport: await loadConfigFromBundledFile(resolvedPath, bundled.code, isESM),
+		dependencies: bundled.dependencies
+	};
+}
+async function bundleConfigFile(fileName, isESM) {
+	let importMetaResolverRegistered = false;
+	const root = path.dirname(fileName);
+	const dirnameVarName = "__vite_injected_original_dirname";
+	const filenameVarName = "__vite_injected_original_filename";
+	const importMetaUrlVarName = "__vite_injected_original_import_meta_url";
+	const importMetaResolveVarName = "__vite_injected_original_import_meta_resolve";
+	const importMetaResolveRegex = /import\.meta\s*\.\s*resolve/;
+	const bundle = await rolldown({
+		input: fileName,
+		platform: "node",
+		resolve: { mainFields: ["main"] },
+		transform: { define: {
+			__dirname: dirnameVarName,
+			__filename: filenameVarName,
+			"import.meta.url": importMetaUrlVarName,
+			"import.meta.dirname": dirnameVarName,
+			"import.meta.filename": filenameVarName,
+			"import.meta.resolve": importMetaResolveVarName,
+			"import.meta.main": "false"
+		} },
+		treeshake: false,
+		tsconfig: false,
+		plugins: [{
+			name: "externalize-deps",
+			resolveId: {
+				filter: { id: /^[^.#].*/ },
+				handler(id, importer, { kind }) {
+					if (!importer || path.isAbsolute(id) || isNodeBuiltin(id)) return;
+					if (isNodeLikeBuiltin(id) || id.startsWith("npm:")) return {
+						id,
+						external: true
+					};
+					const isImport = isESM || kind === "dynamic-import";
+					let idFsPath;
+					try {
+						idFsPath = nodeResolveWithVite(id, importer, {
+							root,
+							isRequire: !isImport
+						});
+					} catch (e) {
+						if (!isImport) {
+							let canResolveWithImport = false;
+							try {
+								canResolveWithImport = !!nodeResolveWithVite(id, importer, { root });
+							} catch {}
+							if (canResolveWithImport) throw new Error(`Failed to resolve ${JSON.stringify(id)}. This package is ESM only but it was tried to load by \`require\`. See https://vite.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`);
+						}
+						throw e;
+					}
+					if (!idFsPath) return;
+					if (idFsPath.endsWith(".json")) return idFsPath;
+					if (idFsPath && isImport) idFsPath = pathToFileURL(idFsPath).href;
+					return {
+						id: idFsPath,
+						external: true
+					};
+				}
+			}
+		}, {
+			name: "inject-file-scope-variables",
+			transform: {
+				filter: { id: /\.[cm]?[jt]s$/ },
+				handler(code, id) {
+					let injectValues = `const ${dirnameVarName} = ${JSON.stringify(path.dirname(id))};const ${filenameVarName} = ${JSON.stringify(id)};const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(id).href)};`;
+					if (importMetaResolveRegex.test(code)) if (isESM) {
+						if (!importMetaResolverRegistered) {
+							importMetaResolverRegistered = true;
+							createImportMetaResolver();
+						}
+						injectValues += `const ${importMetaResolveVarName} = (specifier, importer = ${importMetaUrlVarName}) => (${importMetaResolveWithCustomHookString})(specifier, importer);`;
+					} else injectValues += `const ${importMetaResolveVarName} = (specifier, importer = ${importMetaUrlVarName}) => { throw new Error('import.meta.resolve is not supported in CJS config files') };`;
+					let injectedContents;
+					if (code.startsWith("#!")) {
+						let firstLineEndIndex = code.indexOf("\n");
+						if (firstLineEndIndex < 0) firstLineEndIndex = code.length;
+						injectedContents = code.slice(0, firstLineEndIndex + 1) + injectValues + code.slice(firstLineEndIndex + 1);
+					} else injectedContents = injectValues + code;
+					return {
+						code: injectedContents,
+						map: null
+					};
+				}
+			}
+		}]
+	});
+	const result = await bundle.generate({
+		format: isESM ? "esm" : "cjs",
+		sourcemap: "inline",
+		sourcemapPathTransform(relative) {
+			return path.resolve(fileName, relative);
+		},
+		codeSplitting: false
+	});
+	await bundle.close();
+	const entryChunk = result.output.find((chunk) => chunk.type === "chunk" && chunk.isEntry);
+	const bundleChunks = Object.fromEntries(result.output.flatMap((c) => c.type === "chunk" ? [[c.fileName, c]] : []));
+	const allModules = /* @__PURE__ */ new Set();
+	collectAllModules(bundleChunks, entryChunk.fileName, allModules);
+	return {
+		code: entryChunk.code,
+		dependencies: [...allModules].filter((m) => !m.startsWith("\0"))
+	};
+}
+function collectAllModules(bundle, fileName, allModules, analyzedModules = /* @__PURE__ */ new Set()) {
+	if (analyzedModules.has(fileName)) return;
+	analyzedModules.add(fileName);
+	const chunk = bundle[fileName];
+	for (const mod of chunk.moduleIds) allModules.add(mod);
+	for (const i of chunk.imports) {
+		analyzedModules.add(i);
+		collectAllModules(bundle, i, allModules, analyzedModules);
+	}
+	for (const i of chunk.dynamicImports) {
+		analyzedModules.add(i);
+		collectAllModules(bundle, i, allModules, analyzedModules);
+	}
+}
+const _require = createRequire(
+	/** #__KEEP__ */
+	import.meta.url
+);
+async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
+	if (isESM) {
+		let nodeModulesDir = typeof process.versions.deno === "string" ? void 0 : findNearestNodeModules(path.dirname(fileName));
+		if (nodeModulesDir) try {
+			await fsp.mkdir(path.resolve(nodeModulesDir, ".vite-temp/"), { recursive: true });
+		} catch (e) {
+			if (e.code === "EACCES") nodeModulesDir = void 0;
+			else throw e;
+		}
+		const hash = `timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+		const tempFileName = nodeModulesDir ? path.resolve(nodeModulesDir, `.vite-temp/${path.basename(fileName)}.${hash}.mjs`) : `${fileName}.${hash}.mjs`;
+		await fsp.writeFile(tempFileName, bundledCode);
+		try {
+			return (await import(pathToFileURL(tempFileName).href)).default;
+		} finally {
+			fs.unlink(tempFileName, () => {});
+		}
+	} else {
+		const extension = path.extname(fileName);
+		const realFileName = await promisifiedRealpath(fileName);
+		const loaderExt = extension in _require.extensions ? extension : ".js";
+		const defaultLoader = _require.extensions[loaderExt];
+		_require.extensions[loaderExt] = (module, filename) => {
+			if (filename === realFileName) module._compile(bundledCode, filename);
+			else defaultLoader(module, filename);
+		};
+		delete _require.cache[_require.resolve(fileName)];
+		const raw = _require(fileName);
+		_require.extensions[loaderExt] = defaultLoader;
+		return raw.__esModule ? raw.default : raw;
+	}
+}
+async function runConfigHook(config, plugins, configEnv) {
+	let conf = config;
+	const context = new BasicMinimalPluginContext(basePluginContextMeta, createLogger(config.logLevel, {
+		allowClearScreen: config.clearScreen,
+		customLogger: config.customLogger
+	}));
+	for (const p of getSortedPluginsByHook("config", plugins)) {
+		const hook = p.config;
+		const res = await getHookHandler(hook).call(context, conf, configEnv);
+		if (res && res !== conf) {
+			if (hasBothRollupOptionsAndRolldownOptions(res)) context.warn(`Both \`rollupOptions\` and \`rolldownOptions\` were specified by ${JSON.stringify(p.name)} plugin. \`rollupOptions\` specified by that plugin will be ignored.`);
+			if (res.esbuild) context.warn(`\`esbuild\` option was specified by ${JSON.stringify(p.name)} plugin. This option is deprecated, please use \`oxc\` instead.`);
+			if (res.optimizeDeps?.esbuildOptions) context.warn(`\`optimizeDeps.esbuildOptions\` option was specified by ${JSON.stringify(p.name)} plugin. This option is deprecated, please use \`optimizeDeps.rolldownOptions\` instead.`);
+			conf = mergeConfig(conf, res);
+		}
+	}
+	return conf;
+}
+async function runConfigEnvironmentHook(environments, plugins, logger, configEnv, isSsrTargetWebworkerSet) {
+	const context = new BasicMinimalPluginContext(basePluginContextMeta, logger);
+	const environmentNames = Object.keys(environments);
+	for (const p of getSortedPluginsByHook("configEnvironment", plugins)) {
+		const hook = p.configEnvironment;
+		const handler = getHookHandler(hook);
+		for (const name of environmentNames) {
+			const res = await handler.call(context, name, environments[name], {
+				...configEnv,
+				isSsrTargetWebworker: isSsrTargetWebworkerSet && name === "ssr"
+			});
+			if (res) environments[name] = mergeConfig(environments[name], res);
+		}
+	}
+}
+function optimizeDepsDisabledBackwardCompatibility(resolved, optimizeDeps, optimizeDepsPath = "") {
+	const optimizeDepsDisabled = optimizeDeps.disabled;
+	if (optimizeDepsDisabled !== void 0) {
+		if (optimizeDepsDisabled === true || optimizeDepsDisabled === "dev") {
+			const commonjsOptionsInclude = resolved.build.commonjsOptions.include;
+			const commonjsPluginDisabled = Array.isArray(commonjsOptionsInclude) && commonjsOptionsInclude.length === 0;
+			optimizeDeps.noDiscovery = true;
+			optimizeDeps.include = void 0;
+			if (commonjsPluginDisabled) resolved.build.commonjsOptions.include = void 0;
+			resolved.logger.warn(import_picocolors.default.yellow(`(!) Experimental ${optimizeDepsPath}optimizeDeps.disabled and deps pre-bundling during build were removed in Vite 5.1.
+    To disable the deps optimizer, set ${optimizeDepsPath}optimizeDeps.noDiscovery to true and ${optimizeDepsPath}optimizeDeps.include as undefined or empty.
+    Please remove ${optimizeDepsPath}optimizeDeps.disabled from your config.
+    ${commonjsPluginDisabled ? "Empty config.build.commonjsOptions.include will be ignored to support CJS during build. This config should also be removed." : ""}
+  `));
+		} else if (optimizeDepsDisabled === false || optimizeDepsDisabled === "build") resolved.logger.warn(import_picocolors.default.yellow(`(!) Experimental ${optimizeDepsPath}optimizeDeps.disabled and deps pre-bundling during build were removed in Vite 5.1.
+    Setting it to ${optimizeDepsDisabled} now has no effect.
+    Please remove ${optimizeDepsPath}optimizeDeps.disabled from your config.
+  `));
+	}
+}
+//#endregion
+//#region src/node/server/environments/fetchableEnvironments.ts
+function createFetchableDevEnvironment(name, config, context) {
+	if (typeof Request === "undefined" || typeof Response === "undefined") throw new TypeError("FetchableDevEnvironment requires a global `Request` and `Response` object.");
+	if (!context.handleRequest) throw new TypeError("FetchableDevEnvironment requires a `handleRequest` method during initialisation.");
+	return new FetchableDevEnvironment(name, config, context);
+}
+function isFetchableDevEnvironment(environment) {
+	return environment instanceof FetchableDevEnvironment;
+}
+var FetchableDevEnvironment = class extends DevEnvironment {
+	_handleRequest;
+	constructor(name, config, context) {
+		super(name, config, context);
+		this._handleRequest = context.handleRequest;
+	}
+	async dispatchFetch(request) {
+		if (!(request instanceof Request)) throw new TypeError("FetchableDevEnvironment `dispatchFetch` must receive a `Request` object.");
+		const response = await this._handleRequest(request);
+		if (!(response instanceof Response)) throw new TypeError("FetchableDevEnvironment `context.handleRequest` must return a `Response` object.");
+		return response;
+	}
+};
+//#endregion
+//#region src/node/index.ts
+/** @deprecated - use `parse` instead */
+const parseAst$1 = parseAst;
+/** @deprecated - use `parseAsync` instead */
+const parseAstAsync$1 = parseAstAsync;
+const esbuildVersion = "0.25.0";
+//#endregion
+export { mergeConfig as $, server_exports as A, perEnvironmentState as B, build as C, optimizer_exports as D, optimizeDeps as E, fetchModule as F, loadEnv as G, createServerModuleRunner as H, formatPostcssSourceMap as I, transformWithEsbuild as J, resolveEnvPrefix as K, preprocessCSS as L, send as M, isFileLoadingAllowed as N, createServerHotChannel as O, isFileServingAllowed as P, mergeAlias as Q, searchForWorkspaceRoot as R, BuildEnvironment as S, createBuilder as T, createServerModuleRunnerTransport as U, ssrTransform as V, buildErrorMessage as W, createFilter$1 as X, perEnvironmentPlugin as Y, isCSSRequest as Z, runnerImport as _, minifySync as a, createRunnableDevEnvironment as b, parseAstAsync$1 as c, isFetchableDevEnvironment as d, normalizePath as et, config_exports as f, sortUserPlugins as g, resolveConfig as h, minify as i, DevEnvironment as j, createServer$2 as k, parseSync as l, loadConfigFromFile as m, esbuildVersion as n, rollupVersion as nt, parse as o, defineConfig as p, transformWithOxc as q, esmExternalRequirePlugin$1 as r, withFilter as rt, parseAst$1 as s, Visitor as t, rolldownVersion as tt, createFetchableDevEnvironment as u, preview as v, build_exports as w, isRunnableDevEnvironment as x, preview_exports as y, createIdResolver as z };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/postcss-import.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/postcss-import.js
new file mode 100644
index 0000000..c2d45e8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/chunks/postcss-import.js
@@ -0,0 +1,467 @@
+import { H as __require, z as __commonJSMin } from "./logger.js";
+import { t as require_lib } from "./lib.js";
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/lib/format-import-prelude.js
+var require_format_import_prelude = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function formatImportPrelude(layer, media, supports) {
+		const parts = [];
+		if (typeof layer !== "undefined") {
+			let layerParams = "layer";
+			if (layer) layerParams = `layer(${layer})`;
+			parts.push(layerParams);
+		}
+		if (typeof supports !== "undefined") parts.push(`supports(${supports})`);
+		if (typeof media !== "undefined") parts.push(media);
+		return parts.join(" ");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/lib/base64-encoded-import.js
+var require_base64_encoded_import = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const formatImportPrelude = require_format_import_prelude();
+	module.exports = function base64EncodedConditionalImport(prelude, conditions) {
+		if (!conditions?.length) return prelude;
+		conditions.reverse();
+		const first = conditions.pop();
+		let params = `${prelude} ${formatImportPrelude(first.layer, first.media, first.supports)}`;
+		for (const condition of conditions) params = `'data:text/css;base64,${Buffer.from(`@import ${params}`).toString("base64")}' ${formatImportPrelude(condition.layer, condition.media, condition.supports)}`;
+		return params;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/lib/apply-conditions.js
+var require_apply_conditions = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const base64EncodedConditionalImport = require_base64_encoded_import();
+	module.exports = function applyConditions(bundle, atRule) {
+		const firstImportStatementIndex = bundle.findIndex((stmt) => stmt.type === "import");
+		const lastImportStatementIndex = bundle.findLastIndex((stmt) => stmt.type === "import");
+		bundle.forEach((stmt, index) => {
+			if (stmt.type === "charset" || stmt.type === "warning") return;
+			if (stmt.type === "layer" && (index < lastImportStatementIndex && stmt.conditions?.length || index > firstImportStatementIndex && index < lastImportStatementIndex)) {
+				stmt.type = "import";
+				stmt.node = stmt.node.clone({
+					name: "import",
+					params: base64EncodedConditionalImport(`'data:text/css;base64,${Buffer.from(stmt.node.toString()).toString("base64")}'`, stmt.conditions)
+				});
+				return;
+			}
+			if (!stmt.conditions?.length) return;
+			if (stmt.type === "import") {
+				stmt.node.params = base64EncodedConditionalImport(stmt.fullUri, stmt.conditions);
+				return;
+			}
+			let nodes;
+			let parent;
+			if (stmt.type === "layer") {
+				nodes = [stmt.node];
+				parent = stmt.node.parent;
+			} else {
+				nodes = stmt.nodes;
+				parent = nodes[0].parent;
+			}
+			const atRules = [];
+			for (const condition of stmt.conditions) {
+				if (typeof condition.media !== "undefined") {
+					const mediaNode = atRule({
+						name: "media",
+						params: condition.media,
+						source: parent.source
+					});
+					atRules.push(mediaNode);
+				}
+				if (typeof condition.supports !== "undefined") {
+					const supportsNode = atRule({
+						name: "supports",
+						params: `(${condition.supports})`,
+						source: parent.source
+					});
+					atRules.push(supportsNode);
+				}
+				if (typeof condition.layer !== "undefined") {
+					const layerNode = atRule({
+						name: "layer",
+						params: condition.layer,
+						source: parent.source
+					});
+					atRules.push(layerNode);
+				}
+			}
+			const outerAtRule = atRules.shift();
+			const innerAtRule = atRules.reduce((previous, next) => {
+				previous.append(next);
+				return next;
+			}, outerAtRule);
+			parent.insertBefore(nodes[0], outerAtRule);
+			nodes.forEach((node) => {
+				node.parent = void 0;
+			});
+			nodes[0].raws.before = nodes[0].raws.before || "\n";
+			innerAtRule.append(nodes);
+			stmt.type = "nodes";
+			stmt.nodes = [outerAtRule];
+			delete stmt.node;
+		});
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/lib/apply-raws.js
+var require_apply_raws = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function applyRaws(bundle) {
+		bundle.forEach((stmt, index) => {
+			if (index === 0) return;
+			if (stmt.parent) {
+				const { before } = stmt.parent.node.raws;
+				if (stmt.type === "nodes") stmt.nodes[0].raws.before = before;
+				else stmt.node.raws.before = before;
+			} else if (stmt.type === "nodes") stmt.nodes[0].raws.before = stmt.nodes[0].raws.before || "\n";
+		});
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/lib/apply-styles.js
+var require_apply_styles = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function applyStyles(bundle, styles) {
+		styles.nodes = [];
+		bundle.forEach((stmt) => {
+			if ([
+				"charset",
+				"import",
+				"layer"
+			].includes(stmt.type)) {
+				stmt.node.parent = void 0;
+				styles.append(stmt.node);
+			} else if (stmt.type === "nodes") stmt.nodes.forEach((node) => {
+				node.parent = void 0;
+				styles.append(node);
+			});
+		});
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/lib/data-url.js
+var require_data_url = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const anyDataURLRegexp = /^data:text\/css(?:;(base64|plain))?,/i;
+	const base64DataURLRegexp = /^data:text\/css;base64,/i;
+	const plainDataURLRegexp = /^data:text\/css;plain,/i;
+	function isValid(url) {
+		return anyDataURLRegexp.test(url);
+	}
+	function contents(url) {
+		if (base64DataURLRegexp.test(url)) return Buffer.from(url.slice(21), "base64").toString();
+		if (plainDataURLRegexp.test(url)) return decodeURIComponent(url.slice(20));
+		return decodeURIComponent(url.slice(14));
+	}
+	module.exports = {
+		isValid,
+		contents
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/lib/parse-statements.js
+var require_parse_statements = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const valueParser = require_lib();
+	const { stringify } = valueParser;
+	module.exports = function parseStatements(result, styles, conditions, from) {
+		const statements = [];
+		let nodes = [];
+		let encounteredNonImportNodes = false;
+		styles.each((node) => {
+			let stmt;
+			if (node.type === "atrule") {
+				if (node.name === "import") stmt = parseImport(result, node, conditions, from);
+				else if (node.name === "charset") stmt = parseCharset(result, node, conditions, from);
+				else if (node.name === "layer" && !encounteredNonImportNodes && !node.nodes) stmt = parseLayer(result, node, conditions, from);
+			} else if (node.type !== "comment") encounteredNonImportNodes = true;
+			if (stmt) {
+				if (nodes.length) {
+					statements.push({
+						type: "nodes",
+						nodes,
+						conditions: [...conditions],
+						from
+					});
+					nodes = [];
+				}
+				statements.push(stmt);
+			} else nodes.push(node);
+		});
+		if (nodes.length) statements.push({
+			type: "nodes",
+			nodes,
+			conditions: [...conditions],
+			from
+		});
+		return statements;
+	};
+	function parseCharset(result, atRule, conditions, from) {
+		if (atRule.prev()) return result.warn("@charset must precede all other statements", { node: atRule });
+		return {
+			type: "charset",
+			node: atRule,
+			conditions: [...conditions],
+			from
+		};
+	}
+	function parseImport(result, atRule, conditions, from) {
+		let prev = atRule.prev();
+		if (prev) do {
+			if (prev.type === "comment" || prev.type === "atrule" && prev.name === "import") {
+				prev = prev.prev();
+				continue;
+			}
+			break;
+		} while (prev);
+		if (prev) do {
+			if (prev.type === "comment" || prev.type === "atrule" && (prev.name === "charset" || prev.name === "layer" && !prev.nodes)) {
+				prev = prev.prev();
+				continue;
+			}
+			return result.warn("@import must precede all other statements (besides @charset or empty @layer)", { node: atRule });
+		} while (prev);
+		if (atRule.nodes) return result.warn("It looks like you didn't end your @import statement correctly. Child nodes are attached to it.", { node: atRule });
+		const params = valueParser(atRule.params).nodes;
+		const stmt = {
+			type: "import",
+			uri: "",
+			fullUri: "",
+			node: atRule,
+			conditions: [...conditions],
+			from
+		};
+		let layer;
+		let media;
+		let supports;
+		for (let i = 0; i < params.length; i++) {
+			const node = params[i];
+			if (node.type === "space" || node.type === "comment") continue;
+			if (node.type === "string") {
+				if (stmt.uri) return result.warn(`Multiple url's in '${atRule.toString()}'`, { node: atRule });
+				if (!node.value) return result.warn(`Unable to find uri in '${atRule.toString()}'`, { node: atRule });
+				stmt.uri = node.value;
+				stmt.fullUri = stringify(node);
+				continue;
+			}
+			if (node.type === "function" && /^url$/i.test(node.value)) {
+				if (stmt.uri) return result.warn(`Multiple url's in '${atRule.toString()}'`, { node: atRule });
+				if (!node.nodes?.[0]?.value) return result.warn(`Unable to find uri in '${atRule.toString()}'`, { node: atRule });
+				stmt.uri = node.nodes[0].value;
+				stmt.fullUri = stringify(node);
+				continue;
+			}
+			if (!stmt.uri) return result.warn(`Unable to find uri in '${atRule.toString()}'`, { node: atRule });
+			if ((node.type === "word" || node.type === "function") && /^layer$/i.test(node.value)) {
+				if (typeof layer !== "undefined") return result.warn(`Multiple layers in '${atRule.toString()}'`, { node: atRule });
+				if (typeof supports !== "undefined") return result.warn(`layers must be defined before support conditions in '${atRule.toString()}'`, { node: atRule });
+				if (node.nodes) layer = stringify(node.nodes);
+				else layer = "";
+				continue;
+			}
+			if (node.type === "function" && /^supports$/i.test(node.value)) {
+				if (typeof supports !== "undefined") return result.warn(`Multiple support conditions in '${atRule.toString()}'`, { node: atRule });
+				supports = stringify(node.nodes);
+				continue;
+			}
+			media = stringify(params.slice(i));
+			break;
+		}
+		if (!stmt.uri) return result.warn(`Unable to find uri in '${atRule.toString()}'`, { node: atRule });
+		if (typeof media !== "undefined" || typeof layer !== "undefined" || typeof supports !== "undefined") stmt.conditions.push({
+			layer,
+			media,
+			supports
+		});
+		return stmt;
+	}
+	function parseLayer(result, atRule, conditions, from) {
+		return {
+			type: "layer",
+			node: atRule,
+			conditions: [...conditions],
+			from
+		};
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/lib/process-content.js
+var require_process_content = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$2 = __require("path");
+	let sugarss;
+	module.exports = function processContent(result, content, filename, options, postcss) {
+		const { plugins } = options;
+		const ext = path$2.extname(filename);
+		const parserList = [];
+		if (ext === ".sss") {
+			if (!sugarss)
+ /* c8 ignore next 3 */
+			try {
+				sugarss = __require("sugarss");
+			} catch {}
+			if (sugarss) return runPostcss(postcss, content, filename, plugins, [sugarss]);
+		}
+		if (result.opts.syntax?.parse) parserList.push(result.opts.syntax.parse);
+		if (result.opts.parser) parserList.push(result.opts.parser);
+		parserList.push(null);
+		return runPostcss(postcss, content, filename, plugins, parserList);
+	};
+	function runPostcss(postcss, content, filename, plugins, parsers, index) {
+		if (!index) index = 0;
+		return postcss(plugins).process(content, {
+			from: filename,
+			parser: parsers[index]
+		}).catch((err) => {
+			index++;
+			if (index === parsers.length) throw err;
+			return runPostcss(postcss, content, filename, plugins, parsers, index);
+		});
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/lib/parse-styles.js
+var require_parse_styles = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$1 = __require("path");
+	const dataURL = require_data_url();
+	const parseStatements = require_parse_statements();
+	const processContent = require_process_content();
+	const resolveId = (id) => id;
+	const formatImportPrelude = require_format_import_prelude();
+	async function parseStyles(result, styles, options, state, conditions, from, postcss) {
+		const statements = parseStatements(result, styles, conditions, from);
+		for (const stmt of statements) {
+			if (stmt.type !== "import" || !isProcessableURL(stmt.uri)) continue;
+			if (options.filter && !options.filter(stmt.uri)) continue;
+			await resolveImportId(result, stmt, options, state, postcss);
+		}
+		let charset;
+		const beforeBundle = [];
+		const bundle = [];
+		function handleCharset(stmt) {
+			if (!charset) charset = stmt;
+			else if (stmt.node.params.toLowerCase() !== charset.node.params.toLowerCase()) throw stmt.node.error(`Incompatible @charset statements:
+  ${stmt.node.params} specified in ${stmt.node.source.input.file}
+  ${charset.node.params} specified in ${charset.node.source.input.file}`);
+		}
+		statements.forEach((stmt) => {
+			if (stmt.type === "charset") handleCharset(stmt);
+			else if (stmt.type === "import") if (stmt.children) stmt.children.forEach((child, index) => {
+				if (child.type === "import") beforeBundle.push(child);
+				else if (child.type === "layer") beforeBundle.push(child);
+				else if (child.type === "charset") handleCharset(child);
+				else bundle.push(child);
+				if (index === 0) child.parent = stmt;
+			});
+			else beforeBundle.push(stmt);
+			else if (stmt.type === "layer") beforeBundle.push(stmt);
+			else if (stmt.type === "nodes") bundle.push(stmt);
+		});
+		return charset ? [charset, ...beforeBundle.concat(bundle)] : beforeBundle.concat(bundle);
+	}
+	async function resolveImportId(result, stmt, options, state, postcss) {
+		if (dataURL.isValid(stmt.uri)) {
+			stmt.children = await loadImportContent(result, stmt, stmt.uri, options, state, postcss);
+			return;
+		} else if (dataURL.isValid(stmt.from.slice(-1))) throw stmt.node.error(`Unable to import '${stmt.uri}' from a stylesheet that is embedded in a data url`);
+		const atRule = stmt.node;
+		let sourceFile;
+		if (atRule.source?.input?.file) sourceFile = atRule.source.input.file;
+		const base = sourceFile ? path$1.dirname(atRule.source.input.file) : options.root;
+		const paths = [await options.resolve(stmt.uri, base, options, atRule)].flat();
+		const resolved = await Promise.all(paths.map((file) => {
+			return !path$1.isAbsolute(file) ? resolveId(file, base, options, atRule) : file;
+		}));
+		resolved.forEach((file) => {
+			result.messages.push({
+				type: "dependency",
+				plugin: "postcss-import",
+				file,
+				parent: sourceFile
+			});
+		});
+		stmt.children = (await Promise.all(resolved.map((file) => {
+			return loadImportContent(result, stmt, file, options, state, postcss);
+		}))).flat().filter((x) => !!x);
+	}
+	async function loadImportContent(result, stmt, filename, options, state, postcss) {
+		const atRule = stmt.node;
+		const { conditions, from } = stmt;
+		const stmtDuplicateCheckKey = conditions.map((condition) => formatImportPrelude(condition.layer, condition.media, condition.supports)).join(":");
+		if (options.skipDuplicates) {
+			if (state.importedFiles[filename]?.[stmtDuplicateCheckKey]) return;
+			if (!state.importedFiles[filename]) state.importedFiles[filename] = {};
+			state.importedFiles[filename][stmtDuplicateCheckKey] = true;
+		}
+		if (from.includes(filename)) return;
+		const content = await options.load(filename, options);
+		if (content.trim() === "" && options.warnOnEmpty) {
+			result.warn(`${filename} is empty`, { node: atRule });
+			return;
+		}
+		if (options.skipDuplicates && state.hashFiles[content]?.[stmtDuplicateCheckKey]) return;
+		const importedResult = await processContent(result, content, filename, options, postcss);
+		const styles = importedResult.root;
+		result.messages = result.messages.concat(importedResult.messages);
+		if (options.skipDuplicates) {
+			if (!styles.some((child) => {
+				return child.type === "atrule" && child.name === "import";
+			})) {
+				if (!state.hashFiles[content]) state.hashFiles[content] = {};
+				state.hashFiles[content][stmtDuplicateCheckKey] = true;
+			}
+		}
+		return parseStyles(result, styles, options, state, conditions, [...from, filename], postcss);
+	}
+	function isProcessableURL(uri) {
+		if (/^(?:[a-z]+:)?\/\//i.test(uri)) return false;
+		try {
+			if (new URL(uri, "https://example.com").search) return false;
+		} catch {}
+		return true;
+	}
+	module.exports = parseStyles;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-import@16.1.1_postcss@8.5.14/node_modules/postcss-import/index.js
+var require_postcss_import = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const applyConditions = require_apply_conditions();
+	const applyRaws = require_apply_raws();
+	const applyStyles = require_apply_styles();
+	const loadContent = () => "";
+	const parseStyles = require_parse_styles();
+	const resolveId = (id) => id;
+	function AtImport(options) {
+		options = {
+			root: process.cwd(),
+			path: [],
+			skipDuplicates: true,
+			resolve: resolveId,
+			load: loadContent,
+			plugins: [],
+			addModulesDirectories: [],
+			warnOnEmpty: true,
+			...options
+		};
+		options.root = path.resolve(options.root);
+		if (typeof options.path === "string") options.path = [options.path];
+		if (!Array.isArray(options.path)) options.path = [];
+		options.path = options.path.map((p) => path.resolve(options.root, p));
+		return {
+			postcssPlugin: "postcss-import",
+			async Once(styles, { result, atRule, postcss }) {
+				const state = {
+					importedFiles: {},
+					hashFiles: {}
+				};
+				if (styles.source?.input?.file) state.importedFiles[styles.source.input.file] = {};
+				if (options.plugins && !Array.isArray(options.plugins)) throw new Error("plugins option must be an array");
+				const bundle = await parseStyles(result, styles, options, state, [], [], postcss);
+				applyRaws(bundle);
+				applyConditions(bundle, atRule);
+				applyStyles(bundle, styles);
+			}
+		};
+	}
+	AtImport.postcss = true;
+	module.exports = AtImport;
+}));
+//#endregion
+export default require_postcss_import();
+export {};
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/cli.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/cli.js
new file mode 100644
index 0000000..261a622
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/cli.js
@@ -0,0 +1,836 @@
+import { N as VERSION, R as require_picocolors, W as __toESM, n as createLogger } from "./chunks/logger.js";
+import fs from "node:fs";
+import path from "node:path";
+import { inspect } from "node:util";
+import { performance } from "node:perf_hooks";
+//#region ../../node_modules/.pnpm/cac@7.0.0/node_modules/cac/dist/index.js
+function toArr(any) {
+	return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+	var x, old = out[key], nxt = !!~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : !!~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+	out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function lib_default(args, opts) {
+	args = args || [];
+	opts = opts || {};
+	var k, arr, arg, name, val, out = { _: [] };
+	var i = 0, j = 0, idx = 0, len = args.length;
+	const alibi = opts.alias !== void 0;
+	const strict = opts.unknown !== void 0;
+	const defaults = opts.default !== void 0;
+	opts.alias = opts.alias || {};
+	opts.string = toArr(opts.string);
+	opts.boolean = toArr(opts.boolean);
+	if (alibi) for (k in opts.alias) {
+		arr = opts.alias[k] = toArr(opts.alias[k]);
+		for (i = 0; i < arr.length; i++) (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+	}
+	for (i = opts.boolean.length; i-- > 0;) {
+		arr = opts.alias[opts.boolean[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.boolean.push(arr[j]);
+	}
+	for (i = opts.string.length; i-- > 0;) {
+		arr = opts.alias[opts.string[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.string.push(arr[j]);
+	}
+	if (defaults) for (k in opts.default) {
+		name = typeof opts.default[k];
+		arr = opts.alias[k] = opts.alias[k] || [];
+		if (opts[name] !== void 0) {
+			opts[name].push(k);
+			for (i = 0; i < arr.length; i++) opts[name].push(arr[i]);
+		}
+	}
+	const keys = strict ? Object.keys(opts.alias) : [];
+	for (i = 0; i < len; i++) {
+		arg = args[i];
+		if (arg === "--") {
+			out._ = out._.concat(args.slice(++i));
+			break;
+		}
+		for (j = 0; j < arg.length; j++) if (arg.charCodeAt(j) !== 45) break;
+		if (j === 0) out._.push(arg);
+		else if (arg.substring(j, j + 3) === "no-") {
+			name = arg.substring(j + 3);
+			if (strict && !~keys.indexOf(name)) return opts.unknown(arg);
+			out[name] = false;
+		} else {
+			for (idx = j + 1; idx < arg.length; idx++) if (arg.charCodeAt(idx) === 61) break;
+			name = arg.substring(j, idx);
+			val = arg.substring(++idx) || i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
+			arr = j === 2 ? [name] : name;
+			for (idx = 0; idx < arr.length; idx++) {
+				name = arr[idx];
+				if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+				toVal(out, name, idx + 1 < arr.length || val, opts);
+			}
+		}
+	}
+	if (defaults) {
+		for (k in opts.default) if (out[k] === void 0) out[k] = opts.default[k];
+	}
+	if (alibi) for (k in out) {
+		arr = opts.alias[k] || [];
+		while (arr.length > 0) out[arr.shift()] = out[k];
+	}
+	return out;
+}
+function removeBrackets(v) {
+	return v.replace(/[<[].+/, "").trim();
+}
+function findAllBrackets(v) {
+	const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+	const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+	const res = [];
+	const parse = (match) => {
+		let variadic = false;
+		let value = match[1];
+		if (value.startsWith("...")) {
+			value = value.slice(3);
+			variadic = true;
+		}
+		return {
+			required: match[0].startsWith("<"),
+			value,
+			variadic
+		};
+	};
+	let angledMatch;
+	while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) res.push(parse(angledMatch));
+	let squareMatch;
+	while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) res.push(parse(squareMatch));
+	return res;
+}
+function getMriOptions(options) {
+	const result = {
+		alias: {},
+		boolean: []
+	};
+	for (const [index, option] of options.entries()) {
+		if (option.names.length > 1) result.alias[option.names[0]] = option.names.slice(1);
+		if (option.isBoolean) if (option.negated) {
+			if (!options.some((o, i) => {
+				return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+			})) result.boolean.push(option.names[0]);
+		} else result.boolean.push(option.names[0]);
+	}
+	return result;
+}
+function findLongest(arr) {
+	return arr.sort((a, b) => {
+		return a.length > b.length ? -1 : 1;
+	})[0];
+}
+function padRight(str, length) {
+	return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+}
+function camelcase(input) {
+	return input.replaceAll(/([a-z])-([a-z])/g, (_, p1, p2) => {
+		return p1 + p2.toUpperCase();
+	});
+}
+function setDotProp(obj, keys, val) {
+	let current = obj;
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (i === keys.length - 1) {
+			current[key] = val;
+			return;
+		}
+		if (current[key] == null) {
+			const nextKeyIsArrayIndex = +keys[i + 1] > -1;
+			current[key] = nextKeyIsArrayIndex ? [] : {};
+		}
+		current = current[key];
+	}
+}
+function setByType(obj, transforms) {
+	for (const key of Object.keys(transforms)) {
+		const transform = transforms[key];
+		if (transform.shouldTransform) {
+			obj[key] = [obj[key]].flat();
+			if (typeof transform.transformFunction === "function") obj[key] = obj[key].map(transform.transformFunction);
+		}
+	}
+}
+function getFileName(input) {
+	const m = /([^\\/]+)$/.exec(input);
+	return m ? m[1] : "";
+}
+function camelcaseOptionName(name) {
+	return name.split(".").map((v, i) => {
+		return i === 0 ? camelcase(v) : v;
+	}).join(".");
+}
+var CACError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CACError";
+		if (typeof Error.captureStackTrace !== "function") this.stack = new Error(message).stack;
+	}
+};
+var Option = class {
+	rawName;
+	description;
+	/** Option name */
+	name;
+	/** Option name and aliases */
+	names;
+	isBoolean;
+	required;
+	config;
+	negated;
+	constructor(rawName, description, config) {
+		this.rawName = rawName;
+		this.description = description;
+		this.config = Object.assign({}, config);
+		rawName = rawName.replaceAll(".*", "");
+		this.negated = false;
+		this.names = removeBrackets(rawName).split(",").map((v) => {
+			let name = v.trim().replace(/^-{1,2}/, "");
+			if (name.startsWith("no-")) {
+				this.negated = true;
+				name = name.replace(/^no-/, "");
+			}
+			return camelcaseOptionName(name);
+		}).sort((a, b) => a.length > b.length ? 1 : -1);
+		this.name = this.names.at(-1);
+		if (this.negated && this.config.default == null) this.config.default = true;
+		if (rawName.includes("<")) this.required = true;
+		else if (rawName.includes("[")) this.required = false;
+		else this.isBoolean = true;
+	}
+};
+let runtimeProcessArgs;
+let runtimeInfo;
+if (typeof process !== "undefined") {
+	let runtimeName;
+	if (typeof Deno !== "undefined" && typeof Deno.version?.deno === "string") runtimeName = "deno";
+	else if (typeof Bun !== "undefined" && typeof Bun.version === "string") runtimeName = "bun";
+	else runtimeName = "node";
+	runtimeInfo = `${process.platform}-${process.arch} ${runtimeName}-${process.version}`;
+	runtimeProcessArgs = process.argv;
+} else if (typeof navigator === "undefined") runtimeInfo = `unknown`;
+else runtimeInfo = `${navigator.platform} ${navigator.userAgent}`;
+var Command = class {
+	rawName;
+	description;
+	config;
+	cli;
+	options;
+	aliasNames;
+	name;
+	args;
+	commandAction;
+	usageText;
+	versionNumber;
+	examples;
+	helpCallback;
+	globalCommand;
+	constructor(rawName, description, config = {}, cli) {
+		this.rawName = rawName;
+		this.description = description;
+		this.config = config;
+		this.cli = cli;
+		this.options = [];
+		this.aliasNames = [];
+		this.name = removeBrackets(rawName);
+		this.args = findAllBrackets(rawName);
+		this.examples = [];
+	}
+	usage(text) {
+		this.usageText = text;
+		return this;
+	}
+	allowUnknownOptions() {
+		this.config.allowUnknownOptions = true;
+		return this;
+	}
+	ignoreOptionDefaultValue() {
+		this.config.ignoreOptionDefaultValue = true;
+		return this;
+	}
+	version(version, customFlags = "-v, --version") {
+		this.versionNumber = version;
+		this.option(customFlags, "Display version number");
+		return this;
+	}
+	example(example) {
+		this.examples.push(example);
+		return this;
+	}
+	/**
+	* Add a option for this command
+	* @param rawName Raw option name(s)
+	* @param description Option description
+	* @param config Option config
+	*/
+	option(rawName, description, config) {
+		const option = new Option(rawName, description, config);
+		this.options.push(option);
+		return this;
+	}
+	alias(name) {
+		this.aliasNames.push(name);
+		return this;
+	}
+	action(callback) {
+		this.commandAction = callback;
+		return this;
+	}
+	/**
+	* Check if a command name is matched by this command
+	* @param name Command name
+	*/
+	isMatched(name) {
+		return this.name === name || this.aliasNames.includes(name);
+	}
+	get isDefaultCommand() {
+		return this.name === "" || this.aliasNames.includes("!");
+	}
+	get isGlobalCommand() {
+		return this instanceof GlobalCommand;
+	}
+	/**
+	* Check if an option is registered in this command
+	* @param name Option name
+	*/
+	hasOption(name) {
+		name = name.split(".")[0];
+		return this.options.find((option) => {
+			return option.names.includes(name);
+		});
+	}
+	outputHelp() {
+		const { name, commands } = this.cli;
+		const { versionNumber, options: globalOptions, helpCallback } = this.cli.globalCommand;
+		let sections = [{ body: `${name}${versionNumber ? `/${versionNumber}` : ""}` }];
+		sections.push({
+			title: "Usage",
+			body: `  $ ${name} ${this.usageText || this.rawName}`
+		});
+		if ((this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0) {
+			const longestCommandName = findLongest(commands.map((command) => command.rawName));
+			sections.push({
+				title: "Commands",
+				body: commands.map((command) => {
+					return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+				}).join("\n")
+			}, {
+				title: `For more info, run any command with the \`--help\` flag`,
+				body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+			});
+		}
+		let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+		if (!this.isGlobalCommand && !this.isDefaultCommand) options = options.filter((option) => option.name !== "version");
+		if (options.length > 0) {
+			const longestOptionName = findLongest(options.map((option) => option.rawName));
+			sections.push({
+				title: "Options",
+				body: options.map((option) => {
+					return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
+				}).join("\n")
+			});
+		}
+		if (this.examples.length > 0) sections.push({
+			title: "Examples",
+			body: this.examples.map((example) => {
+				if (typeof example === "function") return example(name);
+				return example;
+			}).join("\n")
+		});
+		if (helpCallback) sections = helpCallback(sections) || sections;
+		console.info(sections.map((section) => {
+			return section.title ? `${section.title}:\n${section.body}` : section.body;
+		}).join("\n\n"));
+	}
+	outputVersion() {
+		const { name } = this.cli;
+		const { versionNumber } = this.cli.globalCommand;
+		if (versionNumber) console.info(`${name}/${versionNumber} ${runtimeInfo}`);
+	}
+	checkRequiredArgs() {
+		const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+		if (this.cli.args.length < minimalArgsCount) throw new CACError(`missing required args for command \`${this.rawName}\``);
+	}
+	/**
+	* Check if the parsed options contain any unknown options
+	*
+	* Exit and output error when true
+	*/
+	checkUnknownOptions() {
+		const { options, globalCommand } = this.cli;
+		if (!this.config.allowUnknownOptions) {
+			for (const name of Object.keys(options)) if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+		}
+	}
+	/**
+	* Check if the required string-type options exist
+	*/
+	checkOptionValue() {
+		const { options: parsedOptions, globalCommand } = this.cli;
+		const options = [...globalCommand.options, ...this.options];
+		for (const option of options) {
+			const value = parsedOptions[option.name.split(".")[0]];
+			if (option.required) {
+				const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+				if (value === true || value === false && !hasNegated) throw new CACError(`option \`${option.rawName}\` value is missing`);
+			}
+		}
+	}
+	/**
+	* Check if the number of args is more than expected
+	*/
+	checkUnusedArgs() {
+		const maximumArgsCount = this.args.some((arg) => arg.variadic) ? Infinity : this.args.length;
+		if (maximumArgsCount < this.cli.args.length) throw new CACError(`Unused args: ${this.cli.args.slice(maximumArgsCount).map((arg) => `\`${arg}\``).join(", ")}`);
+	}
+};
+var GlobalCommand = class extends Command {
+	constructor(cli) {
+		super("@@global@@", "", {}, cli);
+	}
+};
+var CAC = class extends EventTarget {
+	/** The program name to display in help and version message */
+	name;
+	commands;
+	globalCommand;
+	matchedCommand;
+	matchedCommandName;
+	/**
+	* Raw CLI arguments
+	*/
+	rawArgs;
+	/**
+	* Parsed CLI arguments
+	*/
+	args;
+	/**
+	* Parsed CLI options, camelCased
+	*/
+	options;
+	showHelpOnExit;
+	showVersionOnExit;
+	/**
+	* @param name The program name to display in help and version message
+	*/
+	constructor(name = "") {
+		super();
+		this.name = name;
+		this.commands = [];
+		this.rawArgs = [];
+		this.args = [];
+		this.options = {};
+		this.globalCommand = new GlobalCommand(this);
+		this.globalCommand.usage("<command> [options]");
+	}
+	/**
+	* Add a global usage text.
+	*
+	* This is not used by sub-commands.
+	*/
+	usage(text) {
+		this.globalCommand.usage(text);
+		return this;
+	}
+	/**
+	* Add a sub-command
+	*/
+	command(rawName, description, config) {
+		const command = new Command(rawName, description || "", config, this);
+		command.globalCommand = this.globalCommand;
+		this.commands.push(command);
+		return command;
+	}
+	/**
+	* Add a global CLI option.
+	*
+	* Which is also applied to sub-commands.
+	*/
+	option(rawName, description, config) {
+		this.globalCommand.option(rawName, description, config);
+		return this;
+	}
+	/**
+	* Show help message when `-h, --help` flags appear.
+	*
+	*/
+	help(callback) {
+		this.globalCommand.option("-h, --help", "Display this message");
+		this.globalCommand.helpCallback = callback;
+		this.showHelpOnExit = true;
+		return this;
+	}
+	/**
+	* Show version number when `-v, --version` flags appear.
+	*
+	*/
+	version(version, customFlags = "-v, --version") {
+		this.globalCommand.version(version, customFlags);
+		this.showVersionOnExit = true;
+		return this;
+	}
+	/**
+	* Add a global example.
+	*
+	* This example added here will not be used by sub-commands.
+	*/
+	example(example) {
+		this.globalCommand.example(example);
+		return this;
+	}
+	/**
+	* Output the corresponding help message
+	* When a sub-command is matched, output the help message for the command
+	* Otherwise output the global one.
+	*
+	*/
+	outputHelp() {
+		if (this.matchedCommand) this.matchedCommand.outputHelp();
+		else this.globalCommand.outputHelp();
+	}
+	/**
+	* Output the version number.
+	*
+	*/
+	outputVersion() {
+		this.globalCommand.outputVersion();
+	}
+	setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+		this.args = args;
+		this.options = options;
+		if (matchedCommand) this.matchedCommand = matchedCommand;
+		if (matchedCommandName) this.matchedCommandName = matchedCommandName;
+		return this;
+	}
+	unsetMatchedCommand() {
+		this.matchedCommand = void 0;
+		this.matchedCommandName = void 0;
+	}
+	/**
+	* Parse argv
+	*/
+	parse(argv, { run = true } = {}) {
+		if (!argv) {
+			if (!runtimeProcessArgs) throw new Error("No argv provided and runtime process argv is not available.");
+			argv = runtimeProcessArgs;
+		}
+		this.rawArgs = argv;
+		if (!this.name) this.name = argv[1] ? getFileName(argv[1]) : "cli";
+		let shouldParse = true;
+		for (const command of this.commands) {
+			const parsed = this.mri(argv.slice(2), command);
+			const commandName = parsed.args[0];
+			if (command.isMatched(commandName)) {
+				shouldParse = false;
+				const parsedInfo = {
+					...parsed,
+					args: parsed.args.slice(1)
+				};
+				this.setParsedInfo(parsedInfo, command, commandName);
+				this.dispatchEvent(new CustomEvent(`command:${commandName}`, { detail: command }));
+			}
+		}
+		if (shouldParse) {
+			for (const command of this.commands) if (command.isDefaultCommand) {
+				shouldParse = false;
+				const parsed = this.mri(argv.slice(2), command);
+				this.setParsedInfo(parsed, command);
+				this.dispatchEvent(new CustomEvent("command:!", { detail: command }));
+			}
+		}
+		if (shouldParse) {
+			const parsed = this.mri(argv.slice(2));
+			this.setParsedInfo(parsed);
+		}
+		if (this.options.help && this.showHelpOnExit) {
+			this.outputHelp();
+			run = false;
+			this.unsetMatchedCommand();
+		}
+		if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+			this.outputVersion();
+			run = false;
+			this.unsetMatchedCommand();
+		}
+		const parsedArgv = {
+			args: this.args,
+			options: this.options
+		};
+		if (run) this.runMatchedCommand();
+		if (!this.matchedCommand && this.args[0]) this.dispatchEvent(new CustomEvent("command:*", { detail: this.args[0] }));
+		return parsedArgv;
+	}
+	mri(argv, command) {
+		const cliOptions = [...this.globalCommand.options, ...command ? command.options : []];
+		const mriOptions = getMriOptions(cliOptions);
+		let argsAfterDoubleDashes = [];
+		const doubleDashesIndex = argv.indexOf("--");
+		if (doubleDashesIndex !== -1) {
+			argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+			argv = argv.slice(0, doubleDashesIndex);
+		}
+		let parsed = lib_default(argv, mriOptions);
+		parsed = Object.keys(parsed).reduce((res, name) => {
+			return {
+				...res,
+				[camelcaseOptionName(name)]: parsed[name]
+			};
+		}, { _: [] });
+		const args = parsed._;
+		const options = { "--": argsAfterDoubleDashes };
+		const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+		const transforms = Object.create(null);
+		for (const cliOption of cliOptions) {
+			if (!ignoreDefault && cliOption.config.default !== void 0) for (const name of cliOption.names) options[name] = cliOption.config.default;
+			if (Array.isArray(cliOption.config.type) && transforms[cliOption.name] === void 0) {
+				transforms[cliOption.name] = Object.create(null);
+				transforms[cliOption.name].shouldTransform = true;
+				transforms[cliOption.name].transformFunction = cliOption.config.type[0];
+			}
+		}
+		for (const key of Object.keys(parsed)) if (key !== "_") {
+			setDotProp(options, key.split("."), parsed[key]);
+			setByType(options, transforms);
+		}
+		return {
+			args,
+			options
+		};
+	}
+	runMatchedCommand() {
+		const { args, options, matchedCommand: command } = this;
+		if (!command || !command.commandAction) return;
+		command.checkUnknownOptions();
+		command.checkOptionValue();
+		command.checkRequiredArgs();
+		command.checkUnusedArgs();
+		const actionArgs = [];
+		command.args.forEach((arg, index) => {
+			if (arg.variadic) actionArgs.push(args.slice(index));
+			else actionArgs.push(args[index]);
+		});
+		actionArgs.push(options);
+		return command.commandAction.apply(this, actionArgs);
+	}
+};
+/**
+* @param name The program name to display in help and version message
+*/
+const cac = (name = "") => new CAC(name);
+//#endregion
+//#region src/node/cli.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+function checkNodeVersion(nodeVersion) {
+	const currentVersion = nodeVersion.split(".");
+	const major = parseInt(currentVersion[0], 10);
+	const minor = parseInt(currentVersion[1], 10);
+	return major === 20 && minor >= 19 || major === 22 && minor >= 12 || major > 22;
+}
+if (!checkNodeVersion(process.versions.node)) console.warn(import_picocolors.default.yellow(`You are using Node.js ${process.versions.node}. Vite requires Node.js version 20.19+ or 22.12+. Please upgrade your Node.js version.`));
+const cli = cac("vite");
+let profileSession = global.__vite_profile_session;
+let profileCount = 0;
+const stopProfiler = (log) => {
+	if (!profileSession) return;
+	return new Promise((res, rej) => {
+		profileSession.post("Profiler.stop", (err, { profile }) => {
+			if (!err) {
+				const outPath = path.resolve(`./vite-profile-${profileCount++}.cpuprofile`);
+				fs.writeFileSync(outPath, JSON.stringify(profile));
+				log(import_picocolors.default.yellow(`CPU profile written to ${import_picocolors.default.white(import_picocolors.default.dim(outPath))}`));
+				profileSession = void 0;
+				res();
+			} else rej(err);
+		});
+	});
+};
+const filterDuplicateOptions = (options) => {
+	for (const [key, value] of Object.entries(options)) if (Array.isArray(value)) options[key] = value[value.length - 1];
+};
+/**
+* removing global flags before passing as command specific sub-configs
+*/
+function cleanGlobalCLIOptions(options) {
+	const ret = { ...options };
+	delete ret["--"];
+	delete ret.c;
+	delete ret.config;
+	delete ret.base;
+	delete ret.l;
+	delete ret.logLevel;
+	delete ret.clearScreen;
+	delete ret.configLoader;
+	delete ret.d;
+	delete ret.debug;
+	delete ret.f;
+	delete ret.filter;
+	delete ret.m;
+	delete ret.mode;
+	delete ret.force;
+	delete ret.w;
+	if ("sourcemap" in ret) {
+		const sourcemap = ret.sourcemap;
+		ret.sourcemap = sourcemap === "true" ? true : sourcemap === "false" ? false : ret.sourcemap;
+	}
+	if ("watch" in ret) ret.watch = ret.watch ? {} : void 0;
+	return ret;
+}
+/**
+* removing builder flags before passing as command specific sub-configs
+*/
+function cleanBuilderCLIOptions(options) {
+	const ret = { ...options };
+	delete ret.app;
+	return ret;
+}
+/**
+* host may be a number (like 0), should convert to string
+*/
+const convertHost = (v) => {
+	if (typeof v === "number") return String(v);
+	return v;
+};
+/**
+* base may be a number (like 0), should convert to empty string
+*/
+const convertBase = (v) => {
+	if (v === 0) return "";
+	return v;
+};
+cli.option("-c, --config <file>", `[string] use specified config file`).option("--base <path>", `[string] public base path (default: /)`, { type: [convertBase] }).option("-l, --logLevel <level>", `[string] info | warn | error | silent`).option("--clearScreen", `[boolean] allow/disable clear screen when logging`).option("--configLoader <loader>", `[string] use 'bundle' to bundle the config with Rolldown, or 'runner' (experimental) to process it on the fly, or 'native' (experimental) to load using the native runtime (default: bundle)`).option("-d, --debug [feat]", `[string | boolean] show debug logs`).option("-f, --filter <filter>", `[string] filter debug logs`).option("-m, --mode <mode>", `[string] set env mode`);
+cli.command("[root]", "start dev server").alias("serve").alias("dev").option("--host [host]", `[string] specify hostname`, { type: [convertHost] }).option("--port <port>", `[number] specify port`).option("--open [path]", `[boolean | string] open browser on startup`).option("--cors", `[boolean] enable CORS`).option("--strictPort", `[boolean] exit if specified port is already in use`).option("--force", `[boolean] force the optimizer to ignore the cache and re-bundle`).option("--experimentalBundle", `[boolean] use experimental full bundle mode (this is highly experimental)`).action(async (root, options) => {
+	filterDuplicateOptions(options);
+	const { createServer } = await import("./chunks/node.js").then((n) => n.A);
+	try {
+		const server = await createServer({
+			root,
+			base: options.base,
+			mode: options.mode,
+			configFile: options.config,
+			configLoader: options.configLoader,
+			logLevel: options.logLevel,
+			clearScreen: options.clearScreen,
+			server: cleanGlobalCLIOptions(options),
+			forceOptimizeDeps: options.force,
+			experimental: { bundledDev: options.experimentalBundle }
+		});
+		if (!server.httpServer) throw new Error("HTTP server not available");
+		await server.listen();
+		const info = server.config.logger.info;
+		const modeString = options.mode && options.mode !== "development" ? `  ${import_picocolors.default.bgGreen(` ${import_picocolors.default.bold(options.mode)} `)}` : "";
+		const viteStartTime = global.__vite_start_time ?? false;
+		const startupDurationString = viteStartTime ? import_picocolors.default.dim(`ready in ${import_picocolors.default.reset(import_picocolors.default.bold(Math.ceil(performance.now() - viteStartTime)))} ms`) : "";
+		const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
+		info(`\n  ${import_picocolors.default.green(`${import_picocolors.default.bold("VITE")} v${VERSION}`)}${modeString}  ${startupDurationString}\n`, { clear: !hasExistingLogs });
+		server.printUrls();
+		const customShortcuts = [];
+		if (profileSession) customShortcuts.push({
+			key: "p",
+			description: "start/stop the profiler",
+			async action(server) {
+				if (profileSession) await stopProfiler(server.config.logger.info);
+				else {
+					const inspector = await import("node:inspector").then((r) => r.default);
+					await new Promise((res) => {
+						profileSession = new inspector.Session();
+						profileSession.connect();
+						profileSession.post("Profiler.enable", () => {
+							profileSession.post("Profiler.start", () => {
+								server.config.logger.info("Profiler started");
+								res();
+							});
+						});
+					});
+				}
+			}
+		});
+		server.bindCLIShortcuts({
+			print: true,
+			customShortcuts
+		});
+	} catch (e) {
+		const logger = createLogger(options.logLevel);
+		logger.error(import_picocolors.default.red(`error when starting dev server:\n${inspect(e)}`), { error: e });
+		await stopProfiler(logger.info);
+		process.exit(1);
+	}
+});
+cli.command("build [root]", "build for production").option("--target <target>", `[string] transpile target (default: 'baseline-widely-available')`).option("--outDir <dir>", `[string] output directory (default: dist)`).option("--assetsDir <dir>", `[string] directory under outDir to place assets in (default: assets)`).option("--assetsInlineLimit <number>", `[number] static asset base64 inline threshold in bytes (default: 4096)`).option("--ssr [entry]", `[string] build specified entry for server-side rendering`).option("--sourcemap [output]", `[boolean | "inline" | "hidden"] output source maps for build (default: false)`).option("--minify [minifier]", "[boolean | \"oxc\" | \"terser\" | \"esbuild\"] enable/disable minification, or specify minifier to use (default: oxc)").option("--manifest [name]", `[boolean | string] emit build manifest json`).option("--ssrManifest [name]", `[boolean | string] emit ssr manifest json`).option("--emptyOutDir", `[boolean] force empty outDir when it's outside of root`).option("-w, --watch", `[boolean] rebuilds when modules have changed on disk`).option("--app", `[boolean] same as \`builder: {}\``).action(async (root, options) => {
+	filterDuplicateOptions(options);
+	const { createBuilder } = await import("./chunks/node.js").then((n) => n.w);
+	const buildOptions = cleanGlobalCLIOptions(cleanBuilderCLIOptions(options));
+	try {
+		const builder = await createBuilder({
+			root,
+			base: options.base,
+			mode: options.mode,
+			configFile: options.config,
+			configLoader: options.configLoader,
+			logLevel: options.logLevel,
+			clearScreen: options.clearScreen,
+			build: buildOptions,
+			...options.app ? { builder: {} } : {}
+		}, null);
+		await builder.buildApp();
+		await builder.runDevTools();
+	} catch (e) {
+		createLogger(options.logLevel).error(import_picocolors.default.red(`error during build:\n${inspect(e)}`), { error: e });
+		process.exit(1);
+	} finally {
+		await stopProfiler((message) => createLogger(options.logLevel).info(message));
+	}
+});
+cli.command("optimize [root]", "pre-bundle dependencies (deprecated, the pre-bundle process runs automatically and does not need to be called)").option("--force", `[boolean] force the optimizer to ignore the cache and re-bundle`).action(async (root, options) => {
+	filterDuplicateOptions(options);
+	const { resolveConfig } = await import("./chunks/node.js").then((n) => n.f);
+	const { optimizeDeps } = await import("./chunks/node.js").then((n) => n.D);
+	try {
+		await optimizeDeps(await resolveConfig({
+			root,
+			base: options.base,
+			configFile: options.config,
+			configLoader: options.configLoader,
+			logLevel: options.logLevel,
+			mode: options.mode
+		}, "serve"), options.force, true);
+	} catch (e) {
+		createLogger(options.logLevel).error(import_picocolors.default.red(`error when optimizing deps:\n${inspect(e)}`), { error: e });
+		process.exit(1);
+	}
+});
+cli.command("preview [root]", "locally preview production build").option("--host [host]", `[string] specify hostname`, { type: [convertHost] }).option("--port <port>", `[number] specify port`).option("--strictPort", `[boolean] exit if specified port is already in use`).option("--open [path]", `[boolean | string] open browser on startup`).option("--outDir <dir>", `[string] output directory (default: dist)`).action(async (root, options) => {
+	filterDuplicateOptions(options);
+	const { preview } = await import("./chunks/node.js").then((n) => n.y);
+	try {
+		const server = await preview({
+			root,
+			base: options.base,
+			configFile: options.config,
+			configLoader: options.configLoader,
+			logLevel: options.logLevel,
+			mode: options.mode,
+			build: { outDir: options.outDir },
+			preview: {
+				port: options.port,
+				strictPort: options.strictPort,
+				host: options.host,
+				open: options.open
+			}
+		});
+		server.printUrls();
+		server.bindCLIShortcuts({ print: true });
+	} catch (e) {
+		createLogger(options.logLevel).error(import_picocolors.default.red(`error when starting preview server:\n${inspect(e)}`), { error: e });
+		process.exit(1);
+	} finally {
+		await stopProfiler((message) => createLogger(options.logLevel).info(message));
+	}
+});
+cli.help();
+cli.version(VERSION);
+cli.parse();
+//#endregion
+export { stopProfiler };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/index.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/index.d.ts
new file mode 100644
index 0000000..3432690
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/index.d.ts
@@ -0,0 +1,3886 @@
+/// <reference types="node" />
+import { t as ModuleRunnerTransport } from "./chunks/moduleRunnerTransport.js";
+import { ConnectedPayload, CustomPayload, CustomPayload as hmrPayload_CustomPayload, ErrorPayload, FullReloadPayload, HMRPayload, HotPayload, HotPayload as hmrPayload_HotPayload, PrunePayload, Update, UpdatePayload } from "#types/hmrPayload";
+import { CustomEventMap, InferCustomEventPayload, InferCustomEventPayload as hmrPayload_InferCustomEventPayload, InvalidatePayload } from "#types/customEvent";
+import * as Rolldown from "rolldown";
+import { CustomPluginOptions, ExistingRawSourceMap, FunctionPluginHooks, ImportKind, InputOption, InputOptions, LoadResult, MinimalPluginContext, ModuleFormat, ModuleInfo, ModuleType, ModuleTypeFilter, ObjectHook, OutputBundle, OutputChunk, OutputOptions, PartialResolvedId, PluginContext, PluginContextMeta, ResolveIdResult, RolldownOptions, RolldownOutput, RolldownWatcher, RollupError, RollupLog, SourceDescription, SourceMap, SourceMapInput, TransformPluginContext, VERSION as rolldownVersion, WatcherOptions } from "rolldown";
+import { parseAst as parseAst$1, parseAstAsync as parseAstAsync$1 } from "rolldown/parseAst";
+import * as Rollup from "#types/internal/rollupTypeCompat";
+import { esmExternalRequirePlugin } from "rolldown/plugins";
+import { ESTree, MinifyOptions, MinifyResult, ParseResult, ParserOptions, TransformOptions as rolldown_utils_TransformOptions, TransformResult as rolldown_utils_TransformResult, Visitor, VisitorObject, minify, minifySync, parse, parseSync } from "rolldown/utils";
+import * as http from "node:http";
+import { Agent, ClientRequest, ClientRequestArgs, OutgoingHttpHeaders, ServerResponse } from "node:http";
+import { Http2SecureServer } from "node:http2";
+import * as fs from "node:fs";
+import { EventEmitter } from "node:events";
+import { Server as HttpsServer, ServerOptions as HttpsServerOptions } from "node:https";
+import * as net from "node:net";
+import { Duplex, DuplexOptions, Stream } from "node:stream";
+import { FetchFunction, FetchFunctionOptions, FetchResult, FetchResult as moduleRunner_FetchResult, ModuleEvaluator, ModuleRunner, ModuleRunnerHmr, ModuleRunnerOptions } from "vite/module-runner";
+import { DepsOptimizerEsbuildOptions, EsbuildTarget, EsbuildTransformOptions, EsbuildTransformOptions as esbuildOptions_EsbuildTransformOptions, EsbuildTransformResult } from "#types/internal/esbuildOptions";
+import { SecureContextOptions } from "node:tls";
+import { URL as url_URL } from "node:url";
+import { ZlibOptions } from "node:zlib";
+import { ChunkMetadata, CustomPluginOptionsVite } from "#types/metadata";
+import { Terser, TerserMinifyOptions } from "#types/internal/terserOptions";
+import * as PostCSS from "postcss";
+import { LightningCSSOptions, LightningCSSOptions as lightningcssOptions_LightningCSSOptions } from "#types/internal/lightningcssOptions";
+import { LessPreprocessorBaseOptions, SassModernPreprocessBaseOptions, StylusPreprocessorBaseOptions } from "#types/internal/cssPreprocessorOptions";
+import { withFilter } from "rolldown/filter";
+import { GeneralImportGlobOptions, ImportGlobFunction, ImportGlobOptions, KnownAsTypeMap } from "#types/importGlob";
+
+//#region \0rolldown/runtime.js
+//#endregion
+//#region ../../node_modules/.pnpm/@vitejs+devtools@0.1.21_typescript@6.0.2_vite@packages+vite/node_modules/@vitejs/devtools/dist/cli-commands.d.ts
+//#region src/node/cli-commands.d.ts
+interface StartOptions {
+  root?: string;
+  config?: string;
+  host: string;
+  port?: string | number;
+  open?: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vitejs+devtools@0.1.21_typescript@6.0.2_vite@packages+vite/node_modules/@vitejs/devtools/dist/config.d.ts
+//#region src/node/config.d.ts
+interface DevToolsConfig extends Partial<StartOptions> {
+  enabled: boolean;
+  /**
+   * Vite environments to enable DevTools for. Defaults to all environments.
+   */
+  environments?: string[];
+  /**
+   * Disable client authentication.
+   *
+   * Beware that if you disable client authentication,
+   * any browsers can connect to the devtools and access to your server and filesystem.
+   * (including other devices, if you open server `host` option to LAN or WAN)
+   *
+   * @default true
+   */
+  clientAuth?: boolean;
+  /**
+   * Pre-configured auth tokens that are automatically trusted.
+   *
+   * Clients connecting with an auth token matching one of these
+   * will be auto-approved without a terminal prompt.
+   */
+  clientAuthTokens?: string[];
+}
+interface ResolvedDevToolsConfig {
+  config: Omit<DevToolsConfig, 'enabled'> & {
+    host: string;
+  };
+  enabled: boolean;
+}
+//#endregion
+//#region src/types/alias.d.ts
+interface Alias {
+  find: string | RegExp;
+  replacement: string;
+  /**
+   * Instructs the plugin to use an alternative resolving algorithm,
+   * rather than the Rollup's resolver.
+   * @default null
+   * @deprecated Use a custom plugin with resolveId hook and `enforce: 'pre'` instead
+   */
+  customResolver?: ResolverFunction | ResolverObject | null;
+}
+type MapToFunction<T> = T extends Function ? T : never;
+type ResolverFunction = MapToFunction<FunctionPluginHooks['resolveId']>;
+interface ResolverObject {
+  buildStart?: FunctionPluginHooks['buildStart'];
+  resolveId: ResolverFunction;
+}
+/**
+ * Specifies an `Object`, or an `Array` of `Object`,
+ * which defines aliases used to replace values in `import` or `require` statements.
+ * With either format, the order of the entries is important,
+ * in that the first defined rules are applied first.
+ *
+ * This is passed to \@rollup/plugin-alias as the "entries" field
+ * https://github.com/rollup/plugins/tree/master/packages/alias#entries
+ */
+type AliasOptions = readonly Alias[] | {
+  [find: string]: string;
+};
+//#endregion
+//#region src/types/anymatch.d.ts
+type AnymatchFn = (testString: string) => boolean;
+type AnymatchPattern = string | RegExp | AnymatchFn;
+type AnymatchMatcher = AnymatchPattern | AnymatchPattern[];
+//#endregion
+//#region src/types/chokidar.d.ts
+declare class FSWatcher extends EventEmitter implements fs.FSWatcher {
+  options: WatchOptions;
+  /**
+   * Constructs a new FSWatcher instance with optional WatchOptions parameter.
+   */
+  constructor(options?: WatchOptions);
+  /**
+   * When called, requests that the Node.js event loop not exit so long as the fs.FSWatcher is active.
+   * Calling watcher.ref() multiple times will have no effect.
+   */
+  ref(): this;
+  /**
+   * When called, the active fs.FSWatcher object will not require the Node.js event loop to remain active.
+   * If there is no other activity keeping the event loop running, the process may exit before the fs.FSWatcher object's callback is invoked.
+   * Calling watcher.unref() multiple times will have no effect.
+   */
+  unref(): this;
+  /**
+   * Add files, directories, or glob patterns for tracking. Takes an array of strings or just one
+   * string.
+   */
+  add(paths: string | ReadonlyArray<string>): this;
+  /**
+   * Stop watching files, directories, or glob patterns. Takes an array of strings or just one
+   * string.
+   */
+  unwatch(paths: string | ReadonlyArray<string>): this;
+  /**
+   * Returns an object representing all the paths on the file system being watched by this
+   * `FSWatcher` instance. The object's keys are all the directories (using absolute paths unless
+   * the `cwd` option was used), and the values are arrays of the names of the items contained in
+   * each directory.
+   */
+  getWatched(): {
+    [directory: string]: string[];
+  };
+  /**
+   * Removes all listeners from watched files.
+   */
+  close(): Promise<void>;
+  on(event: 'add' | 'addDir' | 'change', listener: (path: string, stats?: fs.Stats) => void): this;
+  on(event: 'all', listener: (eventName: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir', path: string, stats?: fs.Stats) => void): this;
+  /**
+   * Error occurred
+   */
+  on(event: 'error', listener: (error: Error) => void): this;
+  /**
+   * Exposes the native Node `fs.FSWatcher events`
+   */
+  on(event: 'raw', listener: (eventName: string, path: string, details: any) => void): this;
+  /**
+   * Fires when the initial scan is complete
+   */
+  on(event: 'ready', listener: () => void): this;
+  on(event: 'unlink' | 'unlinkDir', listener: (path: string) => void): this;
+  on(event: string, listener: (...args: any[]) => void): this;
+}
+interface WatchOptions {
+  /**
+   * Indicates whether the process should continue to run as long as files are being watched. If
+   * set to `false` when using `fsevents` to watch, no more events will be emitted after `ready`,
+   * even if the process continues to run.
+   */
+  persistent?: boolean;
+  /**
+   * ([anymatch](https://github.com/micromatch/anymatch)-compatible definition) Defines files/paths to
+   * be ignored. The whole relative or absolute path is tested, not just filename. If a function
+   * with two arguments is provided, it gets called twice per path - once with a single argument
+   * (the path), second time with two arguments (the path and the
+   * [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object of that path).
+   */
+  ignored?: AnymatchMatcher;
+  /**
+   * If set to `false` then `add`/`addDir` events are also emitted for matching paths while
+   * instantiating the watching as chokidar discovers these file paths (before the `ready` event).
+   */
+  ignoreInitial?: boolean;
+  /**
+   * When `false`, only the symlinks themselves will be watched for changes instead of following
+   * the link references and bubbling events through the link's path.
+   */
+  followSymlinks?: boolean;
+  /**
+   * The base directory from which watch `paths` are to be derived. Paths emitted with events will
+   * be relative to this.
+   */
+  cwd?: string;
+  /**
+   * If set to true then the strings passed to .watch() and .add() are treated as literal path
+   * names, even if they look like globs.
+   *
+   * @default false
+   */
+  disableGlobbing?: boolean;
+  /**
+   * Whether to use fs.watchFile (backed by polling), or fs.watch. If polling leads to high CPU
+   * utilization, consider setting this to `false`. It is typically necessary to **set this to
+   * `true` to successfully watch files over a network**, and it may be necessary to successfully
+   * watch files in other non-standard situations. Setting to `true` explicitly on OS X overrides
+   * the `useFsEvents` default.
+   */
+  usePolling?: boolean;
+  /**
+   * Whether to use the `fsevents` watching interface if available. When set to `true` explicitly
+   * and `fsevents` is available this supersedes the `usePolling` setting. When set to `false` on
+   * OS X, `usePolling: true` becomes the default.
+   */
+  useFsEvents?: boolean;
+  /**
+   * If relying upon the [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object that
+   * may get passed with `add`, `addDir`, and `change` events, set this to `true` to ensure it is
+   * provided even in cases where it wasn't already available from the underlying watch events.
+   */
+  alwaysStat?: boolean;
+  /**
+   * If set, limits how many levels of subdirectories will be traversed.
+   */
+  depth?: number;
+  /**
+   * Interval of file system polling.
+   */
+  interval?: number;
+  /**
+   * Interval of file system polling for binary files. ([see list of binary extensions](https://gi
+   * thub.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json))
+   */
+  binaryInterval?: number;
+  /**
+   *  Indicates whether to watch files that don't have read permissions if possible. If watching
+   *  fails due to `EPERM` or `EACCES` with this set to `true`, the errors will be suppressed
+   *  silently.
+   */
+  ignorePermissionErrors?: boolean;
+  /**
+   * `true` if `useFsEvents` and `usePolling` are `false`. Automatically filters out artifacts
+   * that occur when using editors that use "atomic writes" instead of writing directly to the
+   * source file. If a file is re-added within 100 ms of being deleted, Chokidar emits a `change`
+   * event rather than `unlink` then `add`. If the default of 100 ms does not work well for you,
+   * you can override it by setting `atomic` to a custom value, in milliseconds.
+   */
+  atomic?: boolean | number;
+  /**
+   * can be set to an object in order to adjust timing params:
+   */
+  awaitWriteFinish?: AwaitWriteFinishOptions | boolean;
+}
+interface AwaitWriteFinishOptions {
+  /**
+   * Amount of time in milliseconds for a file size to remain constant before emitting its event.
+   */
+  stabilityThreshold?: number;
+  /**
+   * File size polling interval.
+   */
+  pollInterval?: number;
+}
+//#endregion
+//#region src/types/connect.d.ts
+declare namespace Connect {
+  export type ServerHandle = HandleFunction | http.Server;
+  export class IncomingMessage extends http.IncomingMessage {
+    originalUrl?: http.IncomingMessage['url'] | undefined;
+  }
+  export type NextFunction = (err?: any) => void;
+  export type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;
+  export type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+  export type ErrorHandleFunction = (err: any, req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+  export type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
+  export interface ServerStackItem {
+    route: string;
+    handle: ServerHandle;
+  }
+  export interface Server extends NodeJS.EventEmitter {
+    (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
+    route: string;
+    stack: ServerStackItem[];
+    /**
+     * Utilize the given middleware `handle` to the given `route`,
+     * defaulting to _/_. This "route" is the mount-point for the
+     * middleware, when given a value other than _/_ the middleware
+     * is only effective when that segment is present in the request's
+     * pathname.
+     *
+     * For example if we were to mount a function at _/admin_, it would
+     * be invoked on _/admin_, and _/admin/settings_, however it would
+     * not be invoked for _/_, or _/posts_.
+     */
+    use(fn: NextHandleFunction): Server;
+    use(fn: HandleFunction): Server;
+    use(route: string, fn: NextHandleFunction): Server;
+    use(route: string, fn: HandleFunction): Server;
+    /**
+     * Handle server requests, punting them down
+     * the middleware stack.
+     */
+    handle(req: http.IncomingMessage, res: http.ServerResponse, next: Function): void;
+    /**
+     * Listen for connections.
+     *
+     * This method takes the same arguments
+     * as node's `http.Server#listen()`.
+     *
+     * HTTP and HTTPS:
+     *
+     * If you run your application both as HTTP
+     * and HTTPS you may wrap them individually,
+     * since your Connect "server" is really just
+     * a JavaScript `Function`.
+     *
+     *      var connect = require('connect')
+     *        , http = require('http')
+     *        , https = require('https');
+     *
+     *      var app = connect();
+     *
+     *      http.createServer(app).listen(80);
+     *      https.createServer(options, app).listen(443);
+     */
+    listen(port: number, hostname?: string, backlog?: number, callback?: Function): http.Server;
+    listen(port: number, hostname?: string, callback?: Function): http.Server;
+    listen(path: string, callback?: Function): http.Server;
+    listen(handle: any, listeningListener?: Function): http.Server;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/http-proxy-3@1.23.2_ms@2.1.3/node_modules/http-proxy-3/dist/lib/http-proxy/index.d.ts
+interface ProxyTargetDetailed {
+  host: string;
+  port: number;
+  protocol?: string;
+  hostname?: string;
+  socketPath?: string;
+  key?: string;
+  passphrase?: string;
+  pfx?: Buffer | string;
+  cert?: string;
+  ca?: string;
+  ciphers?: string;
+  secureProtocol?: string;
+}
+type ProxyType = "ws" | "web";
+type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed;
+type ProxyTargetUrl = URL | string | {
+  port: number;
+  host: string;
+  protocol?: string;
+};
+type NormalizeProxyTarget<T extends ProxyTargetUrl> = Exclude<T, string> | URL;
+interface ServerOptions$3 {
+  /** URL string to be parsed with the url module. */
+  target?: ProxyTarget;
+  /** URL string to be parsed with the url module or a URL object. */
+  forward?: ProxyTargetUrl;
+  /** Object to be passed to http(s).request. */
+  agent?: any;
+  /** Object to be passed to https.createServer(). */
+  ssl?: any;
+  /** If you want to proxy websockets. */
+  ws?: boolean;
+  /** Adds x- forward headers. */
+  xfwd?: boolean;
+  /** Verify SSL certificate. */
+  secure?: boolean;
+  /** Explicitly specify if we are proxying to another proxy. */
+  toProxy?: boolean;
+  /** Specify whether you want to prepend the target's path to the proxy path. */
+  prependPath?: boolean;
+  /** Specify whether you want to ignore the proxy path of the incoming request. */
+  ignorePath?: boolean;
+  /** Local interface string to bind for outgoing connections. */
+  localAddress?: string;
+  /** Changes the origin of the host header to the target URL. */
+  changeOrigin?: boolean;
+  /** specify whether you want to keep letter case of response header key */
+  preserveHeaderKeyCase?: boolean;
+  /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
+  auth?: string;
+  /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
+  hostRewrite?: string;
+  /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
+  autoRewrite?: boolean;
+  /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
+  protocolRewrite?: string;
+  /** rewrites domain of set-cookie headers. */
+  cookieDomainRewrite?: false | string | {
+    [oldDomain: string]: string;
+  };
+  /** rewrites path of set-cookie headers. Default: false */
+  cookiePathRewrite?: false | string | {
+    [oldPath: string]: string;
+  };
+  /** object with extra headers to be added to target requests. */
+  headers?: {
+    [header: string]: string | string[] | undefined;
+  };
+  /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
+  proxyTimeout?: number;
+  /** Timeout (in milliseconds) for incoming requests */
+  timeout?: number;
+  /** Specify whether you want to follow redirects. Default: false */
+  followRedirects?: boolean;
+  /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
+  selfHandleResponse?: boolean;
+  /** Buffer */
+  buffer?: Stream;
+  /** Explicitly set the method type of the ProxyReq */
+  method?: string;
+  /**
+   * Optionally override the trusted CA certificates.
+   * This is passed to https.request.
+   */
+  ca?: string;
+  /** Optional fetch implementation to use instead of global fetch, use this to activate fetch-based proxying,
+   * for example to proxy HTTP/2 requests
+  */
+  fetch?: typeof fetch;
+  /** Optional configuration object for fetch-based proxy requests.
+   * Use this to customize fetch request and response handling.
+   * For custom fetch implementations, use the `fetch` property.*/
+  fetchOptions?: FetchOptions;
+}
+interface FetchOptions {
+  /** Fetch request options */
+  requestOptions?: RequestInit;
+  /** Called before making the fetch request */
+  onBeforeRequest?: (requestOptions: RequestInit, req: http.IncomingMessage, res: http.ServerResponse, options: NormalizedServerOptions) => void | Promise<void>;
+  /** Called after receiving the fetch response */
+  onAfterResponse?: (response: Response, req: http.IncomingMessage, res: http.ServerResponse, options: NormalizedServerOptions) => void | Promise<void>;
+}
+interface NormalizedServerOptions extends ServerOptions$3 {
+  target?: NormalizeProxyTarget<ProxyTarget>;
+  forward?: NormalizeProxyTarget<ProxyTargetUrl>;
+}
+type ErrorCallback<TIncomingMessage extends typeof http.IncomingMessage = typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse = typeof http.ServerResponse, TError = Error> = (err: TError, req: InstanceType<TIncomingMessage>, res: InstanceType<TServerResponse> | net.Socket, target?: ProxyTargetUrl) => void;
+type ProxyServerEventMap<TIncomingMessage extends typeof http.IncomingMessage = typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse = typeof http.ServerResponse, TError = Error> = {
+  error: Parameters<ErrorCallback<TIncomingMessage, TServerResponse, TError>>;
+  start: [req: InstanceType<TIncomingMessage>, res: InstanceType<TServerResponse>, target: ProxyTargetUrl];
+  open: [socket: net.Socket];
+  proxyReq: [proxyReq: http.ClientRequest, req: InstanceType<TIncomingMessage>, res: InstanceType<TServerResponse>, options: ServerOptions$3, socket: net.Socket];
+  proxyRes: [proxyRes: InstanceType<TIncomingMessage>, req: InstanceType<TIncomingMessage>, res: InstanceType<TServerResponse>];
+  proxyReqWs: [proxyReq: http.ClientRequest, req: InstanceType<TIncomingMessage>, socket: net.Socket, options: ServerOptions$3, head: any];
+  econnreset: [err: Error, req: InstanceType<TIncomingMessage>, res: InstanceType<TServerResponse>, target: ProxyTargetUrl];
+  end: [req: InstanceType<TIncomingMessage>, res: InstanceType<TServerResponse>, proxyRes: InstanceType<TIncomingMessage>];
+  close: [proxyRes: InstanceType<TIncomingMessage>, proxySocket: net.Socket, proxyHead: any];
+};
+type ProxyMethodArgs<TIncomingMessage extends typeof http.IncomingMessage = typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse = typeof http.ServerResponse, TError = Error> = {
+  ws: [req: InstanceType<TIncomingMessage>, socket: any, head: any, ...args: [options?: ServerOptions$3, callback?: ErrorCallback<TIncomingMessage, TServerResponse, TError>] | [callback?: ErrorCallback<TIncomingMessage, TServerResponse, TError>]];
+  web: [req: InstanceType<TIncomingMessage>, res: InstanceType<TServerResponse>, ...args: [options: ServerOptions$3, callback?: ErrorCallback<TIncomingMessage, TServerResponse, TError>] | [callback?: ErrorCallback<TIncomingMessage, TServerResponse, TError>]];
+};
+type PassFunctions<TIncomingMessage extends typeof http.IncomingMessage = typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse = typeof http.ServerResponse, TError = Error> = {
+  ws: (req: InstanceType<TIncomingMessage>, socket: net.Socket, options: NormalizedServerOptions, head: Buffer | undefined, server: ProxyServer<TIncomingMessage, TServerResponse, TError>, cb?: ErrorCallback<TIncomingMessage, TServerResponse, TError>) => unknown;
+  web: (req: InstanceType<TIncomingMessage>, res: InstanceType<TServerResponse>, options: NormalizedServerOptions, head: Buffer | undefined, server: ProxyServer<TIncomingMessage, TServerResponse, TError>, cb?: ErrorCallback<TIncomingMessage, TServerResponse, TError>) => unknown;
+};
+declare class ProxyServer<TIncomingMessage extends typeof http.IncomingMessage = typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse = typeof http.ServerResponse, TError = Error> extends EventEmitter<ProxyServerEventMap<TIncomingMessage, TServerResponse, TError>> {
+  /**
+   * Used for proxying WS(S) requests
+   * @param req - Client request.
+   * @param socket - Client socket.
+   * @param head - Client head.
+   * @param options - Additional options.
+   */
+  readonly ws: (...args: ProxyMethodArgs<TIncomingMessage, TServerResponse, TError>["ws"]) => void;
+  /**
+   * Used for proxying regular HTTP(S) requests
+   * @param req - Client request.
+   * @param res - Client response.
+   * @param options - Additional options.
+   */
+  readonly web: (...args: ProxyMethodArgs<TIncomingMessage, TServerResponse, TError>["web"]) => void;
+  private options;
+  private webPasses;
+  private wsPasses;
+  private _server?;
+  /**
+   * Creates the proxy server with specified options.
+   * @param options - Config object passed to the proxy
+   */
+  constructor(options?: ServerOptions$3);
+  /**
+   * Creates the proxy server with specified options.
+   * @param options Config object passed to the proxy
+   * @returns Proxy object with handlers for `ws` and `web` requests
+   */
+  static createProxyServer<TIncomingMessage extends typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse, TError = Error>(options?: ServerOptions$3): ProxyServer<TIncomingMessage, TServerResponse, TError>;
+  /**
+   * Creates the proxy server with specified options.
+   * @param options Config object passed to the proxy
+   * @returns Proxy object with handlers for `ws` and `web` requests
+   */
+  static createServer<TIncomingMessage extends typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse, TError = Error>(options?: ServerOptions$3): ProxyServer<TIncomingMessage, TServerResponse, TError>;
+  /**
+   * Creates the proxy server with specified options.
+   * @param options Config object passed to the proxy
+   * @returns Proxy object with handlers for `ws` and `web` requests
+   */
+  static createProxy<TIncomingMessage extends typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse, TError = Error>(options?: ServerOptions$3): ProxyServer<TIncomingMessage, TServerResponse, TError>;
+  createRightProxy: <PT extends ProxyType>(type: PT) => Function;
+  onError: (err: TError) => void;
+  /**
+   * A function that wraps the object in a webserver, for your convenience
+   * @param port - Port to listen on
+   * @param hostname - The hostname to listen on
+   */
+  listen: (port: number, hostname?: string) => this;
+  address: () => string | net.AddressInfo | null | undefined;
+  /**
+   * A function that closes the inner webserver and stops listening on given port
+   */
+  close: (cb?: Function) => void;
+  before: <PT extends ProxyType>(type: PT, passName: string, cb: PassFunctions<TIncomingMessage, TServerResponse, TError>[PT]) => void;
+  after: <PT extends ProxyType>(type: PT, passName: string, cb: PassFunctions<TIncomingMessage, TServerResponse, TError>[PT]) => void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/http-proxy-3@1.23.2_ms@2.1.3/node_modules/http-proxy-3/dist/lib/http-proxy/passes/ws-incoming.d.ts
+declare function numOpenSockets(): number;
+declare namespace index_d_exports {
+  export { ErrorCallback, ProxyServer, ProxyTarget, ProxyTargetUrl, ServerOptions$3 as ServerOptions, createProxyServer as createProxy, createProxyServer, createProxyServer as createServer, ProxyServer as default, numOpenSockets };
+}
+/**
+ * Creates the proxy server.
+ *
+ * Examples:
+ *
+ *    httpProxy.createProxyServer({ .. }, 8000)
+ *    // => '{ web: [Function], ws: [Function] ... }'
+ *
+ * @param {Object} Options Config object passed to the proxy
+ *
+ * @return {Object} Proxy Proxy object with handlers for `ws` and `web` requests
+ *
+ * @api public
+ */
+declare function createProxyServer<TIncomingMessage extends typeof http.IncomingMessage = typeof http.IncomingMessage, TServerResponse extends typeof http.ServerResponse = typeof http.ServerResponse, TError = Error>(options?: ServerOptions$3): ProxyServer<TIncomingMessage, TServerResponse, TError>;
+//#endregion
+//#region src/node/server/middlewares/proxy.d.ts
+interface ProxyOptions extends ServerOptions$3 {
+  /**
+  * rewrite path
+  */
+  rewrite?: (path: string) => string;
+  /**
+  * configure the proxy server (e.g. listen to events)
+  */
+  configure?: (proxy: ProxyServer, options: ProxyOptions) => void;
+  /**
+  * webpack-dev-server style bypass function
+  */
+  bypass?: (req: http.IncomingMessage, res: http.ServerResponse | undefined, options: ProxyOptions) => void | null | undefined | false | string | Promise<void | null | undefined | boolean | string>;
+  /**
+  * rewrite the Origin header of a WebSocket request to match the target
+  *
+  * **Exercise caution as rewriting the Origin can leave the proxying open to [CSRF attacks](https://owasp.org/www-community/attacks/csrf).**
+  */
+  rewriteWsOrigin?: boolean | undefined;
+}
+//#endregion
+//#region src/node/logger.d.ts
+type LogType = "error" | "warn" | "info";
+type LogLevel = LogType | "silent";
+interface Logger {
+  info(msg: string, options?: LogOptions): void;
+  warn(msg: string, options?: LogOptions): void;
+  warnOnce(msg: string, options?: LogOptions): void;
+  error(msg: string, options?: LogErrorOptions): void;
+  clearScreen(type: LogType): void;
+  hasErrorLogged(error: Error | RollupError): boolean;
+  hasWarned: boolean;
+}
+interface LogOptions {
+  clear?: boolean;
+  timestamp?: boolean;
+  environment?: string;
+}
+interface LogErrorOptions extends LogOptions {
+  error?: Error | RollupError | null;
+}
+interface LoggerOptions {
+  prefix?: string;
+  allowClearScreen?: boolean;
+  customLogger?: Logger;
+  console?: Console;
+}
+declare function createLogger(level?: LogLevel, options?: LoggerOptions): Logger;
+//#endregion
+//#region src/node/http.d.ts
+interface CommonServerOptions {
+  /**
+  * Specify server port. Note if the port is already being used, Vite will
+  * automatically try the next available port so this may not be the actual
+  * port the server ends up listening on.
+  */
+  port?: number;
+  /**
+  * If enabled, vite will exit if specified port is already in use
+  */
+  strictPort?: boolean;
+  /**
+  * Specify which IP addresses the server should listen on.
+  * Set to 0.0.0.0 to listen on all addresses, including LAN and public addresses.
+  */
+  host?: string | boolean;
+  /**
+  * The hostnames that Vite is allowed to respond to.
+  * `localhost` and subdomains under `.localhost` and all IP addresses are allowed by default.
+  * When using HTTPS, this check is skipped.
+  *
+  * If a string starts with `.`, it will allow that hostname without the `.` and all subdomains under the hostname.
+  * For example, `.example.com` will allow `example.com`, `foo.example.com`, and `foo.bar.example.com`.
+  *
+  * If set to `true`, the server is allowed to respond to requests for any hosts.
+  * This is not recommended as it will be vulnerable to DNS rebinding attacks.
+  */
+  allowedHosts?: string[] | true;
+  /**
+  * Enable TLS + HTTP/2.
+  * Note: this downgrades to TLS only when the proxy option is also used.
+  */
+  https?: HttpsServerOptions;
+  /**
+  * Open browser window on startup
+  */
+  open?: boolean | string;
+  /**
+  * Configure custom proxy rules for the dev server. Expects an object
+  * of `{ key: options }` pairs.
+  * Uses [`http-proxy-3`](https://github.com/sagemathinc/http-proxy-3).
+  * Full options [here](https://github.com/sagemathinc/http-proxy-3#options).
+  *
+  * Example `vite.config.js`:
+  * ``` js
+  * module.exports = {
+  *   proxy: {
+  *     // string shorthand: /foo -> http://localhost:4567/foo
+  *     '/foo': 'http://localhost:4567',
+  *     // with options
+  *     '/api': {
+  *       target: 'http://jsonplaceholder.typicode.com',
+  *       changeOrigin: true,
+  *       rewrite: path => path.replace(/^\/api/, '')
+  *     }
+  *   }
+  * }
+  * ```
+  */
+  proxy?: Record<string, string | ProxyOptions>;
+  /**
+  * Configure CORS for the dev server.
+  * Uses https://github.com/expressjs/cors.
+  *
+  * When enabling this option, **we recommend setting a specific value
+  * rather than `true`** to avoid exposing the source code to untrusted origins.
+  *
+  * Set to `true` to allow all methods from any origin, or configure separately
+  * using an object.
+  *
+  * @default false
+  */
+  cors?: CorsOptions | boolean;
+  /**
+  * Specify server response headers.
+  */
+  headers?: OutgoingHttpHeaders;
+}
+/**
+* https://github.com/expressjs/cors#configuration-options
+*/
+interface CorsOptions {
+  /**
+  * Configures the Access-Control-Allow-Origin CORS header.
+  *
+  * **We recommend setting a specific value rather than
+  * `true`** to avoid exposing the source code to untrusted origins.
+  */
+  origin?: CorsOrigin | ((origin: string | undefined, cb: (err: Error, origins: CorsOrigin) => void) => void);
+  methods?: string | string[];
+  allowedHeaders?: string | string[];
+  exposedHeaders?: string | string[];
+  credentials?: boolean;
+  maxAge?: number;
+  preflightContinue?: boolean;
+  optionsSuccessStatus?: number;
+}
+type CorsOrigin = boolean | string | RegExp | (string | RegExp)[];
+//#endregion
+//#region src/shared/forwardConsole.d.ts
+type ForwardConsoleLogLevel = "error" | "warn" | "info" | "log" | "debug" | (string & {});
+interface ForwardConsoleOptions {
+  unhandledErrors?: boolean;
+  logLevels?: ForwardConsoleLogLevel[];
+}
+interface ResolvedForwardConsoleOptions {
+  enabled: boolean;
+  unhandledErrors: boolean;
+  logLevels: ForwardConsoleLogLevel[];
+}
+//#endregion
+//#region src/node/typeUtils.d.ts
+type RequiredExceptFor<T, K extends keyof T> = Pick<T, K> & Required<Omit<T, K>>;
+//#endregion
+//#region src/node/preview.d.ts
+interface PreviewOptions extends CommonServerOptions {}
+interface ResolvedPreviewOptions extends RequiredExceptFor<PreviewOptions, "host" | "https" | "proxy"> {}
+interface PreviewServer {
+  /**
+  * The resolved vite config object
+  */
+  config: ResolvedConfig;
+  /**
+  * Stop the server.
+  */
+  close(): Promise<void>;
+  /**
+  * A connect app instance.
+  * - Can be used to attach custom middlewares to the preview server.
+  * - Can also be used as the handler function of a custom http server
+  *   or as a middleware in any connect-style Node.js frameworks
+  *
+  * https://github.com/senchalabs/connect#use-middleware
+  */
+  middlewares: Connect.Server;
+  /**
+  * native Node http server instance
+  */
+  httpServer: HttpServer;
+  /**
+  * The resolved urls Vite prints on the CLI (URL-encoded). Returns `null`
+  * if the server is not listening on any port.
+  */
+  resolvedUrls: ResolvedServerUrls | null;
+  /**
+  * Print server urls
+  */
+  printUrls(): void;
+  /**
+  * Bind CLI shortcuts
+  */
+  bindCLIShortcuts(options?: BindCLIShortcutsOptions<PreviewServer>): void;
+}
+type PreviewServerHook = (this: MinimalPluginContextWithoutEnvironment, server: PreviewServer) => (() => void) | void | Promise<(() => void) | void>;
+/**
+* Starts the Vite server in preview mode, to simulate a production deployment
+*/
+declare function preview(inlineConfig?: InlineConfig): Promise<PreviewServer>;
+//#endregion
+//#region src/node/shortcuts.d.ts
+type BindCLIShortcutsOptions<Server = ViteDevServer | PreviewServer> = {
+  /**
+  * Print a one-line shortcuts "help" hint to the terminal
+  */
+  print?: boolean;
+  /**
+  * Custom shortcuts to run when a key is pressed. These shortcuts take priority
+  * over the default shortcuts if they have the same keys (except the `h` key).
+  * To disable a default shortcut, define the same key but with `action: undefined`.
+  */
+  customShortcuts?: CLIShortcut<Server>[];
+};
+type CLIShortcut<Server = ViteDevServer | PreviewServer> = {
+  key: string;
+  description: string;
+  action?(server: Server): void | Promise<void>;
+};
+//#endregion
+//#region src/node/baseEnvironment.d.ts
+declare class PartialEnvironment {
+  name: string;
+  getTopLevelConfig(): ResolvedConfig;
+  config: ResolvedConfig & ResolvedEnvironmentOptions;
+  logger: Logger;
+  constructor(name: string, topLevelConfig: ResolvedConfig, options?: ResolvedEnvironmentOptions);
+}
+declare class BaseEnvironment extends PartialEnvironment {
+  get plugins(): readonly Plugin[];
+  constructor(name: string, config: ResolvedConfig, options?: ResolvedEnvironmentOptions);
+}
+/**
+* This class discourages users from inversely checking the `mode`
+* to determine the type of environment, e.g.
+*
+* ```js
+* const isDev = environment.mode !== 'build' // bad
+* const isDev = environment.mode === 'dev'   // good
+* ```
+*
+* You should also not check against `"unknown"` specifically. It's
+* a placeholder for more possible environment types.
+*/
+declare class UnknownEnvironment extends BaseEnvironment {
+  mode: "unknown";
+}
+//#endregion
+//#region src/node/optimizer/scan.d.ts
+declare class ScanEnvironment extends BaseEnvironment {
+  mode: "scan";
+  get pluginContainer(): EnvironmentPluginContainer;
+  init(): Promise<void>;
+}
+//#endregion
+//#region src/node/optimizer/index.d.ts
+type ExportsData = {
+  hasModuleSyntax: boolean;
+  exports: readonly string[];
+  jsxLoader?: boolean;
+};
+interface DepsOptimizer {
+  init: () => Promise<void>;
+  metadata: DepOptimizationMetadata;
+  scanProcessing?: Promise<void>;
+  registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
+  run: () => void;
+  isOptimizedDepFile: (id: string) => boolean;
+  isOptimizedDepUrl: (url: string) => boolean;
+  getOptimizedDepId: (depInfo: OptimizedDepInfo) => string;
+  close: () => Promise<void>;
+  options: DepOptimizationOptions;
+}
+interface DepOptimizationConfig {
+  /**
+  * Force optimize listed dependencies (must be resolvable import paths,
+  * cannot be globs).
+  */
+  include?: string[];
+  /**
+  * Do not optimize these dependencies (must be resolvable import paths,
+  * cannot be globs).
+  */
+  exclude?: string[];
+  /**
+  * Forces ESM interop when importing these dependencies. Some legacy
+  * packages advertise themselves as ESM but use `require` internally
+  * @experimental
+  */
+  needsInterop?: string[];
+  /**
+  * Options to pass to esbuild during the dep scanning and optimization
+  *
+  * Certain options are omitted since changing them would not be compatible
+  * with Vite's dep optimization.
+  *
+  * - `external` is also omitted, use Vite's `optimizeDeps.exclude` option
+  * - `plugins` are merged with Vite's dep plugin
+  *
+  * https://esbuild.github.io/api
+  *
+  * @deprecated Use `rolldownOptions` instead.
+  */
+  esbuildOptions?: DepsOptimizerEsbuildOptions;
+  /**
+  * @deprecated Use `rolldownOptions` instead.
+  */
+  rollupOptions?: Omit<RolldownOptions, "input" | "logLevel" | "output"> & {
+    output?: Omit<OutputOptions, "format" | "sourcemap" | "dir" | "banner">;
+  };
+  /**
+  * Options to pass to rolldown during the dep scanning and optimization
+  *
+  * Certain options are omitted since changing them would not be compatible
+  * with Vite's dep optimization.
+  *
+  * - `plugins` are merged with Vite's dep plugin
+  */
+  rolldownOptions?: Omit<RolldownOptions, "input" | "logLevel" | "output"> & {
+    output?: Omit<OutputOptions, "format" | "sourcemap" | "dir" | "banner">;
+  };
+  /**
+  * List of file extensions that can be optimized. A corresponding esbuild
+  * plugin must exist to handle the specific extension.
+  *
+  * By default, Vite can optimize `.mjs`, `.js`, `.ts`, and `.mts` files. This option
+  * allows specifying additional extensions.
+  *
+  * @experimental
+  */
+  extensions?: string[];
+  /**
+  * Deps optimization during build was removed in Vite 5.1. This option is
+  * now redundant and will be removed in a future version. Switch to using
+  * `optimizeDeps.noDiscovery` and an empty or undefined `optimizeDeps.include`.
+  * true or 'dev' disables the optimizer, false or 'build' leaves it enabled.
+  * @default 'build'
+  * @deprecated
+  * @experimental
+  */
+  disabled?: boolean | "build" | "dev";
+  /**
+  * Automatic dependency discovery. When `noDiscovery` is true, only dependencies
+  * listed in `include` will be optimized. The scanner isn't run for cold start
+  * in this case. CJS-only dependencies must be present in `include` during dev.
+  * @default false
+  */
+  noDiscovery?: boolean;
+  /**
+  * When enabled, it will hold the first optimized deps results until all static
+  * imports are crawled on cold start. This avoids the need for full-page reloads
+  * when new dependencies are discovered and they trigger the generation of new
+  * common chunks. If all dependencies are found by the scanner plus the explicitly
+  * defined ones in `include`, it is better to disable this option to let the
+  * browser process more requests in parallel.
+  * @default true
+  * @experimental
+  */
+  holdUntilCrawlEnd?: boolean;
+  /**
+  * When enabled, Vite will not throw an error when an outdated optimized
+  * dependency is requested. Enabling this option may cause a single module
+  * to have a multiple reference.
+  * @default false
+  * @experimental
+  */
+  ignoreOutdatedRequests?: boolean;
+}
+type DepOptimizationOptions = DepOptimizationConfig & {
+  /**
+  * By default, Vite will crawl your `index.html` to detect dependencies that
+  * need to be pre-bundled. If `build.rolldownOptions.input` is specified, Vite
+  * will crawl those entry points instead.
+  *
+  * If neither of these fit your needs, you can specify custom entries using
+  * this option - the value should be a tinyglobby pattern or array of patterns
+  * (https://github.com/SuperchupuDev/tinyglobby) that are relative from
+  * vite project root. This will overwrite default entries inference.
+  */
+  entries?: string | string[];
+  /**
+  * Force dep pre-optimization regardless of whether deps have changed.
+  * @experimental
+  */
+  force?: boolean;
+};
+interface OptimizedDepInfo {
+  id: string;
+  file: string;
+  src?: string;
+  needsInterop?: boolean;
+  browserHash?: string;
+  fileHash?: string;
+  /**
+  * During optimization, ids can still be resolved to their final location
+  * but the bundles may not yet be saved to disk
+  */
+  processing?: Promise<void>;
+  /**
+  * ExportData cache, discovered deps will parse the src entry to get exports
+  * data used both to define if interop is needed and when pre-bundling
+  */
+  exportsData?: Promise<ExportsData>;
+  isDynamicEntry?: boolean;
+}
+interface DepOptimizationMetadata {
+  /**
+  * The main hash is determined by user config and dependency lockfiles.
+  * This is checked on server startup to avoid unnecessary re-bundles.
+  */
+  hash: string;
+  /**
+  * This hash is determined by dependency lockfiles.
+  * This is checked on server startup to avoid unnecessary re-bundles.
+  */
+  lockfileHash: string;
+  /**
+  * This hash is determined by user config.
+  * This is checked on server startup to avoid unnecessary re-bundles.
+  */
+  configHash: string;
+  /**
+  * The browser hash is determined by the main hash plus additional dependencies
+  * discovered at runtime. This is used to invalidate browser requests to
+  * optimized deps.
+  */
+  browserHash: string;
+  /**
+  * Metadata for each already optimized dependency
+  */
+  optimized: Record<string, OptimizedDepInfo>;
+  /**
+  * Metadata for non-entry optimized chunks and dynamic imports
+  */
+  chunks: Record<string, OptimizedDepInfo>;
+  /**
+  * Metadata for each newly discovered dependency after processing
+  */
+  discovered: Record<string, OptimizedDepInfo>;
+  /**
+  * OptimizedDepInfo list
+  */
+  depInfoList: OptimizedDepInfo[];
+}
+/**
+* Scan and optimize dependencies within a project.
+* Used by Vite CLI when running `vite optimize`.
+*
+* @deprecated the optimization process runs automatically and does not need to be called
+*/
+declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
+//#endregion
+//#region src/node/server/transformRequest.d.ts
+interface TransformResult {
+  code: string;
+  map: SourceMap | {
+    mappings: "";
+  } | null;
+  ssr?: boolean;
+  etag?: string;
+  deps?: string[];
+  dynamicDeps?: string[];
+}
+interface TransformOptions {
+  /**
+  * @deprecated inferred from environment
+  */
+  ssr?: boolean;
+}
+//#endregion
+//#region src/node/server/moduleGraph.d.ts
+declare class EnvironmentModuleNode {
+  environment: string;
+  /**
+  * Public served url path, starts with /
+  */
+  url: string;
+  /**
+  * Resolved file system path + query
+  */
+  id: string | null;
+  file: string | null;
+  type: "js" | "css" | "asset";
+  info?: ModuleInfo;
+  meta?: Record<string, any>;
+  importers: Set<EnvironmentModuleNode>;
+  importedModules: Set<EnvironmentModuleNode>;
+  acceptedHmrDeps: Set<EnvironmentModuleNode>;
+  acceptedHmrExports: Set<string> | null;
+  importedBindings: Map<string, Set<string>> | null;
+  isSelfAccepting?: boolean;
+  transformResult: TransformResult | null;
+  ssrModule: Record<string, any> | null;
+  ssrError: Error | null;
+  lastHMRTimestamp: number;
+  lastInvalidationTimestamp: number;
+  /**
+  * @param setIsSelfAccepting - set `false` to set `isSelfAccepting` later. e.g. #7870
+  */
+  constructor(url: string, environment: string, setIsSelfAccepting?: boolean);
+}
+type ResolvedUrl = [url: string, resolvedId: string, meta: object | null | undefined];
+declare class EnvironmentModuleGraph {
+  environment: string;
+  urlToModuleMap: Map<string, EnvironmentModuleNode>;
+  idToModuleMap: Map<string, EnvironmentModuleNode>;
+  etagToModuleMap: Map<string, EnvironmentModuleNode>;
+  fileToModulesMap: Map<string, Set<EnvironmentModuleNode>>;
+  constructor(environment: string, resolveId: (url: string) => Promise<PartialResolvedId | null>);
+  getModuleByUrl(rawUrl: string): Promise<EnvironmentModuleNode | undefined>;
+  getModuleById(id: string): EnvironmentModuleNode | undefined;
+  getModulesByFile(file: string): Set<EnvironmentModuleNode> | undefined;
+  onFileChange(file: string): void;
+  onFileDelete(file: string): void;
+  invalidateModule(mod: EnvironmentModuleNode, seen?: Set<EnvironmentModuleNode>, timestamp?: number, isHmr?: boolean, softInvalidate?: boolean): void;
+  invalidateAll(): void;
+  /**
+  * Update the module graph based on a module's updated imports information
+  * If there are dependencies that no longer have any importers, they are
+  * returned as a Set.
+  *
+  * @param staticImportedUrls Subset of `importedModules` where they're statically imported in code.
+  *   This is only used for soft invalidations so `undefined` is fine but may cause more runtime processing.
+  */
+  updateModuleInfo(mod: EnvironmentModuleNode, importedModules: Set<string | EnvironmentModuleNode>, importedBindings: Map<string, Set<string>> | null, acceptedModules: Set<string | EnvironmentModuleNode>, acceptedExports: Set<string> | null, isSelfAccepting: boolean, staticImportedUrls?: Set<string>): Promise<Set<EnvironmentModuleNode> | undefined>;
+  ensureEntryFromUrl(rawUrl: string, setIsSelfAccepting?: boolean): Promise<EnvironmentModuleNode>;
+  createFileOnlyEntry(file: string): EnvironmentModuleNode;
+  resolveUrl(url: string): Promise<ResolvedUrl>;
+  updateModuleTransformResult(mod: EnvironmentModuleNode, result: TransformResult | null): void;
+  getModuleByEtag(etag: string): EnvironmentModuleNode | undefined;
+}
+//#endregion
+//#region src/node/server/mixedModuleGraph.d.ts
+declare class ModuleNode {
+  _moduleGraph: ModuleGraph;
+  _clientModule: EnvironmentModuleNode | undefined;
+  _ssrModule: EnvironmentModuleNode | undefined;
+  constructor(moduleGraph: ModuleGraph, clientModule?: EnvironmentModuleNode, ssrModule?: EnvironmentModuleNode);
+  _get<T extends keyof EnvironmentModuleNode>(prop: T): EnvironmentModuleNode[T];
+  _set<T extends keyof EnvironmentModuleNode>(prop: T, value: EnvironmentModuleNode[T]): void;
+  _wrapModuleSet(prop: ModuleSetNames, module: EnvironmentModuleNode | undefined): Set<ModuleNode>;
+  _getModuleSetUnion(prop: "importedModules" | "importers"): Set<ModuleNode>;
+  _getModuleInfoUnion(prop: "info"): ModuleInfo | undefined;
+  _getModuleObjectUnion(prop: "meta"): Record<string, any> | undefined;
+  get url(): string;
+  set url(value: string);
+  get id(): string | null;
+  set id(value: string | null);
+  get file(): string | null;
+  set file(value: string | null);
+  get type(): "js" | "css" | "asset";
+  get info(): ModuleInfo | undefined;
+  get meta(): Record<string, any> | undefined;
+  get importers(): Set<ModuleNode>;
+  get clientImportedModules(): Set<ModuleNode>;
+  get ssrImportedModules(): Set<ModuleNode>;
+  get importedModules(): Set<ModuleNode>;
+  get acceptedHmrDeps(): Set<ModuleNode>;
+  get acceptedHmrExports(): Set<string> | null;
+  get importedBindings(): Map<string, Set<string>> | null;
+  get isSelfAccepting(): boolean | undefined;
+  get transformResult(): TransformResult | null;
+  set transformResult(value: TransformResult | null);
+  get ssrTransformResult(): TransformResult | null;
+  set ssrTransformResult(value: TransformResult | null);
+  get ssrModule(): Record<string, any> | null;
+  get ssrError(): Error | null;
+  get lastHMRTimestamp(): number;
+  set lastHMRTimestamp(value: number);
+  get lastInvalidationTimestamp(): number;
+  get invalidationState(): TransformResult | "HARD_INVALIDATED" | undefined;
+  get ssrInvalidationState(): TransformResult | "HARD_INVALIDATED" | undefined;
+}
+declare class ModuleGraph {
+  urlToModuleMap: Map<string, ModuleNode>;
+  idToModuleMap: Map<string, ModuleNode>;
+  etagToModuleMap: Map<string, ModuleNode>;
+  fileToModulesMap: Map<string, Set<ModuleNode>>;
+  private moduleNodeCache;
+  constructor(moduleGraphs: {
+    client: () => EnvironmentModuleGraph;
+    ssr: () => EnvironmentModuleGraph;
+  });
+  getModuleById(id: string): ModuleNode | undefined;
+  getModuleByUrl(url: string, _ssr?: boolean): Promise<ModuleNode | undefined>;
+  getModulesByFile(file: string): Set<ModuleNode> | undefined;
+  onFileChange(file: string): void;
+  onFileDelete(file: string): void;
+  invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>, timestamp?: number, isHmr?: boolean, softInvalidate?: boolean): void;
+  invalidateAll(): void;
+  ensureEntryFromUrl(rawUrl: string, ssr?: boolean, setIsSelfAccepting?: boolean): Promise<ModuleNode>;
+  createFileOnlyEntry(file: string): ModuleNode;
+  resolveUrl(url: string, ssr?: boolean): Promise<ResolvedUrl>;
+  updateModuleTransformResult(mod: ModuleNode, result: TransformResult | null, ssr?: boolean): void;
+  getModuleByEtag(etag: string): ModuleNode | undefined;
+  getBackwardCompatibleBrowserModuleNode(clientModule: EnvironmentModuleNode): ModuleNode;
+  getBackwardCompatibleServerModuleNode(ssrModule: EnvironmentModuleNode): ModuleNode;
+  getBackwardCompatibleModuleNode(mod: EnvironmentModuleNode): ModuleNode;
+  getBackwardCompatibleModuleNodeDual(clientModule?: EnvironmentModuleNode, ssrModule?: EnvironmentModuleNode): ModuleNode;
+}
+type ModuleSetNames = "acceptedHmrDeps" | "importedModules";
+//#endregion
+//#region src/node/server/hmr.d.ts
+interface HmrOptions {
+  protocol?: string;
+  host?: string;
+  port?: number;
+  clientPort?: number;
+  path?: string;
+  timeout?: number;
+  overlay?: boolean;
+  server?: HttpServer;
+}
+interface HotUpdateOptions {
+  type: "create" | "update" | "delete";
+  file: string;
+  timestamp: number;
+  modules: Array<EnvironmentModuleNode>;
+  read: () => string | Promise<string>;
+  server: ViteDevServer;
+}
+interface HmrContext {
+  file: string;
+  timestamp: number;
+  modules: Array<ModuleNode>;
+  read: () => string | Promise<string>;
+  server: ViteDevServer;
+}
+interface HotChannelClient {
+  send(payload: hmrPayload_HotPayload): void;
+}
+type HotChannelListener<T extends string = string> = (data: InferCustomEventPayload<T>, client: HotChannelClient) => void;
+interface HotChannel<Api = any> {
+  /**
+  * When true, the fs access check is skipped in fetchModule.
+  * Set this for transports that is not exposed over the network.
+  */
+  skipFsCheck?: boolean;
+  /**
+  * Broadcast events to all clients
+  */
+  send?(payload: hmrPayload_HotPayload): void;
+  /**
+  * Handle custom event emitted by `import.meta.hot.send`
+  */
+  on?<T extends string>(event: T, listener: HotChannelListener<T>): void;
+  on?(event: "connection", listener: () => void): void;
+  /**
+  * Unregister event listener
+  */
+  off?(event: string, listener: Function): void;
+  /**
+  * Start listening for messages
+  */
+  listen?(): void;
+  /**
+  * Disconnect all clients, called when server is closed or restarted.
+  */
+  close?(): Promise<unknown> | void;
+  api?: Api;
+}
+interface NormalizedHotChannelClient {
+  /**
+  * Send event to the client
+  */
+  send(payload: hmrPayload_HotPayload): void;
+  /**
+  * Send custom event
+  */
+  send(event: string, payload?: hmrPayload_CustomPayload["data"]): void;
+}
+interface NormalizedHotChannel<Api = any> {
+  /**
+  * Broadcast events to all clients
+  */
+  send(payload: hmrPayload_HotPayload): void;
+  /**
+  * Send custom event
+  */
+  send<T extends string>(event: T, payload?: InferCustomEventPayload<T>): void;
+  /**
+  * Handle custom event emitted by `import.meta.hot.send`
+  */
+  on<T extends string>(event: T, listener: (data: InferCustomEventPayload<T>, client: NormalizedHotChannelClient) => void): void;
+  /**
+  * @deprecated use `vite:client:connect` event instead
+  */
+  on(event: "connection", listener: () => void): void;
+  /**
+  * Unregister event listener
+  */
+  off(event: string, listener: Function): void;
+  handleInvoke(payload: hmrPayload_HotPayload): Promise<{
+    result: any;
+  } | {
+    error: any;
+  }>;
+  /**
+  * Start listening for messages
+  */
+  listen(): void;
+  /**
+  * Disconnect all clients, called when server is closed or restarted.
+  */
+  close(): Promise<unknown> | void;
+  api?: Api;
+}
+type ServerHotChannelApi = {
+  innerEmitter: EventEmitter;
+  outsideEmitter: EventEmitter;
+};
+type ServerHotChannel = HotChannel<ServerHotChannelApi>;
+type NormalizedServerHotChannel = NormalizedHotChannel<ServerHotChannelApi>;
+declare function createServerHotChannel(): ServerHotChannel;
+//#endregion
+//#region src/types/ws.d.ts
+// WebSocket socket.
+declare class WebSocket extends EventEmitter {
+  /** The connection is not yet open. */
+  static readonly CONNECTING: 0;
+  /** The connection is open and ready to communicate. */
+  static readonly OPEN: 1;
+  /** The connection is in the process of closing. */
+  static readonly CLOSING: 2;
+  /** The connection is closed. */
+  static readonly CLOSED: 3;
+  binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments';
+  readonly bufferedAmount: number;
+  readonly extensions: string;
+  /** Indicates whether the websocket is paused */
+  readonly isPaused: boolean;
+  readonly protocol: string;
+  /** The current state of the connection */
+  readonly readyState: typeof WebSocket.CONNECTING | typeof WebSocket.OPEN | typeof WebSocket.CLOSING | typeof WebSocket.CLOSED;
+  readonly url: string;
+  /** The connection is not yet open. */
+  readonly CONNECTING: 0;
+  /** The connection is open and ready to communicate. */
+  readonly OPEN: 1;
+  /** The connection is in the process of closing. */
+  readonly CLOSING: 2;
+  /** The connection is closed. */
+  readonly CLOSED: 3;
+  onopen: ((event: WebSocket.Event) => void) | null;
+  onerror: ((event: WebSocket.ErrorEvent) => void) | null;
+  onclose: ((event: WebSocket.CloseEvent) => void) | null;
+  onmessage: ((event: WebSocket.MessageEvent) => void) | null;
+  constructor(address: null);
+  constructor(address: string | url_URL, options?: WebSocket.ClientOptions | ClientRequestArgs);
+  constructor(address: string | url_URL, protocols?: string | string[], options?: WebSocket.ClientOptions | ClientRequestArgs);
+  close(code?: number, data?: string | Buffer): void;
+  ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+  pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+  send(data: any, cb?: (err?: Error) => void): void;
+  send(data: any, options: {
+    mask?: boolean | undefined;
+    binary?: boolean | undefined;
+    compress?: boolean | undefined;
+    fin?: boolean | undefined;
+  }, cb?: (err?: Error) => void): void;
+  terminate(): void;
+  /**
+   * Pause the websocket causing it to stop emitting events. Some events can still be
+   * emitted after this is called, until all buffered data is consumed. This method
+   * is a noop if the ready state is `CONNECTING` or `CLOSED`.
+   */
+  pause(): void;
+  /**
+   * Make a paused socket resume emitting events. This method is a noop if the ready
+   * state is `CONNECTING` or `CLOSED`.
+   */
+  resume(): void; // HTML5 WebSocket events
+  addEventListener(method: 'message', cb: (event: WebSocket.MessageEvent) => void, options?: WebSocket.EventListenerOptions): void;
+  addEventListener(method: 'close', cb: (event: WebSocket.CloseEvent) => void, options?: WebSocket.EventListenerOptions): void;
+  addEventListener(method: 'error', cb: (event: WebSocket.ErrorEvent) => void, options?: WebSocket.EventListenerOptions): void;
+  addEventListener(method: 'open', cb: (event: WebSocket.Event) => void, options?: WebSocket.EventListenerOptions): void;
+  removeEventListener(method: 'message', cb: (event: WebSocket.MessageEvent) => void): void;
+  removeEventListener(method: 'close', cb: (event: WebSocket.CloseEvent) => void): void;
+  removeEventListener(method: 'error', cb: (event: WebSocket.ErrorEvent) => void): void;
+  removeEventListener(method: 'open', cb: (event: WebSocket.Event) => void): void; // Events
+  on(event: 'close', listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
+  on(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
+  on(event: 'upgrade', listener: (this: WebSocket, request: http.IncomingMessage) => void): this;
+  on(event: 'message', listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
+  on(event: 'open', listener: (this: WebSocket) => void): this;
+  on(event: 'ping' | 'pong', listener: (this: WebSocket, data: Buffer) => void): this;
+  on(event: 'unexpected-response', listener: (this: WebSocket, request: ClientRequest, response: http.IncomingMessage) => void): this;
+  on(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
+  once(event: 'close', listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
+  once(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
+  once(event: 'upgrade', listener: (this: WebSocket, request: http.IncomingMessage) => void): this;
+  once(event: 'message', listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
+  once(event: 'open', listener: (this: WebSocket) => void): this;
+  once(event: 'ping' | 'pong', listener: (this: WebSocket, data: Buffer) => void): this;
+  once(event: 'unexpected-response', listener: (this: WebSocket, request: ClientRequest, response: http.IncomingMessage) => void): this;
+  once(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
+  off(event: 'close', listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
+  off(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
+  off(event: 'upgrade', listener: (this: WebSocket, request: http.IncomingMessage) => void): this;
+  off(event: 'message', listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
+  off(event: 'open', listener: (this: WebSocket) => void): this;
+  off(event: 'ping' | 'pong', listener: (this: WebSocket, data: Buffer) => void): this;
+  off(event: 'unexpected-response', listener: (this: WebSocket, request: ClientRequest, response: http.IncomingMessage) => void): this;
+  off(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
+  addListener(event: 'close', listener: (code: number, reason: Buffer) => void): this;
+  addListener(event: 'error', listener: (err: Error) => void): this;
+  addListener(event: 'upgrade', listener: (request: http.IncomingMessage) => void): this;
+  addListener(event: 'message', listener: (data: WebSocket.RawData, isBinary: boolean) => void): this;
+  addListener(event: 'open', listener: () => void): this;
+  addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this;
+  addListener(event: 'unexpected-response', listener: (request: ClientRequest, response: http.IncomingMessage) => void): this;
+  addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+  removeListener(event: 'close', listener: (code: number, reason: Buffer) => void): this;
+  removeListener(event: 'error', listener: (err: Error) => void): this;
+  removeListener(event: 'upgrade', listener: (request: http.IncomingMessage) => void): this;
+  removeListener(event: 'message', listener: (data: WebSocket.RawData, isBinary: boolean) => void): this;
+  removeListener(event: 'open', listener: () => void): this;
+  removeListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this;
+  removeListener(event: 'unexpected-response', listener: (request: ClientRequest, response: http.IncomingMessage) => void): this;
+  removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+declare const WebSocketAlias: typeof WebSocket;
+interface WebSocketAlias extends WebSocket {}
+declare namespace WebSocket {
+  /**
+   * Data represents the raw message payload received over the WebSocket.
+   */
+  type RawData = Buffer | ArrayBuffer | Buffer[];
+  /**
+   * Data represents the message payload received over the WebSocket.
+   */
+  type Data = string | Buffer | ArrayBuffer | Buffer[];
+  /**
+   * CertMeta represents the accepted types for certificate & key data.
+   */
+  type CertMeta = string | string[] | Buffer | Buffer[];
+  /**
+   * VerifyClientCallbackSync is a synchronous callback used to inspect the
+   * incoming message. The return value (boolean) of the function determines
+   * whether or not to accept the handshake.
+   */
+  type VerifyClientCallbackSync = (info: {
+    origin: string;
+    secure: boolean;
+    req: http.IncomingMessage;
+  }) => boolean;
+  /**
+   * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+   * incoming message. The return value (boolean) of the function determines
+   * whether or not to accept the handshake.
+   */
+  type VerifyClientCallbackAsync = (info: {
+    origin: string;
+    secure: boolean;
+    req: http.IncomingMessage;
+  }, callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void) => void;
+  interface ClientOptions extends SecureContextOptions {
+    protocol?: string | undefined;
+    followRedirects?: boolean | undefined;
+    generateMask?(mask: Buffer): void;
+    handshakeTimeout?: number | undefined;
+    maxRedirects?: number | undefined;
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+    localAddress?: string | undefined;
+    protocolVersion?: number | undefined;
+    headers?: {
+      [key: string]: string;
+    } | undefined;
+    origin?: string | undefined;
+    agent?: Agent | undefined;
+    host?: string | undefined;
+    family?: number | undefined;
+    checkServerIdentity?(servername: string, cert: CertMeta): boolean;
+    rejectUnauthorized?: boolean | undefined;
+    maxPayload?: number | undefined;
+    skipUTF8Validation?: boolean | undefined;
+  }
+  interface PerMessageDeflateOptions {
+    serverNoContextTakeover?: boolean | undefined;
+    clientNoContextTakeover?: boolean | undefined;
+    serverMaxWindowBits?: number | undefined;
+    clientMaxWindowBits?: number | undefined;
+    zlibDeflateOptions?: {
+      flush?: number | undefined;
+      finishFlush?: number | undefined;
+      chunkSize?: number | undefined;
+      windowBits?: number | undefined;
+      level?: number | undefined;
+      memLevel?: number | undefined;
+      strategy?: number | undefined;
+      dictionary?: Buffer | Buffer[] | DataView | undefined;
+      info?: boolean | undefined;
+    } | undefined;
+    zlibInflateOptions?: ZlibOptions | undefined;
+    threshold?: number | undefined;
+    concurrencyLimit?: number | undefined;
+  }
+  interface Event {
+    type: string;
+    target: WebSocket;
+  }
+  interface ErrorEvent {
+    error: any;
+    message: string;
+    type: string;
+    target: WebSocket;
+  }
+  interface CloseEvent {
+    wasClean: boolean;
+    code: number;
+    reason: string;
+    type: string;
+    target: WebSocket;
+  }
+  interface MessageEvent {
+    data: Data;
+    type: string;
+    target: WebSocket;
+  }
+  interface EventListenerOptions {
+    once?: boolean | undefined;
+  }
+  interface ServerOptions {
+    host?: string | undefined;
+    port?: number | undefined;
+    backlog?: number | undefined;
+    server?: http.Server | HttpsServer | undefined;
+    verifyClient?: VerifyClientCallbackAsync | VerifyClientCallbackSync | undefined;
+    handleProtocols?: (protocols: Set<string>, request: http.IncomingMessage) => string | false;
+    path?: string | undefined;
+    noServer?: boolean | undefined;
+    clientTracking?: boolean | undefined;
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+    maxPayload?: number | undefined;
+    skipUTF8Validation?: boolean | undefined;
+    WebSocket?: typeof WebSocket.WebSocket | undefined;
+  }
+  interface AddressInfo {
+    address: string;
+    family: string;
+    port: number;
+  } // WebSocket Server
+  class Server<T extends WebSocket = WebSocket> extends EventEmitter {
+    options: ServerOptions;
+    path: string;
+    clients: Set<T>;
+    constructor(options?: ServerOptions, callback?: () => void);
+    address(): AddressInfo | string;
+    close(cb?: (err?: Error) => void): void;
+    handleUpgrade(request: http.IncomingMessage, socket: Duplex, upgradeHead: Buffer, callback: (client: T, request: http.IncomingMessage) => void): void;
+    shouldHandle(request: http.IncomingMessage): boolean | Promise<boolean>; // Events
+    on(event: 'connection', cb: (this: Server<T>, socket: T, request: http.IncomingMessage) => void): this;
+    on(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
+    on(event: 'headers', cb: (this: Server<T>, headers: string[], request: http.IncomingMessage) => void): this;
+    on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
+    on(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    once(event: 'connection', cb: (this: Server<T>, socket: T, request: http.IncomingMessage) => void): this;
+    once(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
+    once(event: 'headers', cb: (this: Server<T>, headers: string[], request: http.IncomingMessage) => void): this;
+    once(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
+    once(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    off(event: 'connection', cb: (this: Server<T>, socket: T, request: http.IncomingMessage) => void): this;
+    off(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
+    off(event: 'headers', cb: (this: Server<T>, headers: string[], request: http.IncomingMessage) => void): this;
+    off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
+    off(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    addListener(event: 'connection', cb: (client: T, request: http.IncomingMessage) => void): this;
+    addListener(event: 'error', cb: (err: Error) => void): this;
+    addListener(event: 'headers', cb: (headers: string[], request: http.IncomingMessage) => void): this;
+    addListener(event: 'close' | 'listening', cb: () => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(event: 'connection', cb: (client: T) => void): this;
+    removeListener(event: 'error', cb: (err: Error) => void): this;
+    removeListener(event: 'headers', cb: (headers: string[], request: http.IncomingMessage) => void): this;
+    removeListener(event: 'close' | 'listening', cb: () => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+  }
+  const WebSocketServer: typeof Server;
+  interface WebSocketServer extends Server {}
+  const WebSocket: typeof WebSocketAlias;
+  interface WebSocket extends WebSocketAlias {} // WebSocket stream
+  function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
+} // export = WebSocket
+//#endregion
+//#region src/node/server/ws.d.ts
+type WebSocketCustomListener<T> = (data: T, client: WebSocketClient) => void;
+declare const isWebSocketServer: unique symbol;
+interface WebSocketServer extends NormalizedHotChannel {
+  /**
+  * Handle custom event emitted by `import.meta.hot.send`
+  */
+  on: WebSocket.Server["on"] & {
+    <T extends string>(event: T, listener: WebSocketCustomListener<hmrPayload_InferCustomEventPayload<T>>): void;
+  };
+  /**
+  * Unregister event listener.
+  */
+  off: WebSocket.Server["off"] & {
+    (event: string, listener: Function): void;
+  };
+  /**
+  * Listen on port and host
+  */
+  listen(): void;
+  /**
+  * Disconnect all clients and terminate the server.
+  */
+  close(): Promise<void>;
+  [isWebSocketServer]: true;
+  /**
+  * Get all connected clients.
+  */
+  clients: Set<WebSocketClient>;
+}
+interface WebSocketClient extends NormalizedHotChannelClient {
+  /**
+  * The raw WebSocket instance
+  * @advanced
+  */
+  socket: WebSocket;
+}
+//#endregion
+//#region src/node/server/environment.d.ts
+interface DevEnvironmentContext {
+  hot: boolean;
+  transport?: HotChannel | WebSocketServer;
+  options?: EnvironmentOptions;
+  remoteRunner?: {
+    inlineSourceMap?: boolean;
+  };
+  depsOptimizer?: DepsOptimizer;
+}
+declare class DevEnvironment extends BaseEnvironment {
+  mode: "dev";
+  moduleGraph: EnvironmentModuleGraph;
+  depsOptimizer?: DepsOptimizer;
+  get pluginContainer(): EnvironmentPluginContainer<DevEnvironment>;
+  /**
+  * Hot channel for this environment. If not provided or disabled,
+  * it will be a noop channel that does nothing.
+  *
+  * @example
+  * environment.hot.send({ type: 'full-reload' })
+  */
+  hot: NormalizedHotChannel;
+  constructor(name: string, config: ResolvedConfig, context: DevEnvironmentContext);
+  init(options?: {
+    watcher?: FSWatcher;
+    /**
+    * the previous instance used for the environment with the same name
+    *
+    * when using, the consumer should check if it's an instance generated from the same class or factory function
+    */
+    previousInstance?: DevEnvironment;
+  }): Promise<void>;
+  /**
+  * When the dev server is restarted, the methods are called in the following order:
+  * - new instance `init`
+  * - previous instance `close`
+  * - new instance `listen`
+  */
+  listen(server: ViteDevServer): Promise<void>;
+  /**
+  * Called by the module runner to retrieve information about the specified
+  * module. Internally calls `transformRequest` and wraps the result in the
+  * format that the module runner understands.
+  * This method is not meant to be called manually.
+  */
+  fetchModule(id: string, importer?: string, options?: FetchFunctionOptions): Promise<moduleRunner_FetchResult>;
+  reloadModule(module: EnvironmentModuleNode): Promise<void>;
+  transformRequest(url: string): Promise<TransformResult | null>;
+  warmupRequest(url: string): Promise<void>;
+  protected invalidateModule(m: {
+    path: string;
+    message?: string;
+    firstInvalidatedBy: string;
+  }, _client: NormalizedHotChannelClient): void;
+  close(): Promise<void>;
+  /**
+  * Calling `await environment.waitForRequestsIdle(id)` will wait until all static imports
+  * are processed after the first transformRequest call. If called from a load or transform
+  * plugin hook, the id needs to be passed as a parameter to avoid deadlocks.
+  * Calling this function after the first static imports section of the module graph has been
+  * processed will resolve immediately.
+  * @experimental
+  */
+  waitForRequestsIdle(ignoredId?: string): Promise<void>;
+}
+//#endregion
+//#region src/types/commonjs.d.ts
+
+interface RollupCommonJSOptions {
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should operate on. By default, all files with
+   * extension `".cjs"` or those in `extensions` are included, but you can
+   * narrow this list by only including specific files. These files will be
+   * analyzed and transpiled if either the analysis does not find ES module
+   * specific statements or `transformMixedEsModules` is `true`.
+   * @default undefined
+   */
+  include?: string | RegExp | readonly (string | RegExp)[];
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should _ignore_. By default, all files with
+   * extensions other than those in `extensions` or `".cjs"` are ignored, but you
+   * can exclude additional files. See also the `include` option.
+   * @default undefined
+   */
+  exclude?: string | RegExp | readonly (string | RegExp)[];
+  /**
+   * For extensionless imports, search for extensions other than .js in the
+   * order specified. Note that you need to make sure that non-JavaScript files
+   * are transpiled by another plugin first.
+   * @default [ '.js' ]
+   */
+  extensions?: ReadonlyArray<string>;
+  /**
+   * If true then uses of `global` won't be dealt with by this plugin
+   * @default false
+   */
+  ignoreGlobal?: boolean;
+  /**
+   * If false, skips source map generation for CommonJS modules. This will
+   * improve performance.
+   * @default true
+   */
+  sourceMap?: boolean;
+  /**
+   * Some `require` calls cannot be resolved statically to be translated to
+   * imports.
+   * When this option is set to `false`, the generated code will either
+   * directly throw an error when such a call is encountered or, when
+   * `dynamicRequireTargets` is used, when such a call cannot be resolved with a
+   * configured dynamic require target.
+   * Setting this option to `true` will instead leave the `require` call in the
+   * code or use it as a fallback for `dynamicRequireTargets`.
+   * @default false
+   */
+  ignoreDynamicRequires?: boolean;
+  /**
+   * Instructs the plugin whether to enable mixed module transformations. This
+   * is useful in scenarios with modules that contain a mix of ES `import`
+   * statements and CommonJS `require` expressions. Set to `true` if `require`
+   * calls should be transformed to imports in mixed modules, or `false` if the
+   * `require` expressions should survive the transformation. The latter can be
+   * important if the code contains environment detection, or you are coding
+   * for an environment with special treatment for `require` calls such as
+   * ElectronJS. See also the `ignore` option.
+   * @default false
+   */
+  transformMixedEsModules?: boolean;
+  /**
+   * By default, this plugin will try to hoist `require` statements as imports
+   * to the top of each file. While this works well for many code bases and
+   * allows for very efficient ESM output, it does not perfectly capture
+   * CommonJS semantics as the order of side effects like log statements may
+   * change. But it is especially problematic when there are circular `require`
+   * calls between CommonJS modules as those often rely on the lazy execution of
+   * nested `require` calls.
+   *
+   * Setting this option to `true` will wrap all CommonJS files in functions
+   * which are executed when they are required for the first time, preserving
+   * NodeJS semantics. Note that this can have an impact on the size and
+   * performance of the generated code.
+   *
+   * The default value of `"auto"` will only wrap CommonJS files when they are
+   * part of a CommonJS dependency cycle, e.g. an index file that is required by
+   * many of its dependencies. All other CommonJS files are hoisted. This is the
+   * recommended setting for most code bases.
+   *
+   * `false` will entirely prevent wrapping and hoist all files. This may still
+   * work depending on the nature of cyclic dependencies but will often cause
+   * problems.
+   *
+   * You can also provide a minimatch pattern, or array of patterns, to only
+   * specify a subset of files which should be wrapped in functions for proper
+   * `require` semantics.
+   *
+   * `"debug"` works like `"auto"` but after bundling, it will display a warning
+   * containing a list of ids that have been wrapped which can be used as
+   * minimatch pattern for fine-tuning.
+   * @default "auto"
+   */
+  strictRequires?: boolean | string | RegExp | readonly (string | RegExp)[];
+  /**
+   * Sometimes you have to leave require statements unconverted. Pass an array
+   * containing the IDs or a `id => boolean` function.
+   * @default []
+   */
+  ignore?: ReadonlyArray<string> | ((id: string) => boolean);
+  /**
+   * In most cases, where `require` calls are inside a `try-catch` clause,
+   * they should be left unconverted as it requires an optional dependency
+   * that may or may not be installed beside the rolled up package.
+   * Due to the conversion of `require` to a static `import` - the call is
+   * hoisted to the top of the file, outside the `try-catch` clause.
+   *
+   * - `true`: Default. All `require` calls inside a `try` will be left unconverted.
+   * - `false`: All `require` calls inside a `try` will be converted as if the
+   *   `try-catch` clause is not there.
+   * - `remove`: Remove all `require` calls from inside any `try` block.
+   * - `string[]`: Pass an array containing the IDs to left unconverted.
+   * - `((id: string) => boolean|'remove')`: Pass a function that controls
+   *   individual IDs.
+   *
+   * @default true
+   */
+  ignoreTryCatch?: boolean | 'remove' | ReadonlyArray<string> | ((id: string) => boolean | 'remove');
+  /**
+   * Controls how to render imports from external dependencies. By default,
+   * this plugin assumes that all external dependencies are CommonJS. This
+   * means they are rendered as default imports to be compatible with e.g.
+   * NodeJS where ES modules can only import a default export from a CommonJS
+   * dependency.
+   *
+   * If you set `esmExternals` to `true`, this plugin assumes that all
+   * external dependencies are ES modules and respect the
+   * `requireReturnsDefault` option. If that option is not set, they will be
+   * rendered as namespace imports.
+   *
+   * You can also supply an array of ids to be treated as ES modules, or a
+   * function that will be passed each external id to determine whether it is
+   * an ES module.
+   * @default false
+   */
+  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean);
+  /**
+   * Controls what is returned when requiring an ES module from a CommonJS file.
+   * When using the `esmExternals` option, this will also apply to external
+   * modules. By default, this plugin will render those imports as namespace
+   * imports i.e.
+   *
+   * ```js
+   * // input
+   * const foo = require('foo');
+   *
+   * // output
+   * import * as foo from 'foo';
+   * ```
+   *
+   * However, there are some situations where this may not be desired.
+   * For these situations, you can change Rollup's behaviour either globally or
+   * per module. To change it globally, set the `requireReturnsDefault` option
+   * to one of the following values:
+   *
+   * - `false`: This is the default, requiring an ES module returns its
+   *   namespace. This is the only option that will also add a marker
+   *   `__esModule: true` to the namespace to support interop patterns in
+   *   CommonJS modules that are transpiled ES modules.
+   * - `"namespace"`: Like `false`, requiring an ES module returns its
+   *   namespace, but the plugin does not add the `__esModule` marker and thus
+   *   creates more efficient code. For external dependencies when using
+   *   `esmExternals: true`, no additional interop code is generated.
+   * - `"auto"`: This is complementary to how `output.exports: "auto"` works in
+   *   Rollup: If a module has a default export and no named exports, requiring
+   *   that module returns the default export. In all other cases, the namespace
+   *   is returned. For external dependencies when using `esmExternals: true`, a
+   *   corresponding interop helper is added.
+   * - `"preferred"`: If a module has a default export, requiring that module
+   *   always returns the default export, no matter whether additional named
+   *   exports exist. This is similar to how previous versions of this plugin
+   *   worked. Again for external dependencies when using `esmExternals: true`,
+   *   an interop helper is added.
+   * - `true`: This will always try to return the default export on require
+   *   without checking if it actually exists. This can throw at build time if
+   *   there is no default export. This is how external dependencies are handled
+   *   when `esmExternals` is not used. The advantage over the other options is
+   *   that, like `false`, this does not add an interop helper for external
+   *   dependencies, keeping the code lean.
+   *
+   * To change this for individual modules, you can supply a function for
+   * `requireReturnsDefault` instead. This function will then be called once for
+   * each required ES module or external dependency with the corresponding id
+   * and allows you to return different values for different modules.
+   * @default false
+   */
+  requireReturnsDefault?: boolean | 'auto' | 'preferred' | 'namespace' | ((id: string) => boolean | 'auto' | 'preferred' | 'namespace');
+  /**
+   * @default "auto"
+   */
+  defaultIsModuleExports?: boolean | 'auto' | ((id: string) => boolean | 'auto');
+  /**
+   * Some modules contain dynamic `require` calls, or require modules that
+   * contain circular dependencies, which are not handled well by static
+   * imports. Including those modules as `dynamicRequireTargets` will simulate a
+   * CommonJS (NodeJS-like) environment for them with support for dynamic
+   * dependencies. It also enables `strictRequires` for those modules.
+   *
+   * Note: In extreme cases, this feature may result in some paths being
+   * rendered as absolute in the final bundle. The plugin tries to avoid
+   * exposing paths from the local machine, but if you are `dynamicRequirePaths`
+   * with paths that are far away from your project's folder, that may require
+   * replacing strings like `"/Users/John/Desktop/foo-project/"` -\> `"/"`.
+   */
+  dynamicRequireTargets?: string | ReadonlyArray<string>;
+  /**
+   * To avoid long paths when using the `dynamicRequireTargets` option, you can use this option to specify a directory
+   * that is a common parent for all files that use dynamic require statements. Using a directory higher up such as `/`
+   * may lead to unnecessarily long paths in the generated code and may expose directory names on your machine like your
+   * home directory name. By default, it uses the current working directory.
+   */
+  dynamicRequireRoot?: string;
+}
+//#endregion
+//#region src/types/dynamicImportVars.d.ts
+interface RollupDynamicImportVarsOptions {
+  /**
+   * Files to include in this plugin (default all).
+   * @default []
+   */
+  include?: string | RegExp | (string | RegExp)[];
+  /**
+   * Files to exclude in this plugin (default none).
+   * @default []
+   */
+  exclude?: string | RegExp | (string | RegExp)[];
+  /**
+   * @deprecated This option is no-op and will be removed in future versions.
+   */
+  warnOnError?: boolean;
+}
+//#endregion
+//#region src/node/plugins/terser.d.ts
+interface TerserOptions extends TerserMinifyOptions {
+  /**
+  * Vite-specific option to specify the max number of workers to spawn
+  * when minifying files with terser.
+  *
+  * @default number of CPUs minus 1
+  */
+  maxWorkers?: number;
+}
+//#endregion
+//#region src/node/plugins/resolve.d.ts
+interface EnvironmentResolveOptions {
+  /**
+  * @default ['browser', 'module', 'jsnext:main', 'jsnext']
+  */
+  mainFields?: string[];
+  conditions?: string[];
+  externalConditions?: string[];
+  /**
+  * @default ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']
+  */
+  extensions?: string[];
+  dedupe?: string[];
+  /**
+  * Prevent listed dependencies from being externalized and will get bundled in build.
+  * Only works in server environments for now. Previously this was `ssr.noExternal`.
+  * @experimental
+  */
+  noExternal?: string | RegExp | (string | RegExp)[] | true;
+  /**
+  * Externalize the given dependencies and their transitive dependencies.
+  * Only works in server environments for now. Previously this was `ssr.external`.
+  * @experimental
+  */
+  external?: string[] | true;
+  /**
+  * Array of strings or regular expressions that indicate what modules are builtin for the environment.
+  */
+  builtins?: (string | RegExp)[];
+}
+interface ResolveOptions extends EnvironmentResolveOptions {
+  /**
+  * @default false
+  */
+  preserveSymlinks?: boolean;
+  /**
+  * Enable tsconfig paths resolution
+  *
+  * @default false
+  * @experimental
+  */
+  tsconfigPaths?: boolean;
+}
+interface ResolvePluginOptions {
+  root: string;
+  isBuild: boolean;
+  isProduction: boolean;
+  packageCache?: PackageCache;
+  /**
+  * src code mode also attempts the following:
+  * - resolving /xxx as URLs
+  * - resolving bare imports from optimized deps
+  */
+  asSrc?: boolean;
+  tryIndex?: boolean;
+  tryPrefix?: string;
+  preferRelative?: boolean;
+  isRequire?: boolean;
+  scan?: boolean;
+  /**
+  * Enable when `legacy.inconsistentCjsInterop` is true. See that option for more details.
+  */
+  legacyInconsistentCjsInterop?: boolean;
+}
+interface InternalResolveOptions extends Required<ResolveOptions>, ResolvePluginOptions {}
+//#endregion
+//#region src/node/packages.d.ts
+/** Cache for package.json resolution and package.json contents */
+type PackageCache = Map<string, PackageData>;
+interface PackageData {
+  dir: string;
+  hasSideEffects: (id: string) => boolean | "no-treeshake" | null;
+  setResolvedCache: (key: string, entry: string, options: InternalResolveOptions) => void;
+  getResolvedCache: (key: string, options: InternalResolveOptions) => string | undefined;
+  data: {
+    [field: string]: any;
+    name: string;
+    type: string;
+    version: string;
+    main: string;
+    module: string;
+    browser: string | Record<string, string | false>;
+    exports: string | Record<string, any> | string[];
+    imports: Record<string, any>;
+    dependencies: Record<string, string>;
+  };
+}
+//#endregion
+//#region src/node/plugins/license.d.ts
+interface LicenseOptions {
+  /**
+  * The output file name of the license file relative to the output directory.
+  * Specify a path that ends with `.json` to output the raw JSON metadata.
+  *
+  * @default '.vite/license.md'
+  */
+  fileName: string;
+}
+//#endregion
+//#region src/node/build.d.ts
+interface BuildEnvironmentOptions {
+  /**
+  * Compatibility transform target. The transform is performed with esbuild
+  * and the lowest supported target is es2015. Note this only handles
+  * syntax transformation and does not cover polyfills
+  *
+  * Default: 'baseline-widely-available' - transpile targeting browsers that
+  * are included in the Baseline Widely Available on 2026-01-01.
+  * (Chrome 111+, Edge 111+, Firefox 114+, Safari 16.4+).
+  *
+  * Another special value is 'esnext' - which only performs minimal transpiling
+  * (for minification compat).
+  *
+  * For custom targets, see https://esbuild.github.io/api/#target and
+  * https://esbuild.github.io/content-types/#javascript for more details.
+  * @default 'baseline-widely-available'
+  */
+  target?: "baseline-widely-available" | EsbuildTarget | false;
+  /**
+  * whether to inject module preload polyfill.
+  * Note: does not apply to library mode.
+  * @default true
+  * @deprecated use `modulePreload.polyfill` instead
+  */
+  polyfillModulePreload?: boolean;
+  /**
+  * Configure module preload
+  * Note: does not apply to library mode.
+  * @default true
+  */
+  modulePreload?: boolean | ModulePreloadOptions;
+  /**
+  * Directory relative from `root` where build output will be placed. If the
+  * directory exists, it will be removed before the build.
+  * @default 'dist'
+  */
+  outDir?: string;
+  /**
+  * Directory relative from `outDir` where the built js/css/image assets will
+  * be placed.
+  * @default 'assets'
+  */
+  assetsDir?: string;
+  /**
+  * Static asset files smaller than this number (in bytes) will be inlined as
+  * base64 strings. If a callback is passed, a boolean can be returned to opt-in
+  * or opt-out of inlining. If nothing is returned the default logic applies.
+  *
+  * Default limit is `4096` (4 KiB). Set to `0` to disable.
+  * @default 4096
+  */
+  assetsInlineLimit?: number | ((filePath: string, content: Buffer) => boolean | undefined);
+  /**
+  * Whether to code-split CSS. When enabled, CSS in async chunks will be
+  * inlined as strings in the chunk and inserted via dynamically created
+  * style tags when the chunk is loaded.
+  * @default true
+  */
+  cssCodeSplit?: boolean;
+  /**
+  * An optional separate target for CSS minification.
+  * As esbuild only supports configuring targets to mainstream
+  * browsers, users may need this option when they are targeting
+  * a niche browser that comes with most modern JavaScript features
+  * but has poor CSS support, e.g. Android WeChat WebView, which
+  * doesn't support the #RGBA syntax.
+  * @default target
+  */
+  cssTarget?: EsbuildTarget | false;
+  /**
+  * Override CSS minification specifically instead of defaulting to `build.minify`,
+  * so you can configure minification for JS and CSS separately.
+  * @default 'lightningcss'
+  */
+  cssMinify?: boolean | "lightningcss" | "esbuild";
+  /**
+  * If `true`, a separate sourcemap file will be created. If 'inline', the
+  * sourcemap will be appended to the resulting output file as data URI.
+  * 'hidden' works like `true` except that the corresponding sourcemap
+  * comments in the bundled files are suppressed.
+  * @default false
+  */
+  sourcemap?: boolean | "inline" | "hidden";
+  /**
+  * Set to `false` to disable minification, or specify the minifier to use.
+  * Available options are 'oxc' or 'terser' or 'esbuild'.
+  * @default 'oxc'
+  */
+  minify?: boolean | "oxc" | "terser" | "esbuild";
+  /**
+  * Options for terser
+  * https://terser.org/docs/api-reference#minify-options
+  *
+  * In addition, you can also pass a `maxWorkers: number` option to specify the
+  * max number of workers to spawn. Defaults to the number of CPUs minus 1.
+  */
+  terserOptions?: TerserOptions;
+  /**
+  * Alias to `rolldownOptions`
+  * @deprecated Use `rolldownOptions` instead.
+  */
+  rollupOptions?: RolldownOptions;
+  /**
+  * Will be merged with internal rolldown options.
+  * https://rolldown.rs/reference/config-options
+  */
+  rolldownOptions?: RolldownOptions;
+  /**
+  * Options to pass on to `@rollup/plugin-commonjs`
+  * @deprecated This option is no-op and will be removed in future versions.
+  */
+  commonjsOptions?: RollupCommonJSOptions;
+  /**
+  * Options to pass on to `@rollup/plugin-dynamic-import-vars`
+  */
+  dynamicImportVarsOptions?: RollupDynamicImportVarsOptions;
+  /**
+  * Whether to write bundle to disk
+  * @default true
+  */
+  write?: boolean;
+  /**
+  * Empty outDir on write.
+  * @default true when outDir is a sub directory of project root
+  */
+  emptyOutDir?: boolean | null;
+  /**
+  * Copy the public directory to outDir on write.
+  * @default true
+  */
+  copyPublicDir?: boolean;
+  /**
+  * Whether to emit a `.vite/license.md` file that includes all bundled dependencies'
+  * licenses. Pass an object to customize the output file name.
+  * @default false
+  */
+  license?: boolean | LicenseOptions;
+  /**
+  * Whether to emit a .vite/manifest.json in the output dir to map hash-less filenames
+  * to their hashed versions. Useful when you want to generate your own HTML
+  * instead of using the one generated by Vite.
+  *
+  * Example:
+  *
+  * ```json
+  * {
+  *   "main.js": {
+  *     "file": "main.68fe3fad.js",
+  *     "css": "main.e6b63442.css",
+  *     "imports": [...],
+  *     "dynamicImports": [...]
+  *   }
+  * }
+  * ```
+  * @default false
+  */
+  manifest?: boolean | string;
+  /**
+  * Build in library mode. The value should be the global name of the lib in
+  * UMD mode. This will produce esm + cjs + umd bundle formats with default
+  * configurations that are suitable for distributing libraries.
+  * @default false
+  */
+  lib?: LibraryOptions | false;
+  /**
+  * Produce SSR oriented build. Note this requires specifying SSR entry via
+  * `rollupOptions.input`.
+  * @default false
+  */
+  ssr?: boolean | string;
+  /**
+  * Generate SSR manifest for determining style links and asset preload
+  * directives in production.
+  * @default false
+  */
+  ssrManifest?: boolean | string;
+  /**
+  * Emit assets during SSR.
+  * @default false
+  */
+  ssrEmitAssets?: boolean;
+  /**
+  * Emit assets during build. Frameworks can set environments.ssr.build.emitAssets
+  * By default, it is true for the client and false for other environments.
+  */
+  emitAssets?: boolean;
+  /**
+  * Set to false to disable reporting compressed chunk sizes.
+  * Can slightly improve build speed.
+  * @default true
+  */
+  reportCompressedSize?: boolean;
+  /**
+  * Adjust chunk size warning limit (in kB).
+  * @default 500
+  */
+  chunkSizeWarningLimit?: number;
+  /**
+  * Rollup watch options
+  * https://rollupjs.org/configuration-options/#watch
+  * @default null
+  */
+  watch?: WatcherOptions | null;
+  /**
+  * create the Build Environment instance
+  */
+  createEnvironment?: (name: string, config: ResolvedConfig) => Promise<BuildEnvironment> | BuildEnvironment;
+}
+type BuildOptions = BuildEnvironmentOptions;
+interface LibraryOptions {
+  /**
+  * Path of library entry
+  */
+  entry: InputOption;
+  /**
+  * The name of the exposed global variable. Required when the `formats` option includes
+  * `umd` or `iife`
+  */
+  name?: string;
+  /**
+  * Output bundle formats
+  * @default ['es', 'umd']
+  */
+  formats?: LibraryFormats[];
+  /**
+  * The name of the package file output. The default file name is the name option
+  * of the project package.json. It can also be defined as a function taking the
+  * format as an argument.
+  */
+  fileName?: string | ((format: ModuleFormat, entryName: string) => string);
+  /**
+  * The name of the CSS file output if the library imports CSS. Defaults to the
+  * same value as `build.lib.fileName` if it's set a string, otherwise it falls
+  * back to the name option of the project package.json.
+  */
+  cssFileName?: string;
+}
+type LibraryFormats = "es" | "cjs" | "umd" | "iife";
+interface ModulePreloadOptions {
+  /**
+  * Whether to inject a module preload polyfill.
+  * Note: does not apply to library mode.
+  * @default true
+  */
+  polyfill?: boolean;
+  /**
+  * Resolve the list of dependencies to preload for a given dynamic import
+  * @experimental
+  */
+  resolveDependencies?: ResolveModulePreloadDependenciesFn;
+}
+interface ResolvedModulePreloadOptions {
+  polyfill: boolean;
+  resolveDependencies?: ResolveModulePreloadDependenciesFn;
+}
+type ResolveModulePreloadDependenciesFn = (filename: string, deps: string[], context: {
+  hostId: string;
+  hostType: "html" | "js";
+}) => string[];
+interface ResolvedBuildEnvironmentOptions extends Required<Omit<BuildEnvironmentOptions, "polyfillModulePreload">> {
+  modulePreload: false | ResolvedModulePreloadOptions;
+}
+interface ResolvedBuildOptions extends Required<Omit<BuildOptions, "polyfillModulePreload">> {
+  modulePreload: false | ResolvedModulePreloadOptions;
+}
+/**
+* Bundles a single environment for production.
+* Returns a Promise containing the build result.
+*/
+declare function build(inlineConfig?: InlineConfig): Promise<RolldownOutput | RolldownOutput[] | RolldownWatcher>;
+type RenderBuiltAssetUrl = (filename: string, type: {
+  type: "asset" | "public";
+  hostId: string;
+  hostType: "js" | "css" | "html";
+  ssr: boolean;
+}) => string | {
+  relative?: boolean;
+  runtime?: string;
+} | undefined;
+declare class BuildEnvironment extends BaseEnvironment {
+  mode: "build";
+  isBuilt: boolean;
+  constructor(name: string, config: ResolvedConfig, setup?: {
+    options?: EnvironmentOptions;
+  });
+  init(): Promise<void>;
+}
+interface ViteBuilder {
+  environments: Record<string, BuildEnvironment>;
+  config: ResolvedConfig;
+  buildApp(): Promise<void>;
+  build(environment: BuildEnvironment): Promise<RolldownOutput | RolldownOutput[] | RolldownWatcher>;
+  runDevTools(): Promise<void>;
+}
+interface BuilderOptions {
+  /**
+  * Whether to share the config instance among environments to align with the behavior of dev server.
+  *
+  * @default false
+  * @experimental
+  */
+  sharedConfigBuild?: boolean;
+  /**
+  * Whether to share the plugin instances among environments to align with the behavior of dev server.
+  *
+  * @default false
+  * @experimental
+  */
+  sharedPlugins?: boolean;
+  buildApp?: (builder: ViteBuilder) => Promise<void>;
+}
+type ResolvedBuilderOptions = Required<BuilderOptions>;
+/**
+* Creates a ViteBuilder to orchestrate building multiple environments.
+* @experimental
+*/
+declare function createBuilder(inlineConfig?: InlineConfig, useLegacyBuilder?: null | boolean): Promise<ViteBuilder>;
+type BuildAppHook = (this: MinimalPluginContextWithoutEnvironment, builder: ViteBuilder) => Promise<void>;
+//#endregion
+//#region src/node/environment.d.ts
+type Environment = DevEnvironment | BuildEnvironment | ScanEnvironment | UnknownEnvironment;
+/**
+* Creates a function that hides the complexities of a WeakMap with an initial value
+* to implement object metadata. Used by plugins to implement cross hooks per
+* environment metadata
+*
+* @experimental
+*/
+declare function perEnvironmentState<State>(initial: (environment: Environment) => State): (context: PluginContext) => State;
+//#endregion
+//#region src/node/server/pluginContainer.d.ts
+type SkipInformation = {
+  id: string;
+  importer: string | undefined;
+  plugin: Plugin;
+  called?: boolean;
+};
+declare class EnvironmentPluginContainer<Env extends Environment = Environment> {
+  private _pluginContextMap;
+  private _resolvedRollupOptions?;
+  private _processesing;
+  private _seenResolves;
+  private _moduleNodeToLoadAddedImports;
+  getSortedPluginHooks: PluginHookUtils["getSortedPluginHooks"];
+  getSortedPlugins: PluginHookUtils["getSortedPlugins"];
+  moduleGraph: EnvironmentModuleGraph | undefined;
+  watchFiles: Set<string>;
+  minimalContext: MinimalPluginContext$1<Env>;
+  private _started;
+  private _buildStartPromise;
+  private _closed;
+  private _updateModuleLoadAddedImports;
+  private _getAddedImports;
+  getModuleInfo(id: string): ModuleInfo | null;
+  private handleHookPromise;
+  get options(): InputOptions;
+  resolveRollupOptions(): Promise<InputOptions>;
+  private _getPluginContext;
+  private hookParallel;
+  buildStart(_options?: InputOptions): Promise<void>;
+  resolveId(rawId: string, importer?: string | undefined, options?: {
+    kind?: ImportKind;
+    attributes?: Record<string, string>;
+    custom?: CustomPluginOptions; /** @deprecated use `skipCalls` instead */
+    skip?: Set<Plugin>;
+    skipCalls?: readonly SkipInformation[];
+    
+    isEntry?: boolean;
+  }): Promise<PartialResolvedId | null>;
+  load(id: string): Promise<LoadResult | null>;
+  transform(code: string, id: string, options?: {
+    inMap?: SourceDescription["map"];
+    moduleType?: string;
+  }): Promise<{
+    code: string;
+    map: SourceMap | {
+      mappings: "";
+    } | null;
+    moduleType?: ModuleType;
+  }>;
+  watchChange(id: string, change: {
+    event: "create" | "update" | "delete";
+  }): Promise<void>;
+  close(): Promise<void>;
+}
+declare class BasicMinimalPluginContext<Meta = PluginContextMeta> {
+  meta: Meta;
+  private _logger;
+  constructor(meta: Meta, _logger: Logger);
+  get pluginName(): string;
+  debug(rawLog: string | RollupLog | (() => string | RollupLog)): void;
+  info(rawLog: string | RollupLog | (() => string | RollupLog)): void;
+  warn(rawLog: string | RollupLog | (() => string | RollupLog)): void;
+  error(e: string | RollupError): never;
+  private _normalizeRawLog;
+}
+declare class MinimalPluginContext$1<T extends Environment = Environment> extends BasicMinimalPluginContext implements MinimalPluginContext {
+  environment: T;
+  constructor(meta: PluginContextMeta, environment: T);
+}
+declare class PluginContainer {
+  private environments;
+  constructor(environments: Record<string, Environment>);
+  private _getEnvironment;
+  private _getPluginContainer;
+  getModuleInfo(id: string): ModuleInfo | null;
+  get options(): InputOptions;
+  buildStart(_options?: InputOptions): Promise<void>;
+  watchChange(id: string, change: {
+    event: "create" | "update" | "delete";
+  }): Promise<void>;
+  resolveId(rawId: string, importer?: string, options?: {
+    attributes?: Record<string, string>;
+    custom?: CustomPluginOptions; /** @deprecated use `skipCalls` instead */
+    skip?: Set<Plugin>;
+    skipCalls?: readonly SkipInformation[];
+    ssr?: boolean;
+    
+    isEntry?: boolean;
+  }): Promise<PartialResolvedId | null>;
+  load(id: string, options?: {
+    ssr?: boolean;
+  }): Promise<LoadResult | null>;
+  transform(code: string, id: string, options?: {
+    ssr?: boolean;
+    environment?: Environment;
+    inMap?: SourceDescription["map"];
+  }): Promise<{
+    code: string;
+    map: SourceMap | {
+      mappings: "";
+    } | null;
+  }>;
+  close(): Promise<void>;
+}
+/**
+* server.pluginContainer compatibility
+*
+* The default environment is in buildStart, buildEnd, watchChange, and closeBundle hooks,
+* which are called once for all environments, or when no environment is passed in other hooks.
+* The ssrEnvironment is needed for backward compatibility when the ssr flag is passed without
+* an environment. The defaultEnvironment in the main pluginContainer in the server should be
+* the client environment for backward compatibility.
+**/
+//#endregion
+//#region src/node/server/index.d.ts
+interface ServerOptions$1 extends CommonServerOptions {
+  /**
+  * Configure HMR-specific options (port, host, path & protocol)
+  */
+  hmr?: HmrOptions | boolean;
+  /**
+  * Do not start the websocket connection.
+  * @experimental
+  */
+  ws?: false;
+  /**
+  * Warm-up files to transform and cache the results in advance. This improves the
+  * initial page load during server starts and prevents transform waterfalls.
+  */
+  warmup?: {
+    /**
+    * The files to be transformed and used on the client-side. Supports glob patterns.
+    */
+    clientFiles?: string[];
+    /**
+    * The files to be transformed and used in SSR. Supports glob patterns.
+    */
+    ssrFiles?: string[];
+  };
+  /**
+  * chokidar watch options or null to disable FS watching
+  * https://github.com/paulmillr/chokidar/tree/3.6.0#api
+  */
+  watch?: WatchOptions | null;
+  /**
+  * Create Vite dev server to be used as a middleware in an existing server
+  * @default false
+  */
+  middlewareMode?: boolean | {
+    /**
+    * Parent server instance to attach to
+    *
+    * This is needed to proxy WebSocket connections to the parent server.
+    */
+    server: HttpServer;
+  };
+  /**
+  * Options for files served via '/\@fs/'.
+  */
+  fs?: FileSystemServeOptions;
+  /**
+  * Origin for the generated asset URLs.
+  *
+  * @example `http://127.0.0.1:8080`
+  */
+  origin?: string;
+  /**
+  * Pre-transform known direct imports
+  * @default true
+  */
+  preTransformRequests?: boolean;
+  /**
+  * Whether or not to ignore-list source files in the dev server sourcemap, used to populate
+  * the [`x_google_ignoreList` source map extension](https://developer.chrome.com/blog/devtools-better-angular-debugging/#the-x_google_ignorelist-source-map-extension).
+  *
+  * By default, it excludes all paths containing `node_modules`. You can pass `false` to
+  * disable this behavior, or, for full control, a function that takes the source path and
+  * sourcemap path and returns whether to ignore the source path.
+  */
+  sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
+  /**
+  * Backward compatibility. The buildStart and buildEnd hooks were called only once for
+  * the client environment. This option enables per-environment buildStart and buildEnd hooks.
+  * @default false
+  * @experimental
+  */
+  perEnvironmentStartEndDuringDev?: boolean;
+  /**
+  * Backward compatibility. The watchChange hook was called only once for the client environment.
+  * This option enables per-environment watchChange hooks.
+  * @default false
+  * @experimental
+  */
+  perEnvironmentWatchChangeDuringDev?: boolean;
+  /**
+  * Run HMR tasks, by default the HMR propagation is done in parallel for all environments
+  * @experimental
+  */
+  hotUpdateEnvironments?: (server: ViteDevServer, hmr: (environment: DevEnvironment) => Promise<void>) => Promise<void>;
+  forwardConsole?: boolean | ForwardConsoleOptions;
+}
+interface ResolvedServerOptions extends Omit<RequiredExceptFor<ServerOptions$1, "host" | "https" | "proxy" | "hmr" | "ws" | "watch" | "origin" | "hotUpdateEnvironments">, "fs" | "middlewareMode" | "sourcemapIgnoreList" | "forwardConsole"> {
+  fs: Required<FileSystemServeOptions>;
+  middlewareMode: NonNullable<ServerOptions$1["middlewareMode"]>;
+  sourcemapIgnoreList: Exclude<ServerOptions$1["sourcemapIgnoreList"], false | undefined>;
+  forwardConsole: ResolvedForwardConsoleOptions;
+}
+interface FileSystemServeOptions {
+  /**
+  * Strictly restrict file accessing outside of allowing paths.
+  *
+  * Set to `false` to disable the warning
+  *
+  * @default true
+  */
+  strict?: boolean;
+  /**
+  * Restrict accessing files outside the allowed directories.
+  *
+  * Accepts absolute path or a path relative to project root.
+  * Will try to search up for workspace root by default.
+  */
+  allow?: string[];
+  /**
+  * Restrict accessing files that matches the patterns.
+  *
+  * This will have higher priority than `allow`.
+  * picomatch patterns are supported.
+  *
+  * @default ['.env', '.env.*', '*.{crt,pem}', '**\/.git/**']
+  */
+  deny?: string[];
+}
+type ServerHook = (this: MinimalPluginContextWithoutEnvironment, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
+type HttpServer = http.Server | Http2SecureServer;
+interface ViteDevServer {
+  /**
+  * The resolved vite config object
+  */
+  config: ResolvedConfig;
+  /**
+  * A connect app instance.
+  * - Can be used to attach custom middlewares to the dev server.
+  * - Can also be used as the handler function of a custom http server
+  *   or as a middleware in any connect-style Node.js frameworks
+  *
+  * https://github.com/senchalabs/connect#use-middleware
+  */
+  middlewares: Connect.Server;
+  /**
+  * native Node http server instance
+  * will be null in middleware mode
+  */
+  httpServer: HttpServer | null;
+  /**
+  * Chokidar watcher instance. If `config.server.watch` is set to `null`,
+  * it will not watch any files and calling `add` or `unwatch` will have no effect.
+  * https://github.com/paulmillr/chokidar/tree/3.6.0#api
+  */
+  watcher: FSWatcher;
+  /**
+  * WebSocket server with `send(payload)` method
+  */
+  ws: WebSocketServer;
+  /**
+  * An alias to `server.environments.client.hot`.
+  * If you want to interact with all environments, loop over `server.environments`.
+  */
+  hot: NormalizedHotChannel;
+  /**
+  * Rollup plugin container that can run plugin hooks on a given file
+  */
+  pluginContainer: PluginContainer;
+  /**
+  * Module execution environments attached to the Vite server.
+  */
+  environments: Record<"client" | "ssr" | (string & {}), DevEnvironment>;
+  /**
+  * Module graph that tracks the import relationships, url to file mapping
+  * and hmr state.
+  */
+  moduleGraph: ModuleGraph;
+  /**
+  * The resolved urls Vite prints on the CLI (URL-encoded). Returns `null`
+  * in middleware mode or if the server is not listening on any port.
+  */
+  resolvedUrls: ResolvedServerUrls | null;
+  /**
+  * Programmatically resolve, load and transform a URL and get the result
+  * without going through the http request pipeline.
+  */
+  transformRequest(url: string, options?: TransformOptions): Promise<TransformResult | null>;
+  /**
+  * Same as `transformRequest` but only warm up the URLs so the next request
+  * will already be cached. The function will never throw as it handles and
+  * reports errors internally.
+  */
+  warmupRequest(url: string, options?: TransformOptions): Promise<void>;
+  /**
+  * Apply vite built-in HTML transforms and any plugin HTML transforms.
+  */
+  transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
+  /**
+  * Transform module code into SSR format.
+  */
+  ssrTransform(code: string, inMap: SourceMap | {
+    mappings: "";
+  } | null, url: string, originalCode?: string): Promise<TransformResult | null>;
+  /**
+  * Load a given URL as an instantiated module for SSR.
+  */
+  ssrLoadModule(url: string, opts?: {
+    fixStacktrace?: boolean;
+  }): Promise<Record<string, any>>;
+  /**
+  * Returns a fixed version of the given stack
+  */
+  ssrRewriteStacktrace(stack: string): string;
+  /**
+  * Mutates the given SSR error by rewriting the stacktrace
+  */
+  ssrFixStacktrace(e: Error): void;
+  /**
+  * Triggers HMR for a module in the module graph. You can use the `server.moduleGraph`
+  * API to retrieve the module to be reloaded. If `hmr` is false, this is a no-op.
+  */
+  reloadModule(module: ModuleNode): Promise<void>;
+  /**
+  * Start the server.
+  */
+  listen(port?: number, isRestart?: boolean): Promise<ViteDevServer>;
+  /**
+  * Stop the server.
+  */
+  close(): Promise<void>;
+  /**
+  * Print server urls
+  */
+  printUrls(): void;
+  /**
+  * Bind CLI shortcuts
+  */
+  bindCLIShortcuts(options?: BindCLIShortcutsOptions<ViteDevServer>): void;
+  /**
+  * Restart the server.
+  *
+  * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
+  */
+  restart(forceOptimize?: boolean): Promise<void>;
+  /**
+  * Open browser
+  */
+  openBrowser(): void;
+  /**
+  * Calling `await server.waitForRequestsIdle(id)` will wait until all static imports
+  * are processed. If called from a load or transform plugin hook, the id needs to be
+  * passed as a parameter to avoid deadlocks. Calling this function after the first
+  * static imports section of the module graph has been processed will resolve immediately.
+  */
+  waitForRequestsIdle: (ignoredId?: string) => Promise<void>;
+}
+interface ResolvedServerUrls {
+  local: string[];
+  network: string[];
+}
+declare function createServer(inlineConfig?: InlineConfig | ResolvedConfig): Promise<ViteDevServer>;
+//#endregion
+//#region src/node/plugins/html.d.ts
+interface HtmlTagDescriptor {
+  tag: string;
+  /**
+  * attribute values will be escaped automatically if needed
+  */
+  attrs?: Record<string, string | boolean | undefined>;
+  children?: string | HtmlTagDescriptor[];
+  /**
+  * default: 'head-prepend'
+  */
+  injectTo?: "head" | "body" | "head-prepend" | "body-prepend";
+}
+type IndexHtmlTransformResult = string | HtmlTagDescriptor[] | {
+  html: string;
+  tags: HtmlTagDescriptor[];
+};
+interface IndexHtmlTransformContext {
+  /**
+  * public path when served
+  */
+  path: string;
+  /**
+  * filename on disk
+  */
+  filename: string;
+  server?: ViteDevServer;
+  bundle?: OutputBundle;
+  chunk?: OutputChunk;
+  originalUrl?: string;
+}
+type IndexHtmlTransformHook = (this: MinimalPluginContextWithoutEnvironment, html: string, ctx: IndexHtmlTransformContext) => IndexHtmlTransformResult | void | Promise<IndexHtmlTransformResult | void>;
+type IndexHtmlTransform = IndexHtmlTransformHook | {
+  order?: "pre" | "post" | null;
+  handler: IndexHtmlTransformHook;
+};
+//#endregion
+//#region src/node/plugins/pluginFilter.d.ts
+type StringFilter<Value = string | RegExp> = Value | Array<Value> | {
+  include?: Value | Array<Value>;
+  exclude?: Value | Array<Value>;
+};
+//#endregion
+//#region src/node/plugin.d.ts
+/**
+* Vite plugins extends the Rollup plugin interface with a few extra
+* vite-specific options. A valid vite plugin is also a valid Rollup plugin.
+* On the contrary, a Rollup plugin may or may NOT be a valid vite universal
+* plugin, since some Rollup features do not make sense in an unbundled
+* dev server context. That said, as long as a rollup plugin doesn't have strong
+* coupling between its bundle phase and output phase hooks then it should
+* just work (that means, most of them).
+*
+* By default, the plugins are run during both serve and build. When a plugin
+* is applied during serve, it will only run **non output plugin hooks** (see
+* rollup type definition of {@link rollup#PluginHooks}). You can think of the
+* dev server as only running `const bundle = rollup.rollup()` but never calling
+* `bundle.generate()`.
+*
+* A plugin that expects to have different behavior depending on serve/build can
+* export a factory function that receives the command being run via options.
+*
+* If a plugin should be applied only for server or build, a function format
+* config file can be used to conditional determine the plugins to use.
+*
+* The current environment can be accessed from the context for the all non-global
+* hooks (it is not available in config, configResolved, configureServer, etc).
+* It can be a dev, build, or scan environment.
+* Plugins can use this.environment.mode === 'dev' to guard for dev specific APIs.
+*/
+interface PluginContextExtension {
+  /**
+  * Vite-specific environment instance
+  */
+  environment: Environment;
+}
+interface PluginContextMetaExtension {
+  viteVersion: string;
+}
+interface ConfigPluginContext extends Omit<MinimalPluginContext, "meta" | "environment"> {
+  meta: Omit<PluginContextMeta, "watchMode">;
+}
+interface MinimalPluginContextWithoutEnvironment extends Omit<MinimalPluginContext, "environment"> {}
+declare module "rolldown" {
+  interface MinimalPluginContext extends PluginContextExtension {}
+  interface PluginContextMeta extends PluginContextMetaExtension {}
+}
+/**
+* There are two types of plugins in Vite. App plugins and environment plugins.
+* Environment Plugins are defined by a constructor function that will be called
+* once per each environment allowing users to have completely different plugins
+* for each of them. The constructor gets the resolved environment after the server
+* and builder has already been created simplifying config access and cache
+* management for environment specific plugins.
+* Environment Plugins are closer to regular rollup plugins. They can't define
+* app level hooks (like config, configResolved, configureServer, etc).
+*/
+interface Plugin<A = any> extends Rolldown.Plugin<A> {
+  /**
+  * Perform custom handling of HMR updates.
+  * The handler receives an options containing changed filename, timestamp, a
+  * list of modules affected by the file change, and the dev server instance.
+  *
+  * - The hook can return a filtered list of modules to narrow down the update.
+  *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
+  *   the descriptors.
+  *
+  * - The hook can also return an empty array and then perform custom updates
+  *   by sending a custom hmr payload via environment.hot.send().
+  *
+  * - If the hook doesn't return a value, the hmr update will be performed as
+  *   normal.
+  */
+  hotUpdate?: ObjectHook<(this: MinimalPluginContext & {
+    environment: DevEnvironment;
+  }, options: HotUpdateOptions) => Array<EnvironmentModuleNode> | void | Promise<Array<EnvironmentModuleNode> | void>>;
+  /**
+  * extend hooks with ssr flag
+  */
+  resolveId?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined, options: {
+    kind?: ImportKind;
+    custom?: CustomPluginOptions;
+    ssr?: boolean | undefined;
+    
+    isEntry: boolean;
+  }) => Promise<ResolveIdResult> | ResolveIdResult, {
+    filter?: {
+      id?: StringFilter<RegExp>;
+    };
+  }>;
+  load?: ObjectHook<(this: PluginContext, id: string, options?: {
+    ssr?: boolean | undefined;
+  }) => Promise<LoadResult> | LoadResult, {
+    filter?: {
+      id?: StringFilter;
+    };
+  }>;
+  transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string, options?: {
+    moduleType: ModuleType;
+    ssr?: boolean | undefined;
+  }) => Promise<Rolldown.TransformResult> | Rolldown.TransformResult, {
+    filter?: {
+      id?: StringFilter;
+      code?: StringFilter;
+      moduleType?: ModuleTypeFilter;
+    };
+  }>;
+  /**
+  * Opt-in this plugin into the shared plugins pipeline.
+  * For backward-compatibility, plugins are re-recreated for each environment
+  * during `vite build --app`
+  * We have an opt-in per plugin, and a general `builder.sharedPlugins`
+  * In a future major, we'll flip the default to be shared by default
+  * @experimental
+  */
+  sharedDuringBuild?: boolean;
+  /**
+  * Opt-in this plugin into per-environment buildStart and buildEnd during dev.
+  * For backward-compatibility, the buildStart hook is called only once during
+  * dev, for the client environment. Plugins can opt-in to be called
+  * per-environment, aligning with the build hook behavior.
+  * @experimental
+  */
+  perEnvironmentStartEndDuringDev?: boolean;
+  /**
+  * Opt-in this plugin into per-environment watchChange during dev.
+  * For backward-compatibility, the watchChange hook is called only once during
+  * dev, for the client environment. Plugins can opt-in to be called
+  * per-environment, aligning with the watchChange hook behavior.
+  * @experimental
+  */
+  perEnvironmentWatchChangeDuringDev?: boolean;
+  /**
+  * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering
+  * is still subject to the `order` property in the hook object.
+  *
+  * Plugin invocation order:
+  * - alias resolution
+  * - `enforce: 'pre'` plugins
+  * - vite core plugins
+  * - normal plugins
+  * - vite build plugins
+  * - `enforce: 'post'` plugins
+  * - vite build post plugins
+  */
+  enforce?: "pre" | "post";
+  /**
+  * Apply the plugin only for serve or build, or on certain conditions.
+  */
+  apply?: "serve" | "build" | ((this: void, config: UserConfig, env: ConfigEnv) => boolean);
+  /**
+  * Define environments where this plugin should be active
+  * By default, the plugin is active in all environments
+  * @experimental
+  */
+  applyToEnvironment?: (environment: PartialEnvironment) => boolean | Promise<boolean> | PluginOption;
+  /**
+  * Modify vite config before it's resolved. The hook can either mutate the
+  * passed-in config directly, or return a partial config object that will be
+  * deeply merged into existing config.
+  *
+  * Note: User plugins are resolved before running this hook so injecting other
+  * plugins inside  the `config` hook will have no effect.
+  */
+  config?: ObjectHook<(this: ConfigPluginContext, config: UserConfig, env: ConfigEnv) => Omit<UserConfig, "plugins"> | null | void | Promise<Omit<UserConfig, "plugins"> | null | void>>;
+  /**
+  * Modify environment configs before it's resolved. The hook can either mutate the
+  * passed-in environment config directly, or return a partial config object that will be
+  * deeply merged into existing config.
+  * This hook is called for each environment with a partially resolved environment config
+  * that already accounts for the default environment config values set at the root level.
+  * If plugins need to modify the config of a given environment, they should do it in this
+  * hook instead of the config hook. Leaving the config hook only for modifying the root
+  * default environment config.
+  */
+  configEnvironment?: ObjectHook<(this: ConfigPluginContext, name: string, config: EnvironmentOptions, env: ConfigEnv & {
+    /**
+    * Whether this environment is SSR environment and `ssr.target` is set to `'webworker'`.
+    * Only intended to be used for backward compatibility.
+    */
+    isSsrTargetWebworker?: boolean;
+  }) => EnvironmentOptions | null | void | Promise<EnvironmentOptions | null | void>>;
+  /**
+  * Use this hook to read and store the final resolved vite config.
+  */
+  configResolved?: ObjectHook<(this: MinimalPluginContextWithoutEnvironment, config: ResolvedConfig) => void | Promise<void>>;
+  /**
+  * Configure the vite server. The hook receives the {@link ViteDevServer}
+  * instance. This can also be used to store a reference to the server
+  * for use in other hooks.
+  *
+  * The hooks will be called before internal middlewares are applied. A hook
+  * can return a post hook that will be called after internal middlewares
+  * are applied. Hook can be async functions and will be called in series.
+  */
+  configureServer?: ObjectHook<ServerHook>;
+  /**
+  * Configure the preview server. The hook receives the {@link PreviewServer}
+  * instance. This can also be used to store a reference to the server
+  * for use in other hooks.
+  *
+  * The hooks are called before other middlewares are applied. A hook can
+  * return a post hook that will be called after other middlewares are
+  * applied. Hooks can be async functions and will be called in series.
+  */
+  configurePreviewServer?: ObjectHook<PreviewServerHook>;
+  /**
+  * Transform index.html.
+  * The hook receives the following arguments:
+  *
+  * - html: string
+  * - ctx: IndexHtmlTransformContext, which contains:
+  *    - path: public path when served
+  *    - filename: filename on disk
+  *    - server?: ViteDevServer (only present during serve)
+  *    - bundle?: rollup.OutputBundle (only present during build)
+  *    - chunk?: rollup.OutputChunk
+  *    - originalUrl?: string
+  *
+  * It can either return a transformed string, or a list of html tag
+  * descriptors that will be injected into the `<head>` or `<body>`.
+  *
+  * By default the transform is applied **after** vite's internal html
+  * transform. If you need to apply the transform before vite, use an object:
+  * `{ order: 'pre', handler: hook }`
+  */
+  transformIndexHtml?: IndexHtmlTransform;
+  /**
+  * Build Environments
+  *
+  * @experimental
+  */
+  buildApp?: ObjectHook<BuildAppHook>;
+  /**
+  * Perform custom handling of HMR updates.
+  * The handler receives a context containing changed filename, timestamp, a
+  * list of modules affected by the file change, and the dev server instance.
+  *
+  * - The hook can return a filtered list of modules to narrow down the update.
+  *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
+  *   the descriptors.
+  *
+  * - The hook can also return an empty array and then perform custom updates
+  *   by sending a custom hmr payload via server.ws.send().
+  *
+  * - If the hook doesn't return a value, the hmr update will be performed as
+  *   normal.
+  */
+  handleHotUpdate?: ObjectHook<(this: MinimalPluginContextWithoutEnvironment, ctx: HmrContext) => Array<ModuleNode> | void | Promise<Array<ModuleNode> | void>>;
+  /**
+  * This hook is not supported by Rolldown yet. But the type is declared for compatibility.
+  *
+  * @deprecated This hook is **not** deprecated. It is marked as deprecated just to make it clear that this hook is currently a no-op.
+  */
+  shouldTransformCachedModule?: ObjectHook<(this: PluginContext, options: {
+    code: string;
+    id: string;
+    meta: CustomPluginOptions;
+    moduleSideEffects: boolean | "no-treeshake";
+  }) => boolean | null | void>;
+}
+type HookHandler<T> = T extends ObjectHook<infer H> ? H : T;
+type PluginWithRequiredHook<K extends keyof Plugin> = Plugin & { [P in K]: NonNullable<Plugin[P]> };
+type Thenable<T> = T | Promise<T>;
+type FalsyPlugin = false | null | undefined;
+type PluginOption = Thenable<Plugin | {
+  name: string;
+} | FalsyPlugin | PluginOption[]>;
+/**
+* @experimental
+*/
+declare function perEnvironmentPlugin(name: string, applyToEnvironment: (environment: PartialEnvironment) => boolean | Promise<boolean> | PluginOption): Plugin;
+//#endregion
+//#region src/node/plugins/css.d.ts
+interface CSSOptions {
+  /**
+  * Using lightningcss is an experimental option to handle CSS modules,
+  * assets and imports via Lightning CSS. It requires to install it as a
+  * peer dependency.
+  *
+  * @default 'postcss'
+  * @experimental
+  */
+  transformer?: "postcss" | "lightningcss";
+  /**
+  * https://github.com/css-modules/postcss-modules
+  */
+  modules?: CSSModulesOptions | false;
+  /**
+  * Options for preprocessors.
+  *
+  * In addition to options specific to each processors, Vite supports `additionalData` option.
+  * The `additionalData` option can be used to inject extra code for each style content.
+  */
+  preprocessorOptions?: {
+    scss?: SassPreprocessorOptions;
+    sass?: SassPreprocessorOptions;
+    less?: LessPreprocessorOptions;
+    styl?: StylusPreprocessorOptions;
+    stylus?: StylusPreprocessorOptions;
+  };
+  /**
+  * If this option is set, preprocessors will run in workers when possible.
+  * `true` means the number of CPUs minus 1.
+  *
+  * @default true
+  */
+  preprocessorMaxWorkers?: number | true;
+  postcss?: string | (PostCSS.ProcessOptions & {
+    plugins?: PostCSS.AcceptedPlugin[];
+  });
+  /**
+  * Enables css sourcemaps during dev
+  * @default false
+  * @experimental
+  */
+  devSourcemap?: boolean;
+  /**
+  * @experimental
+  */
+  lightningcss?: lightningcssOptions_LightningCSSOptions;
+}
+interface CSSModulesOptions {
+  getJSON?: (cssFileName: string, json: Record<string, string>, outputFileName: string) => void;
+  scopeBehaviour?: "global" | "local";
+  globalModulePaths?: RegExp[];
+  exportGlobals?: boolean;
+  generateScopedName?: string | ((name: string, filename: string, css: string) => string);
+  hashPrefix?: string;
+  /**
+  * default: undefined
+  */
+  localsConvention?: "camelCase" | "camelCaseOnly" | "dashes" | "dashesOnly" | ((originalClassName: string, generatedClassName: string, inputFile: string) => string);
+}
+type ResolvedCSSOptions = Omit<CSSOptions, "lightningcss"> & Required<Pick<CSSOptions, "transformer" | "devSourcemap">> & {
+  lightningcss?: lightningcssOptions_LightningCSSOptions;
+};
+interface PreprocessCSSResult {
+  code: string;
+  map?: SourceMapInput;
+  modules?: Record<string, string>;
+  deps?: Set<string>;
+}
+/**
+* @experimental
+*/
+declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig): Promise<PreprocessCSSResult>;
+declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
+type PreprocessorAdditionalDataResult = string | {
+  content: string;
+  map?: ExistingRawSourceMap;
+};
+type PreprocessorAdditionalData = string | ((source: string, filename: string) => PreprocessorAdditionalDataResult | Promise<PreprocessorAdditionalDataResult>);
+type SassPreprocessorOptions = {
+  additionalData?: PreprocessorAdditionalData;
+} & SassModernPreprocessBaseOptions;
+type LessPreprocessorOptions = {
+  additionalData?: PreprocessorAdditionalData;
+} & LessPreprocessorBaseOptions;
+type StylusPreprocessorOptions = {
+  additionalData?: PreprocessorAdditionalData;
+} & StylusPreprocessorBaseOptions;
+//#endregion
+//#region src/node/plugins/esbuild.d.ts
+interface ESBuildOptions extends esbuildOptions_EsbuildTransformOptions {
+  include?: string | RegExp | ReadonlyArray<string | RegExp>;
+  exclude?: string | RegExp | ReadonlyArray<string | RegExp>;
+  jsxInject?: string;
+  /**
+  * This option is not respected. Use `build.minify` instead.
+  */
+  minify?: never;
+}
+type ESBuildTransformResult = Omit<EsbuildTransformResult, "map"> & {
+  map: SourceMap;
+};
+declare function transformWithEsbuild(code: string, filename: string, options?: esbuildOptions_EsbuildTransformOptions, inMap?: object, config?: ResolvedConfig, watcher?: FSWatcher, ignoreEsbuildWarning?: boolean): Promise<ESBuildTransformResult>;
+//#endregion
+//#region src/node/plugins/json.d.ts
+interface JsonOptions {
+  /**
+  * Generate a named export for every property of the JSON object
+  * @default true
+  */
+  namedExports?: boolean;
+  /**
+  * Generate performant output as JSON.parse("stringified").
+  *
+  * When set to 'auto', the data will be stringified only if the data is bigger than 10kB.
+  * @default 'auto'
+  */
+  stringify?: boolean | "auto";
+}
+//#endregion
+//#region src/node/ssr/index.d.ts
+type SSRTarget = "node" | "webworker";
+type SsrDepOptimizationConfig = DepOptimizationConfig;
+interface SSROptions {
+  noExternal?: string | RegExp | (string | RegExp)[] | true;
+  external?: string[] | true;
+  /**
+  * Define the target for the ssr build. The browser field in package.json
+  * is ignored for node but used if webworker is the target
+  * This option will be removed in a future major version
+  * @default 'node'
+  */
+  target?: SSRTarget;
+  /**
+  * Control over which dependencies are optimized during SSR and esbuild options
+  * During build:
+  *   no external CJS dependencies are optimized by default
+  * During dev:
+  *   explicit no external CJS dependencies are optimized by default
+  * @experimental
+  */
+  optimizeDeps?: SsrDepOptimizationConfig;
+  resolve?: {
+    /**
+    * Conditions that are used in the plugin pipeline. The default value is the root config's `resolve.conditions`.
+    *
+    * Use this to override the default ssr conditions for the ssr build.
+    *
+    * @default rootConfig.resolve.conditions
+    */
+    conditions?: string[];
+    /**
+    * Conditions that are used during ssr import (including `ssrLoadModule`) of externalized dependencies.
+    *
+    * @default ['node', 'module-sync']
+    */
+    externalConditions?: string[];
+    mainFields?: string[];
+  };
+}
+interface ResolvedSSROptions extends SSROptions {
+  target: SSRTarget;
+  optimizeDeps: SsrDepOptimizationConfig;
+}
+//#endregion
+//#region src/node/plugins/oxc.d.ts
+interface OxcOptions extends Omit<rolldown_utils_TransformOptions, "cwd" | "sourceType" | "lang" | "sourcemap" | "helpers" | "inject" | "tsconfig" | "inputMap"> {
+  include?: string | RegExp | ReadonlyArray<string | RegExp>;
+  exclude?: string | RegExp | ReadonlyArray<string | RegExp>;
+  jsxInject?: string;
+  jsxRefreshInclude?: string | RegExp | ReadonlyArray<string | RegExp>;
+  jsxRefreshExclude?: string | RegExp | ReadonlyArray<string | RegExp>;
+}
+declare function transformWithOxc(code: string, filename: string, options?: rolldown_utils_TransformOptions, inMap?: object, config?: ResolvedConfig, watcher?: FSWatcher): Promise<Omit<rolldown_utils_TransformResult, "errors">>;
+//#endregion
+//#region src/node/config.d.ts
+interface ConfigEnv {
+  /**
+  * 'serve': during dev (`vite` command)
+  * 'build': when building for production (`vite build` command)
+  */
+  command: "build" | "serve";
+  mode: string;
+  isSsrBuild?: boolean;
+  isPreview?: boolean;
+}
+/**
+* spa: include SPA fallback middleware and configure sirv with `single: true` in preview
+*
+* mpa: only include non-SPA HTML middlewares
+*
+* custom: don't include HTML middlewares
+*/
+type AppType = "spa" | "mpa" | "custom";
+type UserConfigFnObject = (env: ConfigEnv) => UserConfig;
+type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>;
+type UserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
+type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
+/**
+* Type helper to make it easier to use vite.config.ts
+* accepts a direct {@link UserConfig} object, or a function that returns it.
+* The function receives a {@link ConfigEnv} object.
+*/
+declare function defineConfig(config: UserConfig): UserConfig;
+declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
+declare function defineConfig(config: UserConfigFnPromise): UserConfigFnPromise;
+declare function defineConfig(config: UserConfigFn): UserConfigFn;
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
+interface CreateDevEnvironmentContext {
+  ws: WebSocketServer;
+}
+interface DevEnvironmentOptions {
+  /**
+  * Files to be pre-transformed. Supports glob patterns.
+  */
+  warmup?: string[];
+  /**
+  * Pre-transform known direct imports
+  * defaults to true for the client environment, false for the rest
+  */
+  preTransformRequests?: boolean;
+  /**
+  * Enables sourcemaps during dev
+  * @default { js: true }
+  * @experimental
+  */
+  sourcemap?: boolean | {
+    js?: boolean;
+    css?: boolean;
+  };
+  /**
+  * Whether or not to ignore-list source files in the dev server sourcemap, used to populate
+  * the [`x_google_ignoreList` source map extension](https://developer.chrome.com/blog/devtools-better-angular-debugging/#the-x_google_ignorelist-source-map-extension).
+  *
+  * By default, it excludes all paths containing `node_modules`. You can pass `false` to
+  * disable this behavior, or, for full control, a function that takes the source path and
+  * sourcemap path and returns whether to ignore the source path.
+  */
+  sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
+  /**
+  * create the Dev Environment instance
+  */
+  createEnvironment?: (name: string, config: ResolvedConfig, context: CreateDevEnvironmentContext) => Promise<DevEnvironment> | DevEnvironment;
+  /**
+  * For environments that support a full-reload, like the client, we can short-circuit when
+  * restarting the server throwing early to stop processing current files. We avoided this for
+  * SSR requests. Maybe this is no longer needed.
+  * @experimental
+  */
+  recoverable?: boolean;
+  /**
+  * For environments associated with a module runner.
+  * By default, it is false for the client environment and true for non-client environments.
+  * This option can also be used instead of the removed config.experimental.skipSsrTransform.
+  */
+  moduleRunnerTransform?: boolean;
+}
+type ResolvedDevEnvironmentOptions = Omit<Required<DevEnvironmentOptions>, "sourcemapIgnoreList"> & {
+  sourcemapIgnoreList: Exclude<DevEnvironmentOptions["sourcemapIgnoreList"], false | undefined>;
+};
+type AllResolveOptions = ResolveOptions & {
+  alias?: AliasOptions;
+};
+interface SharedEnvironmentOptions {
+  /**
+  * Define global variable replacements.
+  * Entries will be defined on `window` during dev and replaced during build.
+  */
+  define?: Record<string, any>;
+  /**
+  * Configure resolver
+  */
+  resolve?: EnvironmentResolveOptions;
+  /**
+  * Define if this environment is used for Server-Side Rendering
+  * @default 'server' if it isn't the client environment
+  */
+  consumer?: "client" | "server";
+  /**
+  * If true, `process.env` referenced in code will be preserved as-is and evaluated in runtime.
+  * Otherwise, it is statically replaced as an empty object.
+  */
+  keepProcessEnv?: boolean;
+  /**
+  * Optimize deps config
+  */
+  optimizeDeps?: DepOptimizationOptions;
+  /**
+  * Whether this environment produces a bundled output.
+  *
+  * During `build`, this defaults to `true` for every environment.
+  * During `serve`, this defaults to `true` only for the client environment
+  * when `experimental.bundledDev` is enabled, and `false` otherwise.
+  * Setting this explicitly on an environment always overrides the default.
+  *
+  * @experimental
+  */
+  isBundled?: boolean;
+}
+interface EnvironmentOptions extends SharedEnvironmentOptions {
+  /**
+  * Dev specific options
+  */
+  dev?: DevEnvironmentOptions;
+  /**
+  * Build specific options
+  */
+  build?: BuildEnvironmentOptions;
+}
+type ResolvedResolveOptions = Required<ResolveOptions>;
+type ResolvedEnvironmentOptions = {
+  define?: Record<string, any>;
+  resolve: ResolvedResolveOptions;
+  consumer: "client" | "server";
+  keepProcessEnv?: boolean;
+  optimizeDeps: DepOptimizationOptions;
+  dev: ResolvedDevEnvironmentOptions;
+  build: ResolvedBuildEnvironmentOptions;
+  isBundled: boolean;
+  plugins: readonly Plugin[];
+};
+type DefaultEnvironmentOptions = Omit<EnvironmentOptions, "consumer" | "resolve" | "keepProcessEnv"> & {
+  resolve?: AllResolveOptions;
+};
+interface UserConfig extends DefaultEnvironmentOptions {
+  /**
+  * Project root directory. Can be an absolute path, or a path relative from
+  * the location of the config file itself.
+  * @default process.cwd()
+  */
+  root?: string;
+  /**
+  * Base public path when served in development or production.
+  * @default '/'
+  */
+  base?: string;
+  /**
+  * Directory to serve as plain static assets. Files in this directory are
+  * served and copied to build dist dir as-is without transform. The value
+  * can be either an absolute file system path or a path relative to project root.
+  *
+  * Set to `false` or an empty string to disable copied static assets to build dist dir.
+  * @default 'public'
+  */
+  publicDir?: string | false;
+  /**
+  * Directory to save cache files. Files in this directory are pre-bundled
+  * deps or some other cache files that generated by vite, which can improve
+  * the performance. You can use `--force` flag or manually delete the directory
+  * to regenerate the cache files. The value can be either an absolute file
+  * system path or a path relative to project root.
+  * Default to `.vite` when no `package.json` is detected.
+  * @default 'node_modules/.vite'
+  */
+  cacheDir?: string;
+  /**
+  * Explicitly set a mode to run in. This will override the default mode for
+  * each command, and can be overridden by the command line --mode option.
+  */
+  mode?: string;
+  /**
+  * Array of vite plugins to use.
+  */
+  plugins?: PluginOption[];
+  /**
+  * HTML related options
+  */
+  html?: HTMLOptions;
+  /**
+  * CSS related options (preprocessors and CSS modules)
+  */
+  css?: CSSOptions;
+  /**
+  * JSON loading options
+  */
+  json?: JsonOptions;
+  /**
+  * Transform options to pass to esbuild.
+  * Or set to `false` to disable esbuild.
+  *
+  * @deprecated Use `oxc` option instead.
+  */
+  esbuild?: ESBuildOptions | false;
+  /**
+  * Transform options to pass to Oxc.
+  * Or set to `false` to disable Oxc.
+  */
+  oxc?: OxcOptions | false;
+  /**
+  * Specify additional picomatch patterns to be treated as static assets.
+  */
+  assetsInclude?: string | RegExp | (string | RegExp)[];
+  /**
+  * Builder specific options
+  * @experimental
+  */
+  builder?: BuilderOptions;
+  /**
+  * Server specific options, e.g. host, port, https...
+  */
+  server?: ServerOptions$1;
+  /**
+  * Preview specific options, e.g. host, port, https...
+  */
+  preview?: PreviewOptions;
+  /**
+  * Experimental features
+  *
+  * Features under this field could change in the future and might NOT follow semver.
+  * Please be careful and always pin Vite's version when using them.
+  * @experimental
+  */
+  experimental?: ExperimentalOptions;
+  /**
+  * Options to opt-in to future behavior
+  */
+  future?: FutureOptions | "warn";
+  /**
+  * Legacy options
+  *
+  * Features under this field only follow semver for patches, they could be removed in a
+  * future minor version. Please always pin Vite's version to a minor when using them.
+  */
+  legacy?: LegacyOptions;
+  /**
+  * Log level.
+  * @default 'info'
+  */
+  logLevel?: LogLevel;
+  /**
+  * Custom logger.
+  */
+  customLogger?: Logger;
+  /**
+  * @default true
+  */
+  clearScreen?: boolean;
+  /**
+  * Environment files directory. Can be an absolute path, or a path relative from
+  * root.
+  * @default root
+  */
+  envDir?: string | false;
+  /**
+  * Env variables starts with `envPrefix` will be exposed to your client source code via import.meta.env.
+  * @default 'VITE_'
+  */
+  envPrefix?: string | string[];
+  /**
+  * Worker bundle options
+  */
+  worker?: {
+    /**
+    * Output format for worker bundle
+    * @default 'iife'
+    */
+    format?: "es" | "iife";
+    /**
+    * Vite plugins that apply to worker bundle. The plugins returned by this function
+    * should be new instances every time it is called, because they are used for each
+    * rolldown worker bundling process.
+    */
+    plugins?: () => PluginOption[];
+    /**
+    * Alias to `rolldownOptions`.
+    * @deprecated Use `rolldownOptions` instead.
+    */
+    rollupOptions?: Omit<RolldownOptions, "plugins" | "input" | "onwarn" | "preserveEntrySignatures">;
+    /**
+    * Rolldown options to build worker bundle
+    */
+    rolldownOptions?: Omit<RolldownOptions, "plugins" | "input" | "onwarn" | "preserveEntrySignatures">;
+  };
+  /**
+  * Dep optimization options
+  */
+  optimizeDeps?: DepOptimizationOptions;
+  /**
+  * SSR specific options
+  * We could make SSROptions be a EnvironmentOptions if we can abstract
+  * external/noExternal for environments in general.
+  */
+  ssr?: SSROptions;
+  /**
+  * Environment overrides
+  */
+  environments?: Record<string, EnvironmentOptions>;
+  /**
+  * Whether your application is a Single Page Application (SPA),
+  * a Multi-Page Application (MPA), or Custom Application (SSR
+  * and frameworks with custom HTML handling)
+  * @default 'spa'
+  */
+  appType?: AppType;
+  /**
+  * Enable devtools integration. Ensure that `@vitejs/devtools` is installed as a dependency.
+  * This feature is currently supported only in build mode.
+  * @experimental
+  * @default false
+  */
+  devtools?: boolean | DevToolsConfig;
+}
+interface HTMLOptions {
+  /**
+  * A nonce value placeholder that will be used when generating script/style tags.
+  *
+  * Make sure that this placeholder will be replaced with a unique value for each request by the server.
+  */
+  cspNonce?: string;
+}
+interface FutureOptions {
+  removePluginHookHandleHotUpdate?: "warn";
+  removePluginHookSsrArgument?: "warn";
+  removeServerModuleGraph?: "warn";
+  removeServerReloadModule?: "warn";
+  removeServerPluginContainer?: "warn";
+  removeServerHot?: "warn";
+  removeServerTransformRequest?: "warn";
+  removeServerWarmupRequest?: "warn";
+  removeSsrLoadModule?: "warn";
+}
+interface ExperimentalOptions {
+  /**
+  * Append fake `&lang.(ext)` when queries are specified, to preserve the file extension for following plugins to process.
+  *
+  * @experimental
+  * @default false
+  */
+  importGlobRestoreExtension?: boolean;
+  /**
+  * Allow finegrain control over assets and public files paths
+  *
+  * @experimental
+  */
+  renderBuiltUrl?: RenderBuiltAssetUrl;
+  /**
+  * Enables support of HMR partial accept via `import.meta.hot.acceptExports`.
+  *
+  * @experimental
+  * @default false
+  */
+  hmrPartialAccept?: boolean;
+  /**
+  * Enable full bundle mode during `serve`.
+  *
+  * This seeds the default for the client environment's `isBundled` option.
+  * Other environments default to `false` during `serve`. Any environment
+  * can override its `isBundled` value via `environments[name].isBundled`.
+  *
+  * This is highly experimental.
+  *
+  * @experimental
+  * @default false
+  */
+  bundledDev?: boolean;
+}
+interface LegacyOptions {
+  /**
+  * In Vite 6.0.8 and below, WebSocket server was able to connect from any web pages. However,
+  * that could be exploited by a malicious web page.
+  *
+  * In Vite 6.0.9+, the WebSocket server now requires a token to connect from a web page.
+  * But this may break some plugins and frameworks that connects to the WebSocket server
+  * on their own. Enabling this option will make Vite skip the token check.
+  *
+  * **We do not recommend enabling this option unless you are sure that you are fine with
+  * that security weakness.**
+  */
+  skipWebSocketTokenCheck?: boolean;
+  /**
+  * Opt-in to the pre-Vite 8 CJS interop behavior, which was inconsistent.
+  *
+  * In pre-Vite 8 versions, Vite had inconsistent CJS interop behavior. This was due to
+  * the different behavior of esbuild and the Rollup commonjs plugin.
+  * Vite 8+ uses Rolldown for both the dependency optimization in dev and the production build,
+  * which aligns the behavior to esbuild.
+  *
+  * See the Vite 8 migration guide for more details.
+  */
+  inconsistentCjsInterop?: boolean;
+}
+interface ResolvedWorkerOptions {
+  format: "es" | "iife";
+  plugins: (bundleChain: string[]) => Promise<ResolvedConfig>;
+  /**
+  * @deprecated Use `rolldownOptions` instead.
+  */
+  rollupOptions: RolldownOptions;
+  rolldownOptions: RolldownOptions;
+}
+interface InlineConfig extends UserConfig {
+  configFile?: string | false;
+  /** @experimental */
+  configLoader?: "bundle" | "runner" | "native";
+  /** @deprecated */
+  envFile?: false;
+  forceOptimizeDeps?: boolean;
+}
+interface ResolvedConfig extends Readonly<Omit<UserConfig, "plugins" | "css" | "json" | "assetsInclude" | "optimizeDeps" | "worker" | "build" | "dev" | "environments" | "experimental" | "future" | "server" | "preview" | "devtools"> & {
+  configFile: string | undefined;
+  configFileDependencies: string[];
+  inlineConfig: InlineConfig;
+  root: string;
+  base: string;
+  publicDir: string;
+  cacheDir: string;
+  command: "build" | "serve";
+  mode: string;
+  isWorker: boolean;
+  isProduction: boolean;
+  envDir: string | false;
+  env: Record<string, any>;
+  resolve: Required<ResolveOptions> & {
+    alias: Alias[];
+  };
+  plugins: readonly Plugin[];
+  css: ResolvedCSSOptions;
+  json: Required<JsonOptions>; /** @deprecated Use `oxc` option instead. */
+  esbuild: ESBuildOptions | false;
+  oxc: OxcOptions | false;
+  server: ResolvedServerOptions;
+  dev: ResolvedDevEnvironmentOptions; /** @experimental */
+  builder: ResolvedBuilderOptions | undefined;
+  build: ResolvedBuildOptions;
+  devtools: ResolvedDevToolsConfig;
+  preview: ResolvedPreviewOptions;
+  ssr: ResolvedSSROptions;
+  assetsInclude: (file: string) => boolean;
+  rawAssetsInclude: (string | RegExp)[];
+  logger: Logger;
+  /**
+  * Create an internal resolver to be used in special scenarios, e.g.
+  * optimizer & handling css `@imports`.
+  *
+  * This API is deprecated. It only works for the client and ssr
+  * environments. The `aliasOnly` option is also not being used anymore.
+  * Plugins should move to `createIdResolver(environment.config)` instead.
+  *
+  * @deprecated Use `createIdResolver` from `vite` instead.
+  */
+  createResolver: (options?: Partial<InternalResolveOptions>) => ResolveFn;
+  optimizeDeps: DepOptimizationOptions;
+  worker: ResolvedWorkerOptions;
+  appType: AppType;
+  experimental: RequiredExceptFor<ExperimentalOptions, "renderBuiltUrl">;
+  future: FutureOptions | undefined;
+  environments: Record<string, ResolvedEnvironmentOptions>;
+  /**
+  * The token to connect to the WebSocket server from browsers.
+  *
+  * We recommend using `import.meta.hot` rather than connecting
+  * to the WebSocket server directly.
+  * If you have a usecase that requires connecting to the WebSocket
+  * server, please create an issue so that we can discuss.
+  *
+  * @deprecated
+  */
+  webSocketToken: string;
+} & PluginHookUtils> {}
+interface PluginHookUtils {
+  getSortedPlugins: <K extends keyof Plugin>(hookName: K) => PluginWithRequiredHook<K>[];
+  getSortedPluginHooks: <K extends keyof Plugin>(hookName: K) => NonNullable<HookHandler<Plugin[K]>>[];
+}
+type ResolveFn = (id: string, importer?: string, aliasOnly?: boolean, ssr?: boolean) => Promise<string | undefined>;
+declare function resolveConfig(inlineConfig: InlineConfig, command: "build" | "serve", defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean, patchConfig?: ((config: ResolvedConfig) => void) | undefined, patchPlugins?: ((resolvedPlugins: Plugin[]) => void) | undefined): Promise<ResolvedConfig>;
+declare function sortUserPlugins(plugins: (Plugin | Plugin[])[] | undefined): [Plugin[], Plugin[], Plugin[]];
+declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel, customLogger?: Logger, configLoader?: "bundle" | "runner" | "native"): Promise<{
+  path: string;
+  config: UserConfig;
+  dependencies: string[];
+} | null>;
+//#endregion
+//#region src/node/idResolver.d.ts
+type ResolveIdFn = (environment: PartialEnvironment, id: string, importer?: string, aliasOnly?: boolean) => Promise<string | undefined>;
+/**
+* Create an internal resolver to be used in special scenarios, e.g.
+* optimizer and handling css @imports
+*/
+declare function createIdResolver(config: ResolvedConfig, options?: Partial<InternalResolveOptions>): ResolveIdFn;
+//#endregion
+//#region src/node/server/middlewares/error.d.ts
+declare function buildErrorMessage(err: RollupError, args?: string[], includeStack?: boolean): string;
+//#endregion
+//#region src/node/ssr/runtime/serverModuleRunner.d.ts
+/**
+* @experimental
+*/
+interface ServerModuleRunnerOptions extends Omit<ModuleRunnerOptions, "root" | "fetchModule" | "hmr" | "transport"> {
+  /**
+  * Disable HMR or configure HMR logger.
+  */
+  hmr?: false | {
+    logger?: ModuleRunnerHmr["logger"];
+  };
+  /**
+  * Provide a custom module evaluator. This controls how the code is executed.
+  */
+  evaluator?: ModuleEvaluator;
+}
+declare const createServerModuleRunnerTransport: (options: {
+  channel: NormalizedServerHotChannel;
+}) => ModuleRunnerTransport;
+/**
+* Create an instance of the Vite SSR runtime that support HMR.
+* @experimental
+*/
+declare function createServerModuleRunner(environment: DevEnvironment, options?: ServerModuleRunnerOptions): ModuleRunner;
+//#endregion
+//#region src/node/server/environments/runnableEnvironment.d.ts
+declare function createRunnableDevEnvironment(name: string, config: ResolvedConfig, context?: RunnableDevEnvironmentContext): RunnableDevEnvironment;
+interface RunnableDevEnvironmentContext extends Omit<DevEnvironmentContext, "hot"> {
+  runner?: (environment: RunnableDevEnvironment, options?: ServerModuleRunnerOptions) => ModuleRunner;
+  runnerOptions?: ServerModuleRunnerOptions;
+  hot?: boolean;
+}
+declare function isRunnableDevEnvironment(environment: Environment): environment is RunnableDevEnvironment;
+declare class RunnableDevEnvironment extends DevEnvironment {
+  private _runner;
+  private _runnerFactory;
+  private _runnerOptions;
+  constructor(name: string, config: ResolvedConfig, context: RunnableDevEnvironmentContext);
+  get runner(): ModuleRunner;
+  override close(): Promise<void>;
+}
+//#endregion
+//#region src/node/server/environments/fetchableEnvironments.d.ts
+interface FetchableDevEnvironmentContext extends DevEnvironmentContext {
+  handleRequest(request: Request): Promise<Response> | Response;
+}
+declare function createFetchableDevEnvironment(name: string, config: ResolvedConfig, context: FetchableDevEnvironmentContext): FetchableDevEnvironment;
+declare function isFetchableDevEnvironment(environment: Environment): environment is FetchableDevEnvironment;
+declare class FetchableDevEnvironment extends DevEnvironment {
+  private _handleRequest;
+  constructor(name: string, config: ResolvedConfig, context: FetchableDevEnvironmentContext);
+  dispatchFetch(request: Request): Promise<Response>;
+}
+//#endregion
+//#region src/node/ssr/runnerImport.d.ts
+interface RunnerImportResult<T> {
+  module: T;
+  dependencies: string[];
+}
+/**
+* Import any file using the default Vite environment.
+* @experimental
+*/
+declare function runnerImport<T>(moduleId: string, inlineConfig?: InlineConfig): Promise<RunnerImportResult<T>>;
+//#endregion
+//#region src/node/ssr/fetchModule.d.ts
+interface FetchModuleOptions {
+  cached?: boolean;
+  inlineSourceMap?: boolean;
+  startOffset?: number;
+}
+/**
+* Fetch module information for Vite module runner.
+* @experimental
+*/
+declare function fetchModule(environment: DevEnvironment, url: string, importer?: string, options?: FetchModuleOptions): Promise<moduleRunner_FetchResult>;
+//#endregion
+//#region src/node/ssr/ssrTransform.d.ts
+interface ModuleRunnerTransformOptions {
+  json?: {
+    stringify?: boolean;
+  };
+}
+declare function ssrTransform(code: string, inMap: SourceMap | {
+  mappings: "";
+} | null, url: string, originalCode: string, options?: ModuleRunnerTransformOptions): Promise<TransformResult | null>;
+//#endregion
+//#region src/node/constants.d.ts
+declare const VERSION: string;
+declare const DEFAULT_CLIENT_MAIN_FIELDS: readonly string[];
+declare const DEFAULT_SERVER_MAIN_FIELDS: readonly string[];
+declare const DEFAULT_CLIENT_CONDITIONS: readonly string[];
+declare const DEFAULT_SERVER_CONDITIONS: readonly string[];
+declare const DEFAULT_EXTERNAL_CONDITIONS: readonly string[];
+declare const defaultAllowedOrigins: RegExp;
+//#endregion
+//#region src/node/utils.d.ts
+/**
+* Inlined to keep `@rollup/pluginutils` in devDependencies
+*/
+type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
+declare const createFilter: (include?: FilterPattern, exclude?: FilterPattern, options?: {
+  resolve?: string | false | null;
+}) => (id: unknown) => boolean;
+declare const rollupVersion = "4.23.0";
+declare function normalizePath(id: string): string;
+declare const isCSSRequest: (request: string) => boolean;
+declare function mergeConfig<D extends Record<string, any>, O extends Record<string, any>>(defaults: D extends Function ? never : D, overrides: O extends Function ? never : O, isRoot?: boolean): Record<string, any>;
+declare function mergeAlias(a?: AliasOptions, b?: AliasOptions): AliasOptions | undefined;
+//#endregion
+//#region src/node/server/send.d.ts
+interface SendOptions {
+  etag?: string;
+  cacheControl?: string;
+  headers?: OutgoingHttpHeaders;
+  map?: SourceMap | {
+    mappings: "";
+  } | null;
+}
+declare function send(req: http.IncomingMessage, res: ServerResponse, content: string | Buffer, type: string, options: SendOptions): void;
+//#endregion
+//#region src/node/server/searchRoot.d.ts
+/**
+* Search up for the nearest workspace root
+*/
+declare function searchForWorkspaceRoot(current: string, root?: string): string;
+//#endregion
+//#region src/node/server/middlewares/static.d.ts
+/**
+* Check if the url is allowed to be served, via the `server.fs` config.
+* @deprecated Use the `isFileLoadingAllowed` function instead.
+*/
+declare function isFileServingAllowed(config: ResolvedConfig, url: string): boolean;
+declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;
+/**
+* Warning: parameters are not validated, only works with normalized absolute paths
+*/
+declare function isFileLoadingAllowed(config: ResolvedConfig, filePath: string): boolean;
+//#endregion
+//#region src/node/env.d.ts
+declare function loadEnv(mode: string, envDir: string | false, prefixes?: string | string[]): Record<string, string>;
+declare function resolveEnvPrefix({
+  envPrefix
+}: UserConfig): string[];
+//#endregion
+//#region src/node/plugins/manifest.d.ts
+type Manifest = Record<string, ManifestChunk>;
+interface ManifestChunk {
+  /**
+  * The input file name of this chunk / asset if known
+  */
+  src?: string;
+  /**
+  * The output file name of this chunk / asset
+  */
+  file: string;
+  /**
+  * The list of CSS files imported by this chunk
+  */
+  css?: string[];
+  /**
+  * The list of asset files imported by this chunk, excluding CSS files
+  */
+  assets?: string[];
+  /**
+  * Whether this chunk or asset is an entry point
+  */
+  isEntry?: boolean;
+  /**
+  * The name of this chunk / asset if known
+  */
+  name?: string;
+  /**
+  * Whether this chunk is a dynamic entry point
+  *
+  * This field is only present in JS chunks.
+  */
+  isDynamicEntry?: boolean;
+  /**
+  * The list of statically imported chunks by this chunk
+  *
+  * The values are the keys of the manifest. This field is only present in JS chunks.
+  */
+  imports?: string[];
+  /**
+  * The list of dynamically imported chunks by this chunk
+  *
+  * The values are the keys of the manifest. This field is only present in JS chunks.
+  */
+  dynamicImports?: string[];
+}
+//#endregion
+//#region src/node/index.d.ts
+/** @deprecated - use `parse` instead */
+declare const parseAst: typeof parseAst$1;
+/** @deprecated - use `parseAsync` instead */
+declare const parseAstAsync: typeof parseAstAsync$1;
+declare const esbuildVersion = "0.25.0";
+//#endregion
+export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type BindCLIShortcutsOptions, type BuildAppHook, BuildEnvironment, type BuildEnvironmentOptions, type BuildOptions, type BuilderOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type ChunkMetadata, type CommonServerOptions, type ConfigEnv, type ConfigPluginContext, type Connect, type ConnectedPayload, type CorsOptions, type CorsOrigin, type CustomEventMap, type CustomPayload, type CustomPluginOptionsVite, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, DevEnvironment, type DevEnvironmentContext, type DevEnvironmentOptions, type ESBuildOptions, type ESTree, type Environment, type EnvironmentModuleGraph, type EnvironmentModuleNode, type EnvironmentOptions, type ErrorPayload, type EsbuildTransformOptions, type ExperimentalOptions, type ExportsData, type FSWatcher, type FetchFunction, type FetchModuleOptions, type FetchResult, type FetchableDevEnvironment, type FetchableDevEnvironmentContext, type FileSystemServeOptions, type FilterPattern, type FullReloadPayload, type GeneralImportGlobOptions, type HMRPayload, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HotChannel, type HotChannelClient, type HotChannelListener, type HotPayload, type HotUpdateOptions, type HtmlTagDescriptor, type index_d_exports as HttpProxy, type HttpServer, type ImportGlobFunction, type ImportGlobOptions, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InferCustomEventPayload, type InlineConfig, type InternalResolveOptions, type InvalidatePayload, type JsonOptions, type KnownAsTypeMap, type LegacyOptions, type LessPreprocessorOptions, type LibraryFormats, type LibraryOptions, type LightningCSSOptions, type LogErrorOptions, type LogLevel, type LogOptions, type LogType, type Logger, type LoggerOptions, type Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, type MinifyOptions, type MinifyResult, type MinimalPluginContextWithoutEnvironment, type ModuleGraph, type ModuleNode, type ModulePreloadOptions, type ModuleRunnerTransformOptions, type NormalizedHotChannel, type NormalizedHotChannelClient, type NormalizedServerHotChannel, type OptimizedDepInfo, type OxcOptions, type ParseResult, type ParserOptions, type Plugin, type PluginContainer, type PluginHookUtils, type PluginOption, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, type PrunePayload, type RenderBuiltAssetUrl, type ResolveFn, type ResolveModulePreloadDependenciesFn, type ResolveOptions, type ResolvedBuildEnvironmentOptions, type ResolvedBuildOptions, type ResolvedCSSOptions, type ResolvedConfig, type ResolvedDevEnvironmentOptions, type ResolvedModulePreloadOptions, type ResolvedPreviewOptions, type ResolvedSSROptions, type ResolvedServerOptions, type ResolvedServerUrls, type ResolvedUrl, type ResolvedWorkerOptions, type ResolverFunction, type ResolverObject, type Rolldown, type Rollup, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type RunnableDevEnvironment, type RunnableDevEnvironmentContext, type SSROptions, type SSRTarget, type SassPreprocessorOptions, type SendOptions, type ServerHook, type ServerHotChannel, type ServerModuleRunnerOptions, type ServerOptions$1 as ServerOptions, type SkipInformation, type SsrDepOptimizationConfig, type StylusPreprocessorOptions, type Terser, type TerserOptions, type TransformOptions, type TransformResult, type Update, type UpdatePayload, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, Visitor, type VisitorObject, type ViteBuilder, type ViteDevServer, type WatchOptions, type WebSocket, type WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, type WebSocketServer, build, buildErrorMessage, createBuilder, createFetchableDevEnvironment, createFilter, createIdResolver, createLogger, createRunnableDevEnvironment, createServer, createServerHotChannel, createServerModuleRunner, createServerModuleRunnerTransport, defaultAllowedOrigins, DEFAULT_CLIENT_CONDITIONS as defaultClientConditions, DEFAULT_CLIENT_MAIN_FIELDS as defaultClientMainFields, DEFAULT_EXTERNAL_CONDITIONS as defaultExternalConditions, DEFAULT_SERVER_CONDITIONS as defaultServerConditions, DEFAULT_SERVER_MAIN_FIELDS as defaultServerMainFields, defineConfig, esbuildVersion, esmExternalRequirePlugin, fetchModule, formatPostcssSourceMap, isCSSRequest, isFetchableDevEnvironment, isFileLoadingAllowed, isFileServingAllowed, isRunnableDevEnvironment, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, minify, minifySync, ssrTransform as moduleRunnerTransform, normalizePath, optimizeDeps, parse, parseAst, parseAstAsync, parseSync, perEnvironmentPlugin, perEnvironmentState, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rolldownVersion, rollupVersion, runnerImport, searchForWorkspaceRoot, send, sortUserPlugins, transformWithEsbuild, transformWithOxc, VERSION as version, withFilter };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/index.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/index.js
new file mode 100644
index 0000000..a926fdc
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/index.js
@@ -0,0 +1,3 @@
+import { F as defaultAllowedOrigins, N as VERSION, _ as DEFAULT_SERVER_CONDITIONS, d as DEFAULT_CLIENT_MAIN_FIELDS, h as DEFAULT_EXTERNAL_CONDITIONS, n as createLogger, u as DEFAULT_CLIENT_CONDITIONS, v as DEFAULT_SERVER_MAIN_FIELDS } from "./chunks/logger.js";
+import { $ as mergeConfig, B as perEnvironmentState, C as build, E as optimizeDeps, F as fetchModule, G as loadEnv, H as createServerModuleRunner, I as formatPostcssSourceMap, J as transformWithEsbuild, K as resolveEnvPrefix, L as preprocessCSS, M as send, N as isFileLoadingAllowed, O as createServerHotChannel, P as isFileServingAllowed, Q as mergeAlias, R as searchForWorkspaceRoot, S as BuildEnvironment, T as createBuilder, U as createServerModuleRunnerTransport, V as ssrTransform, W as buildErrorMessage, X as createFilter, Y as perEnvironmentPlugin, Z as isCSSRequest, _ as runnerImport, a as minifySync, b as createRunnableDevEnvironment, c as parseAstAsync, d as isFetchableDevEnvironment, et as normalizePath, g as sortUserPlugins, h as resolveConfig, i as minify, j as DevEnvironment, k as createServer, l as parseSync, m as loadConfigFromFile, n as esbuildVersion, nt as rollupVersion, o as parse, p as defineConfig, q as transformWithOxc, r as esmExternalRequirePlugin, rt as withFilter, s as parseAst, t as Visitor, tt as rolldownVersion, u as createFetchableDevEnvironment, v as preview, x as isRunnableDevEnvironment, z as createIdResolver } from "./chunks/node.js";
+export { BuildEnvironment, DevEnvironment, Visitor, build, buildErrorMessage, createBuilder, createFetchableDevEnvironment, createFilter, createIdResolver, createLogger, createRunnableDevEnvironment, createServer, createServerHotChannel, createServerModuleRunner, createServerModuleRunnerTransport, defaultAllowedOrigins, DEFAULT_CLIENT_CONDITIONS as defaultClientConditions, DEFAULT_CLIENT_MAIN_FIELDS as defaultClientMainFields, DEFAULT_EXTERNAL_CONDITIONS as defaultExternalConditions, DEFAULT_SERVER_CONDITIONS as defaultServerConditions, DEFAULT_SERVER_MAIN_FIELDS as defaultServerMainFields, defineConfig, esbuildVersion, esmExternalRequirePlugin, fetchModule, formatPostcssSourceMap, isCSSRequest, isFetchableDevEnvironment, isFileLoadingAllowed, isFileServingAllowed, isRunnableDevEnvironment, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, minify, minifySync, ssrTransform as moduleRunnerTransform, normalizePath, optimizeDeps, parse, parseAst, parseAstAsync, parseSync, perEnvironmentPlugin, perEnvironmentState, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rolldownVersion, rollupVersion, runnerImport, searchForWorkspaceRoot, send, sortUserPlugins, transformWithEsbuild, transformWithOxc, VERSION as version, withFilter };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/internal.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/internal.d.ts
new file mode 100644
index 0000000..fd5e08a
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/internal.d.ts
@@ -0,0 +1,2 @@
+import { viteReactRefreshWrapperPlugin as reactRefreshWrapperPlugin } from "rolldown/experimental";
+export { reactRefreshWrapperPlugin };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/internal.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/internal.js
new file mode 100644
index 0000000..db0c368
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/internal.js
@@ -0,0 +1,2 @@
+import { viteReactRefreshWrapperPlugin as reactRefreshWrapperPlugin } from "rolldown/experimental";
+export { reactRefreshWrapperPlugin };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/module-runner.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/module-runner.d.ts
new file mode 100644
index 0000000..0ea4b4c
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/module-runner.d.ts
@@ -0,0 +1,314 @@
+import { a as ExternalFetchResult, c as ViteFetchResult, i as createWebSocketModuleRunnerTransport, n as ModuleRunnerTransportHandlers, o as FetchFunctionOptions, r as NormalizedModuleRunnerTransport, s as FetchResult, t as ModuleRunnerTransport } from "./chunks/moduleRunnerTransport.js";
+import { ModuleNamespace, ViteHotContext } from "#types/hot";
+import { HotPayload, Update } from "#types/hmrPayload";
+import { InferCustomEventPayload } from "#types/customEvent";
+
+//#region src/module-runner/sourcemap/decoder.d.ts
+interface SourceMapLike {
+  version: number;
+  mappings?: string;
+  names?: string[];
+  sources?: string[];
+  sourcesContent?: string[];
+}
+declare class DecodedMap {
+  map: SourceMapLike;
+  _encoded: string;
+  _decoded: undefined | number[][][];
+  _decodedMemo: Stats;
+  url: string;
+  file: string;
+  version: number;
+  names: string[];
+  resolvedSources: string[];
+  constructor(map: SourceMapLike, from: string);
+}
+interface Stats {
+  lastKey: number;
+  lastNeedle: number;
+  lastIndex: number;
+}
+//#endregion
+//#region src/shared/hmr.d.ts
+type CustomListenersMap = Map<string, ((data: any) => void)[]>;
+interface HotModule {
+  id: string;
+  callbacks: HotCallback[];
+}
+interface HotCallback {
+  deps: string[];
+  fn: (modules: Array<ModuleNamespace | undefined>) => void;
+}
+interface HMRLogger {
+  error(msg: string | Error): void;
+  debug(...msg: unknown[]): void;
+}
+declare class HMRClient {
+  logger: HMRLogger;
+  private transport;
+  private importUpdatedModule;
+  hotModulesMap: Map<string, HotModule>;
+  disposeMap: Map<string, (data: any) => void | Promise<void>>;
+  pruneMap: Map<string, (data: any) => void | Promise<void>>;
+  dataMap: Map<string, any>;
+  customListenersMap: CustomListenersMap;
+  ctxToListenersMap: Map<string, CustomListenersMap>;
+  currentFirstInvalidatedBy: string | undefined;
+  constructor(logger: HMRLogger, transport: NormalizedModuleRunnerTransport, importUpdatedModule: (update: Update) => Promise<ModuleNamespace>);
+  notifyListeners<T extends string>(event: T, data: InferCustomEventPayload<T>): Promise<void>;
+  send(payload: HotPayload): void;
+  clear(): void;
+  prunePaths(paths: string[]): Promise<void>;
+  protected warnFailedUpdate(err: Error, path: string | string[]): void;
+  private updateQueue;
+  private pendingUpdateQueue;
+  /**
+  * buffer multiple hot updates triggered by the same src change
+  * so that they are invoked in the same order they were sent.
+  * (otherwise the order may be inconsistent because of the http request round trip)
+  */
+  queueUpdate(payload: Update): Promise<void>;
+  private fetchUpdate;
+}
+//#endregion
+//#region src/shared/ssrTransform.d.ts
+interface DefineImportMetadata {
+  /**
+  * Imported names before being transformed to `ssrImportKey`
+  *
+  * import foo, { bar as baz, qux } from 'hello'
+  * => ['default', 'bar', 'qux']
+  *
+  * import * as namespace from 'world
+  * => undefined
+  */
+  importedNames?: string[];
+}
+interface SSRImportMetadata extends DefineImportMetadata {
+  isDynamicImport?: boolean;
+}
+//#endregion
+//#region src/module-runner/constants.d.ts
+declare const ssrModuleExportsKey = "__vite_ssr_exports__";
+declare const ssrImportKey = "__vite_ssr_import__";
+declare const ssrDynamicImportKey = "__vite_ssr_dynamic_import__";
+declare const ssrExportAllKey = "__vite_ssr_exportAll__";
+declare const ssrExportNameKey = "__vite_ssr_exportName__";
+declare const ssrImportMetaKey = "__vite_ssr_import_meta__";
+//#endregion
+//#region src/module-runner/runner.d.ts
+interface ModuleRunnerDebugger {
+  (formatter: unknown, ...args: unknown[]): void;
+}
+declare class ModuleRunner {
+  options: ModuleRunnerOptions;
+  evaluator: ModuleEvaluator;
+  private debug?;
+  evaluatedModules: EvaluatedModules;
+  hmrClient?: HMRClient;
+  private readonly transport;
+  private readonly resetSourceMapSupport?;
+  private readonly concurrentModuleNodePromises;
+  private isBuiltin?;
+  private builtinsPromise?;
+  private closed;
+  constructor(options: ModuleRunnerOptions, evaluator?: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
+  /**
+  * URL to execute. Accepts file path, server path or id relative to the root.
+  */
+  import<T = any>(url: string): Promise<T>;
+  /**
+  * Clear all caches including HMR listeners.
+  */
+  clearCache(): void;
+  /**
+  * Clears all caches, removes all HMR listeners, and resets source map support.
+  * This method doesn't stop the HMR connection.
+  */
+  close(): Promise<void>;
+  /**
+  * Returns `true` if the runtime has been closed by calling `close()` method.
+  */
+  isClosed(): boolean;
+  private processImport;
+  private isCircularRequest;
+  private cachedRequest;
+  private cachedModule;
+  private ensureBuiltins;
+  private getModuleInformation;
+  protected directRequest(url: string, mod: EvaluatedModuleNode, _callstack: string[]): Promise<any>;
+}
+//#endregion
+//#region src/module-runner/sourcemap/interceptor.d.ts
+interface RetrieveFileHandler {
+  (path: string): string | null | undefined | false;
+}
+interface RetrieveSourceMapHandler {
+  (path: string): null | {
+    url: string;
+    map: any;
+  };
+}
+interface InterceptorOptions {
+  retrieveFile?: RetrieveFileHandler;
+  retrieveSourceMap?: RetrieveSourceMapHandler;
+}
+//#endregion
+//#region src/module-runner/types.d.ts
+interface ModuleRunnerImportMeta {
+  url: string;
+  env: ImportMetaEnv;
+  hot?: ViteHotContext;
+  dirname: string;
+  filename: string;
+  glob: (...args: any[]) => any;
+  resolve(specifier: string, parent?: string): string;
+  [key: string]: any;
+}
+interface ModuleRunnerContext {
+  [ssrModuleExportsKey]: Record<string, any>;
+  [ssrImportKey]: (id: string, metadata?: DefineImportMetadata) => Promise<any>;
+  [ssrDynamicImportKey]: (id: string, options?: ImportCallOptions) => Promise<any>;
+  [ssrExportAllKey]: (obj: any) => void;
+  [ssrExportNameKey]: (name: string, getter: () => unknown) => void;
+  [ssrImportMetaKey]: ModuleRunnerImportMeta;
+}
+interface ModuleEvaluator {
+  /**
+  * Number of prefixed lines in the transformed code.
+  */
+  startOffset?: number;
+  /**
+  * Run code that was transformed by Vite.
+  * @param context Function context
+  * @param code Transformed code
+  * @param module The module node
+  */
+  runInlinedModule(context: ModuleRunnerContext, code: string, module: Readonly<EvaluatedModuleNode>): Promise<any>;
+  /**
+  * Run externalized module.
+  * @param file File URL to the external module
+  */
+  runExternalModule(file: string): Promise<any>;
+}
+type ResolvedResult = (ExternalFetchResult | ViteFetchResult) & {
+  url: string;
+  id: string;
+};
+type FetchFunction = (id: string, importer?: string, options?: FetchFunctionOptions) => Promise<FetchResult>;
+interface ModuleRunnerHmr {
+  /**
+  * Configure HMR logger.
+  */
+  logger?: false | HMRLogger;
+}
+interface ModuleRunnerOptions {
+  /**
+  * A set of methods to communicate with the server.
+  */
+  transport: ModuleRunnerTransport;
+  /**
+  * Configure how source maps are resolved. Prefers `node` if `process.setSourceMapsEnabled` is available.
+  * Otherwise it will use `prepareStackTrace` by default which overrides `Error.prepareStackTrace` method.
+  * You can provide an object to configure how file contents and source maps are resolved for files that were not processed by Vite.
+  */
+  sourcemapInterceptor?: false | "node" | "prepareStackTrace" | InterceptorOptions;
+  /**
+  * Disable HMR or configure HMR options.
+  *
+  * @default true
+  */
+  hmr?: boolean | ModuleRunnerHmr;
+  /**
+  * Create import.meta object for the module.
+  *
+  * @default createDefaultImportMeta
+  */
+  createImportMeta?: (modulePath: string) => ModuleRunnerImportMeta | Promise<ModuleRunnerImportMeta>;
+  /**
+  * Custom module cache. If not provided, creates a separate module cache for each ModuleRunner instance.
+  */
+  evaluatedModules?: EvaluatedModules;
+}
+interface ImportMetaEnv {
+  [key: string]: any;
+  BASE_URL: string;
+  MODE: string;
+  DEV: boolean;
+  PROD: boolean;
+  SSR: boolean;
+}
+//#endregion
+//#region src/module-runner/evaluatedModules.d.ts
+declare class EvaluatedModuleNode {
+  id: string;
+  url: string;
+  importers: Set<string>;
+  imports: Set<string>;
+  evaluated: boolean;
+  meta: ResolvedResult | undefined;
+  promise: Promise<any> | undefined;
+  exports: any;
+  file: string;
+  map: DecodedMap | undefined;
+  constructor(id: string, url: string);
+}
+declare class EvaluatedModules {
+  readonly idToModuleMap: Map<string, EvaluatedModuleNode>;
+  readonly fileToModulesMap: Map<string, Set<EvaluatedModuleNode>>;
+  readonly urlToIdModuleMap: Map<string, EvaluatedModuleNode>;
+  /**
+  * Returns the module node by the resolved module ID. Usually, module ID is
+  * the file system path with query and/or hash. It can also be a virtual module.
+  *
+  * Module runner graph will have 1 to 1 mapping with the server module graph.
+  * @param id Resolved module ID
+  */
+  getModuleById(id: string): EvaluatedModuleNode | undefined;
+  /**
+  * Returns all modules related to the file system path. Different modules
+  * might have different query parameters or hash, so it's possible to have
+  * multiple modules for the same file.
+  * @param file The file system path of the module
+  */
+  getModulesByFile(file: string): Set<EvaluatedModuleNode> | undefined;
+  /**
+  * Returns the module node by the URL that was used in the import statement.
+  * Unlike module graph on the server, the URL is not resolved and is used as is.
+  * @param url Server URL that was used in the import statement
+  */
+  getModuleByUrl(url: string): EvaluatedModuleNode | undefined;
+  /**
+  * Ensure that module is in the graph. If the module is already in the graph,
+  * it will return the existing module node. Otherwise, it will create a new
+  * module node and add it to the graph.
+  * @param id Resolved module ID
+  * @param url URL that was used in the import statement
+  */
+  ensureModule(id: string, url: string): EvaluatedModuleNode;
+  invalidateModule(node: EvaluatedModuleNode): void;
+  /**
+  * Extracts the inlined source map from the module code and returns the decoded
+  * source map. If the source map is not inlined, it will return null.
+  * @param id Resolved module ID
+  */
+  getModuleSourceMapById(id: string): DecodedMap | null;
+  clear(): void;
+}
+declare function normalizeModuleId(file: string): string;
+//#endregion
+//#region src/module-runner/esmEvaluator.d.ts
+declare class ESModulesEvaluator implements ModuleEvaluator {
+  readonly startOffset: number;
+  runInlinedModule(context: ModuleRunnerContext, code: string): Promise<any>;
+  runExternalModule(filepath: string): Promise<any>;
+}
+//#endregion
+//#region src/module-runner/createImportMeta.d.ts
+declare function createDefaultImportMeta(modulePath: string): ModuleRunnerImportMeta;
+/**
+* Create import.meta object for Node.js.
+*/
+declare function createNodeImportMeta(modulePath: string): ModuleRunnerImportMeta;
+//#endregion
+export { ESModulesEvaluator, type EvaluatedModuleNode, EvaluatedModules, type FetchFunction, type FetchFunctionOptions, type FetchResult, type HMRLogger, type InterceptorOptions, type ModuleEvaluator, ModuleRunner, type ModuleRunnerContext, type ModuleRunnerHmr, type ModuleRunnerImportMeta, type ModuleRunnerOptions, type ModuleRunnerTransport, type ModuleRunnerTransportHandlers, type ResolvedResult, type SSRImportMetadata, createDefaultImportMeta, createNodeImportMeta, createWebSocketModuleRunnerTransport, normalizeModuleId, ssrDynamicImportKey, ssrExportAllKey, ssrExportNameKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/module-runner.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/module-runner.js
new file mode 100644
index 0000000..fbfa449
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/dist/node/module-runner.js
@@ -0,0 +1,1269 @@
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+//#endregion
+//#region src/shared/utils.ts
+const isWindows = typeof process < "u" && process.platform === "win32";
+/**
+* Undo {@link wrapId}'s `/@id/` and null byte replacements.
+*/
+function unwrapId(id) {
+	return id.startsWith("/@id/") ? id.slice(5).replace("__x00__", "\0") : id;
+}
+const windowsSlashRE = /\\/g;
+function slash(p) {
+	return p.replace(windowsSlashRE, "/");
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function isPrimitive(value) {
+	return !value || typeof value != "object" && typeof value != "function";
+}
+const AsyncFunction = async function() {}.constructor;
+let asyncFunctionDeclarationPaddingLineCount;
+function getAsyncFunctionDeclarationPaddingLineCount() {
+	if (asyncFunctionDeclarationPaddingLineCount === void 0) {
+		let body = "/*code*/", source = new AsyncFunction("a", "b", body).toString();
+		asyncFunctionDeclarationPaddingLineCount = source.slice(0, source.indexOf(body)).split("\n").length - 1;
+	}
+	return asyncFunctionDeclarationPaddingLineCount;
+}
+function promiseWithResolvers() {
+	let resolve, reject;
+	return {
+		promise: new Promise((_resolve, _reject) => {
+			resolve = _resolve, reject = _reject;
+		}),
+		resolve,
+		reject
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/, _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+function cwd() {
+	return typeof process < "u" && typeof process.cwd == "function" ? process.cwd().replace(/\\/g, "/") : "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "", resolvedAbsolute = !1;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		let path = index >= 0 ? arguments_[index] : cwd();
+		!path || path.length === 0 || (resolvedPath = `${path}/${resolvedPath}`, resolvedAbsolute = isAbsolute(path));
+	}
+	return resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (!(lastSlash === index - 1 || dots === 1)) if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						let lastSlashIndex = res.lastIndexOf("/");
+						lastSlashIndex === -1 ? (res = "", lastSegmentLength = 0) : (res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/")), lastSlash = index, dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "", lastSegmentLength = 0, lastSlash = index, dots = 0;
+						continue;
+					}
+				}
+				allowAboveRoot && (res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2);
+			} else res.length > 0 ? res += `/${path.slice(lastSlash + 1, index)}` : res = path.slice(lastSlash + 1, index), lastSegmentLength = index - lastSlash - 1;
+			lastSlash = index, dots = 0;
+		} else char === "." && dots !== -1 ? ++dots : dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+}, dirname = function(p) {
+	let segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	return segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0]) && (segments[0] += "/"), segments.join("/") || (isAbsolute(p) ? "/" : ".");
+}, textDecoder = new TextDecoder(), decodeBase64 = typeof Buffer == "function" && typeof Buffer.from == "function" ? (base64) => Buffer.from(base64, "base64").toString("utf-8") : (base64) => textDecoder.decode(Uint8Array.from(atob(base64), (c) => c.charCodeAt(0))), percentRegEx = /%/g, backslashRegEx = /\\/g, newlineRegEx = /\n/g, carriageReturnRegEx = /\r/g, tabRegEx = /\t/g, questionRegex = /\?/g, hashRegex = /#/g;
+function encodePathChars(filepath) {
+	return filepath.includes("%") && (filepath = filepath.replace(percentRegEx, "%25")), !isWindows && filepath.includes("\\") && (filepath = filepath.replace(backslashRegEx, "%5C")), filepath.includes("\n") && (filepath = filepath.replace(newlineRegEx, "%0A")), filepath.includes("\r") && (filepath = filepath.replace(carriageReturnRegEx, "%0D")), filepath.includes("	") && (filepath = filepath.replace(tabRegEx, "%09")), filepath;
+}
+const posixDirname = dirname, posixResolve = resolve;
+function posixPathToFileHref(posixPath) {
+	let resolved = posixResolve(posixPath), filePathLast = posixPath.charCodeAt(posixPath.length - 1);
+	return (filePathLast === 47 || isWindows && filePathLast === 92) && resolved[resolved.length - 1] !== "/" && (resolved += "/"), resolved = encodePathChars(resolved), resolved.includes("?") && (resolved = resolved.replace(questionRegex, "%3F")), resolved.includes("#") && (resolved = resolved.replace(hashRegex, "%23")), new URL(`file://${resolved}`).href;
+}
+function toWindowsPath(path) {
+	return path.replace(/\//g, "\\");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = 44, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", intToChar = new Uint8Array(64), charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	let c = chars.charCodeAt(i);
+	intToChar[i] = c, charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0, shift = 0, integer = 0;
+	do
+		integer = charToInt[reader.next()], value |= (integer & 31) << shift, shift += 5;
+	while (integer & 32);
+	let shouldNegate = value & 1;
+	return value >>>= 1, shouldNegate && (value = -2147483648 | -value), relative + value;
+}
+function hasMoreVlq(reader, max) {
+	return reader.pos >= max ? !1 : reader.peek() !== comma;
+}
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0, this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		let { buffer, pos } = this, idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	let { length } = mappings, reader = new StringReader(mappings), decoded = [], genColumn = 0, sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
+	do {
+		let semi = reader.indexOf(";"), line = [], sorted = !0, lastCol = 0;
+		for (genColumn = 0; reader.pos < semi;) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn), genColumn < lastCol && (sorted = !1), lastCol = genColumn, hasMoreVlq(reader, semi) ? (sourcesIndex = decodeInteger(reader, sourcesIndex), sourceLine = decodeInteger(reader, sourceLine), sourceColumn = decodeInteger(reader, sourceColumn), hasMoreVlq(reader, semi) ? (namesIndex = decodeInteger(reader, namesIndex), seg = [
+				genColumn,
+				sourcesIndex,
+				sourceLine,
+				sourceColumn,
+				namesIndex
+			]) : seg = [
+				genColumn,
+				sourcesIndex,
+				sourceLine,
+				sourceColumn
+			]) : seg = [genColumn], line.push(seg), reader.pos++;
+		}
+		sorted || sort(line), decoded.push(line), reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[0] - b[0];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+var COLUMN = 0, SOURCES_INDEX = 1, SOURCE_LINE = 2, SOURCE_COLUMN = 3, NAMES_INDEX = 4, found = !1;
+function binarySearch(haystack, needle, low, high) {
+	for (; low <= high;) {
+		let mid = low + (high - low >> 1), cmp = haystack[mid][COLUMN] - needle;
+		if (cmp === 0) return found = !0, mid;
+		cmp < 0 ? low = mid + 1 : high = mid - 1;
+	}
+	return found = !1, low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length && haystack[i][COLUMN] === needle; index = i++);
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0 && haystack[i][COLUMN] === needle; index = i--);
+	return index;
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+	let { lastKey, lastNeedle, lastIndex } = state, low = 0, high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) return found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle, lastIndex;
+		needle >= lastNeedle ? low = lastIndex === -1 ? 0 : lastIndex : high = lastIndex;
+	}
+	return state.lastKey = key, state.lastNeedle = needle, state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)", COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+function cast(map) {
+	return map;
+}
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+	let { line, column, bias } = needle;
+	if (line--, line < 0) throw Error(LINE_GTR_ZERO);
+	if (column < 0) throw Error(COL_GTR_EQ_ZERO);
+	let decoded = decodedMappings(map);
+	if (line >= decoded.length) return OMapping(null, null, null, null);
+	let segments = decoded[line], index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || 1);
+	if (index === -1) return OMapping(null, null, null, null);
+	let segment = segments[index];
+	if (segment.length === 1) return OMapping(null, null, null, null);
+	let { names, resolvedSources } = map;
+	return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	return found ? index = (bias === -1 ? upperBound : lowerBound)(segments, column, index) : bias === -1 && index++, index === -1 || index === segments.length ? -1 : index;
+}
+//#endregion
+//#region src/module-runner/sourcemap/decoder.ts
+var DecodedMap = class {
+	map;
+	_encoded;
+	_decoded;
+	_decodedMemo;
+	url;
+	file;
+	version;
+	names = [];
+	resolvedSources;
+	constructor(map, from) {
+		this.map = map;
+		let { mappings, names, sources } = map;
+		this.version = map.version, this.names = names || [], this._encoded = mappings || "", this._decodedMemo = memoizedState(), this.url = from, this.file = from;
+		let originDir = posixDirname(from);
+		this.resolvedSources = (sources || []).map((s) => posixResolve(originDir, s || ""));
+	}
+};
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function getOriginalPosition(map, needle) {
+	let result = originalPositionFor(map, needle);
+	return result.column == null ? null : result;
+}
+//#endregion
+//#region src/module-runner/evaluatedModules.ts
+const MODULE_RUNNER_SOURCEMAPPING_REGEXP = RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`);
+var EvaluatedModuleNode = class {
+	id;
+	url;
+	importers = /* @__PURE__ */ new Set();
+	imports = /* @__PURE__ */ new Set();
+	evaluated = !1;
+	meta;
+	promise;
+	exports;
+	file;
+	map;
+	constructor(id, url) {
+		this.id = id, this.url = url, this.file = cleanUrl(id);
+	}
+}, EvaluatedModules = class {
+	idToModuleMap = /* @__PURE__ */ new Map();
+	fileToModulesMap = /* @__PURE__ */ new Map();
+	urlToIdModuleMap = /* @__PURE__ */ new Map();
+	/**
+	* Returns the module node by the resolved module ID. Usually, module ID is
+	* the file system path with query and/or hash. It can also be a virtual module.
+	*
+	* Module runner graph will have 1 to 1 mapping with the server module graph.
+	* @param id Resolved module ID
+	*/
+	getModuleById(id) {
+		return this.idToModuleMap.get(id);
+	}
+	/**
+	* Returns all modules related to the file system path. Different modules
+	* might have different query parameters or hash, so it's possible to have
+	* multiple modules for the same file.
+	* @param file The file system path of the module
+	*/
+	getModulesByFile(file) {
+		return this.fileToModulesMap.get(file);
+	}
+	/**
+	* Returns the module node by the URL that was used in the import statement.
+	* Unlike module graph on the server, the URL is not resolved and is used as is.
+	* @param url Server URL that was used in the import statement
+	*/
+	getModuleByUrl(url) {
+		return this.urlToIdModuleMap.get(unwrapId(url));
+	}
+	/**
+	* Ensure that module is in the graph. If the module is already in the graph,
+	* it will return the existing module node. Otherwise, it will create a new
+	* module node and add it to the graph.
+	* @param id Resolved module ID
+	* @param url URL that was used in the import statement
+	*/
+	ensureModule(id, url) {
+		if (id = normalizeModuleId(id), this.idToModuleMap.has(id)) {
+			let moduleNode = this.idToModuleMap.get(id);
+			return this.urlToIdModuleMap.set(url, moduleNode), moduleNode;
+		}
+		let moduleNode = new EvaluatedModuleNode(id, url);
+		this.idToModuleMap.set(id, moduleNode), this.urlToIdModuleMap.set(url, moduleNode);
+		let fileModules = this.fileToModulesMap.get(moduleNode.file) || /* @__PURE__ */ new Set();
+		return fileModules.add(moduleNode), this.fileToModulesMap.set(moduleNode.file, fileModules), moduleNode;
+	}
+	invalidateModule(node) {
+		node.evaluated = !1, node.meta = void 0, node.map = void 0, node.promise = void 0, node.exports = void 0, node.imports.clear();
+	}
+	/**
+	* Extracts the inlined source map from the module code and returns the decoded
+	* source map. If the source map is not inlined, it will return null.
+	* @param id Resolved module ID
+	*/
+	getModuleSourceMapById(id) {
+		let mod = this.getModuleById(id);
+		if (!mod) return null;
+		if (mod.map) return mod.map;
+		if (!mod.meta || !("code" in mod.meta)) return null;
+		let pattern = `//# ${SOURCEMAPPING_URL}=data:application/json;base64,`, lastIndex = mod.meta.code.lastIndexOf(pattern);
+		if (lastIndex === -1) return null;
+		let mapString = MODULE_RUNNER_SOURCEMAPPING_REGEXP.exec(mod.meta.code.slice(lastIndex))?.[1];
+		return mapString ? (mod.map = new DecodedMap(JSON.parse(decodeBase64(mapString)), mod.file), mod.map) : null;
+	}
+	clear() {
+		this.idToModuleMap.clear(), this.fileToModulesMap.clear(), this.urlToIdModuleMap.clear();
+	}
+};
+const prefixedBuiltins = new Set([
+	"node:sea",
+	"node:sqlite",
+	"node:test",
+	"node:test/reporters"
+]);
+function normalizeModuleId(file) {
+	return prefixedBuiltins.has(file) ? file : slash(file).replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\/+/, isWindows ? "" : "/");
+}
+//#endregion
+//#region src/shared/hmr.ts
+var HMRContext = class {
+	hmrClient;
+	ownerPath;
+	newListeners;
+	constructor(hmrClient, ownerPath) {
+		this.hmrClient = hmrClient, this.ownerPath = ownerPath, hmrClient.dataMap.has(ownerPath) || hmrClient.dataMap.set(ownerPath, {});
+		let mod = hmrClient.hotModulesMap.get(ownerPath);
+		mod && (mod.callbacks = []);
+		let staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+		if (staleListeners) for (let [event, staleFns] of staleListeners) {
+			let listeners = hmrClient.customListenersMap.get(event);
+			listeners && hmrClient.customListenersMap.set(event, listeners.filter((l) => !staleFns.includes(l)));
+		}
+		this.newListeners = /* @__PURE__ */ new Map(), hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+	}
+	get data() {
+		return this.hmrClient.dataMap.get(this.ownerPath);
+	}
+	accept(deps, callback) {
+		if (typeof deps == "function" || !deps) this.acceptDeps([this.ownerPath], ([mod]) => deps?.(mod));
+		else if (typeof deps == "string") this.acceptDeps([deps], ([mod]) => callback?.(mod));
+		else if (Array.isArray(deps)) this.acceptDeps(deps, callback);
+		else throw Error("invalid hot.accept() usage.");
+	}
+	acceptExports(_, callback) {
+		this.acceptDeps([this.ownerPath], ([mod]) => callback?.(mod));
+	}
+	dispose(cb) {
+		this.hmrClient.disposeMap.set(this.ownerPath, cb);
+	}
+	prune(cb) {
+		this.hmrClient.pruneMap.set(this.ownerPath, cb);
+	}
+	decline() {}
+	invalidate(message) {
+		let firstInvalidatedBy = this.hmrClient.currentFirstInvalidatedBy ?? this.ownerPath;
+		this.hmrClient.notifyListeners("vite:invalidate", {
+			path: this.ownerPath,
+			message,
+			firstInvalidatedBy
+		}), this.send("vite:invalidate", {
+			path: this.ownerPath,
+			message,
+			firstInvalidatedBy
+		}), this.hmrClient.logger.debug(`invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`);
+	}
+	on(event, cb) {
+		let addToMap = (map) => {
+			let existing = map.get(event) || [];
+			existing.push(cb), map.set(event, existing);
+		};
+		addToMap(this.hmrClient.customListenersMap), addToMap(this.newListeners);
+	}
+	off(event, cb) {
+		let removeFromMap = (map) => {
+			let existing = map.get(event);
+			if (existing === void 0) return;
+			let pruned = existing.filter((l) => l !== cb);
+			if (pruned.length === 0) {
+				map.delete(event);
+				return;
+			}
+			map.set(event, pruned);
+		};
+		removeFromMap(this.hmrClient.customListenersMap), removeFromMap(this.newListeners);
+	}
+	send(event, data) {
+		this.hmrClient.send({
+			type: "custom",
+			event,
+			data
+		});
+	}
+	acceptDeps(deps, callback = () => {}) {
+		let mod = this.hmrClient.hotModulesMap.get(this.ownerPath) || {
+			id: this.ownerPath,
+			callbacks: []
+		};
+		mod.callbacks.push({
+			deps,
+			fn: callback
+		}), this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
+	}
+}, HMRClient = class {
+	logger;
+	transport;
+	importUpdatedModule;
+	hotModulesMap = /* @__PURE__ */ new Map();
+	disposeMap = /* @__PURE__ */ new Map();
+	pruneMap = /* @__PURE__ */ new Map();
+	dataMap = /* @__PURE__ */ new Map();
+	customListenersMap = /* @__PURE__ */ new Map();
+	ctxToListenersMap = /* @__PURE__ */ new Map();
+	currentFirstInvalidatedBy;
+	constructor(logger, transport, importUpdatedModule) {
+		this.logger = logger, this.transport = transport, this.importUpdatedModule = importUpdatedModule;
+	}
+	async notifyListeners(event, data) {
+		let cbs = this.customListenersMap.get(event);
+		cbs && await Promise.allSettled(cbs.map((cb) => cb(data)));
+	}
+	send(payload) {
+		this.transport.send(payload).catch((err) => {
+			this.logger.error(err);
+		});
+	}
+	clear() {
+		this.hotModulesMap.clear(), this.disposeMap.clear(), this.pruneMap.clear(), this.dataMap.clear(), this.customListenersMap.clear(), this.ctxToListenersMap.clear();
+	}
+	async prunePaths(paths) {
+		await Promise.all(paths.map((path) => {
+			let disposer = this.disposeMap.get(path);
+			if (disposer) return disposer(this.dataMap.get(path));
+		})), await Promise.all(paths.map((path) => {
+			let fn = this.pruneMap.get(path);
+			if (fn) return fn(this.dataMap.get(path));
+		}));
+	}
+	warnFailedUpdate(err, path) {
+		(!(err instanceof Error) || !err.message.includes("fetch")) && this.logger.error(err), this.logger.error(`Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
+	}
+	updateQueue = [];
+	pendingUpdateQueue = !1;
+	/**
+	* buffer multiple hot updates triggered by the same src change
+	* so that they are invoked in the same order they were sent.
+	* (otherwise the order may be inconsistent because of the http request round trip)
+	*/
+	async queueUpdate(payload) {
+		if (this.updateQueue.push(this.fetchUpdate(payload)), !this.pendingUpdateQueue) {
+			this.pendingUpdateQueue = !0, await Promise.resolve(), this.pendingUpdateQueue = !1;
+			let loading = [...this.updateQueue];
+			this.updateQueue = [], (await Promise.all(loading)).forEach((fn) => fn && fn());
+		}
+	}
+	async fetchUpdate(update) {
+		let { path, acceptedPath, firstInvalidatedBy } = update, mod = this.hotModulesMap.get(path);
+		if (!mod) return;
+		let fetchedModule, isSelfUpdate = path === acceptedPath, qualifiedCallbacks = mod.callbacks.filter(({ deps }) => deps.includes(acceptedPath));
+		if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+			let disposer = this.disposeMap.get(acceptedPath);
+			disposer && await disposer(this.dataMap.get(acceptedPath));
+			try {
+				fetchedModule = await this.importUpdatedModule(update);
+			} catch (e) {
+				this.warnFailedUpdate(e, acceptedPath);
+			}
+		}
+		return () => {
+			try {
+				this.currentFirstInvalidatedBy = firstInvalidatedBy;
+				for (let { deps, fn } of qualifiedCallbacks) fn(deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0));
+				let loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+				this.logger.debug(`hot updated: ${loggedPath}`);
+			} finally {
+				this.currentFirstInvalidatedBy = void 0;
+			}
+		};
+	}
+};
+//#endregion
+//#region src/shared/ssrTransform.ts
+/**
+* Vite converts `import { } from 'foo'` to `const _ = __vite_ssr_import__('foo')`.
+* Top-level imports and dynamic imports work slightly differently in Node.js.
+* This function normalizes the differences so it matches prod behaviour.
+*/
+function analyzeImportedModDifference(mod, rawId, moduleType, metadata) {
+	if (!metadata?.isDynamicImport && metadata?.importedNames?.length) {
+		let missingBindings = metadata.importedNames.filter((s) => !(s in mod));
+		if (missingBindings.length) {
+			let lastBinding = missingBindings[missingBindings.length - 1];
+			throw SyntaxError(moduleType === "module" ? `[vite] The requested module '${rawId}' does not provide an export named '${lastBinding}'` : `\
+[vite] Named export '${lastBinding}' not found. The requested module '${rawId}' is a CommonJS module, which may not support all module.exports as named exports.
+CommonJS modules can always be imported via the default export, for example using:
+
+import pkg from '${rawId}';
+const {${missingBindings.join(", ")}} = pkg;
+`);
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/non-secure/index.js
+let nanoid = (size = 21) => {
+	let id = "", i = size | 0;
+	for (; i--;) id += "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict"[Math.random() * 64 | 0];
+	return id;
+};
+//#endregion
+//#region src/shared/moduleRunnerTransport.ts
+function reviveInvokeError(e) {
+	let error = Error(e.message || "Unknown invoke error");
+	return Object.assign(error, e, { runnerError: /* @__PURE__ */ Error("RunnerError") }), error;
+}
+const createInvokeableTransport = (transport) => {
+	if (transport.invoke) return {
+		...transport,
+		async invoke(name, data) {
+			let result = await transport.invoke({
+				type: "custom",
+				event: "vite:invoke",
+				data: {
+					id: "send",
+					name,
+					data
+				}
+			});
+			if ("error" in result) throw reviveInvokeError(result.error);
+			return result.result;
+		}
+	};
+	if (!transport.send || !transport.connect) throw Error("transport must implement send and connect when invoke is not implemented");
+	let rpcPromises = /* @__PURE__ */ new Map();
+	return {
+		...transport,
+		connect({ onMessage, onDisconnection }) {
+			return transport.connect({
+				onMessage(payload) {
+					if (payload.type === "custom" && payload.event === "vite:invoke") {
+						let data = payload.data;
+						if (data.id.startsWith("response:")) {
+							let invokeId = data.id.slice(9), promise = rpcPromises.get(invokeId);
+							if (!promise) return;
+							promise.timeoutId && clearTimeout(promise.timeoutId), rpcPromises.delete(invokeId);
+							let { error, result } = data.data;
+							error ? promise.reject(error) : promise.resolve(result);
+							return;
+						}
+					}
+					onMessage(payload);
+				},
+				onDisconnection
+			});
+		},
+		disconnect() {
+			return rpcPromises.forEach((promise) => {
+				promise.reject(/* @__PURE__ */ Error(`transport was disconnected, cannot call ${JSON.stringify(promise.name)}`));
+			}), rpcPromises.clear(), transport.disconnect?.();
+		},
+		send(data) {
+			return transport.send(data);
+		},
+		async invoke(name, data) {
+			let promiseId = nanoid(), wrappedData = {
+				type: "custom",
+				event: "vite:invoke",
+				data: {
+					name,
+					id: `send:${promiseId}`,
+					data
+				}
+			}, sendPromise = transport.send(wrappedData), { promise, resolve, reject } = promiseWithResolvers(), timeout = transport.timeout ?? 6e4, timeoutId;
+			timeout > 0 && (timeoutId = setTimeout(() => {
+				rpcPromises.delete(promiseId), reject(/* @__PURE__ */ Error(`transport invoke timed out after ${timeout}ms (data: ${JSON.stringify(wrappedData)})`));
+			}, timeout), timeoutId?.unref?.()), rpcPromises.set(promiseId, {
+				resolve,
+				reject,
+				name,
+				timeoutId
+			}), sendPromise && sendPromise.catch((err) => {
+				clearTimeout(timeoutId), rpcPromises.delete(promiseId), reject(err);
+			});
+			try {
+				return await promise;
+			} catch (err) {
+				throw reviveInvokeError(err);
+			}
+		}
+	};
+}, normalizeModuleRunnerTransport = (transport) => {
+	let invokeableTransport = createInvokeableTransport(transport), isConnected = !invokeableTransport.connect, connectingPromise;
+	return {
+		...transport,
+		...invokeableTransport.connect ? { async connect(onMessage) {
+			if (isConnected) return;
+			if (connectingPromise) {
+				await connectingPromise;
+				return;
+			}
+			let maybePromise = invokeableTransport.connect({
+				onMessage: onMessage ?? (() => {}),
+				onDisconnection() {
+					isConnected = !1;
+				}
+			});
+			maybePromise && (connectingPromise = maybePromise, await connectingPromise, connectingPromise = void 0), isConnected = !0;
+		} } : {},
+		...invokeableTransport.disconnect ? { async disconnect() {
+			isConnected && (connectingPromise && await connectingPromise, isConnected = !1, await invokeableTransport.disconnect());
+		} } : {},
+		async send(data) {
+			if (invokeableTransport.send) {
+				if (!isConnected) if (connectingPromise) await connectingPromise;
+				else throw Error("send was called before connect");
+				await invokeableTransport.send(data);
+			}
+		},
+		async invoke(name, data) {
+			if (!isConnected) if (connectingPromise) await connectingPromise;
+			else throw Error("invoke was called before connect");
+			return invokeableTransport.invoke(name, data);
+		}
+	};
+}, createWebSocketModuleRunnerTransport = (options) => {
+	let pingInterval = options.pingInterval ?? 3e4, ws, pingIntervalId;
+	return {
+		async connect({ onMessage, onDisconnection }) {
+			let socket = options.createConnection();
+			socket.addEventListener("message", ({ data }) => {
+				onMessage(JSON.parse(data));
+			});
+			let isOpened = socket.readyState === socket.OPEN;
+			isOpened || await new Promise((resolve, reject) => {
+				socket.addEventListener("open", () => {
+					isOpened = !0, resolve();
+				}, { once: !0 }), socket.addEventListener("close", () => {
+					if (!isOpened) {
+						reject(/* @__PURE__ */ Error("WebSocket closed without opened."));
+						return;
+					}
+					onMessage({
+						type: "custom",
+						event: "vite:ws:disconnect",
+						data: { webSocket: socket }
+					}), onDisconnection();
+				});
+			}), onMessage({
+				type: "custom",
+				event: "vite:ws:connect",
+				data: { webSocket: socket }
+			}), ws = socket, pingIntervalId = setInterval(() => {
+				socket.readyState === socket.OPEN && socket.send(JSON.stringify({ type: "ping" }));
+			}, pingInterval);
+		},
+		disconnect() {
+			clearInterval(pingIntervalId), ws?.close();
+		},
+		send(data) {
+			ws.send(JSON.stringify(data));
+		}
+	};
+};
+//#endregion
+//#region src/shared/builtin.ts
+function createIsBuiltin(builtins) {
+	let plainBuiltinsSet = new Set(builtins.filter((builtin) => typeof builtin == "string")), regexBuiltins = builtins.filter((builtin) => typeof builtin != "string");
+	return (id) => plainBuiltinsSet.has(id) || regexBuiltins.some((regexp) => regexp.test(id));
+}
+//#endregion
+//#region src/module-runner/constants.ts
+const ssrModuleExportsKey = "__vite_ssr_exports__", ssrImportKey = "__vite_ssr_import__", ssrDynamicImportKey = "__vite_ssr_dynamic_import__", ssrExportAllKey = "__vite_ssr_exportAll__", ssrExportNameKey = "__vite_ssr_exportName__", ssrImportMetaKey = "__vite_ssr_import_meta__", noop = () => {}, silentConsole = {
+	debug: noop,
+	error: noop
+}, hmrLogger = {
+	debug: (...msg) => console.log("[vite]", ...msg),
+	error: (error) => console.log("[vite]", error)
+};
+//#endregion
+//#region src/shared/hmrHandler.ts
+function createHMRHandler(handler) {
+	let queue = new Queue();
+	return (payload) => queue.enqueue(() => handler(payload));
+}
+var Queue = class {
+	queue = [];
+	pending = !1;
+	enqueue(promise) {
+		return new Promise((resolve, reject) => {
+			this.queue.push({
+				promise,
+				resolve,
+				reject
+			}), this.dequeue();
+		});
+	}
+	dequeue() {
+		if (this.pending) return !1;
+		let item = this.queue.shift();
+		return item ? (this.pending = !0, item.promise().then(item.resolve).catch(item.reject).finally(() => {
+			this.pending = !1, this.dequeue();
+		}), !0) : !1;
+	}
+};
+//#endregion
+//#region src/module-runner/hmrHandler.ts
+function createHMRHandlerForRunner(runner) {
+	return createHMRHandler(async (payload) => {
+		let hmrClient = runner.hmrClient;
+		if (!(!hmrClient || runner.isClosed())) switch (payload.type) {
+			case "connected":
+				hmrClient.logger.debug("connected.");
+				break;
+			case "update":
+				await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(payload.updates.map(async (update) => {
+					if (update.type === "js-update") return update.acceptedPath = unwrapId(update.acceptedPath), update.path = unwrapId(update.path), hmrClient.queueUpdate(update);
+					hmrClient.logger.error("css hmr is not supported in runner mode.");
+				})), await hmrClient.notifyListeners("vite:afterUpdate", payload);
+				break;
+			case "custom":
+				await hmrClient.notifyListeners(payload.event, payload.data);
+				break;
+			case "full-reload": {
+				let { triggeredBy } = payload, clearEntrypointUrls = triggeredBy ? getModulesEntrypoints(runner, getModulesByFile(runner, slash(triggeredBy))) : findAllEntrypoints(runner);
+				if (!clearEntrypointUrls.size) break;
+				hmrClient.logger.debug("program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.evaluatedModules.clear();
+				for (let url of clearEntrypointUrls) {
+					if (runner.isClosed()) break;
+					try {
+						await runner.import(url);
+					} catch (err) {
+						if (runner.isClosed()) break;
+						err.code !== "ERR_OUTDATED_OPTIMIZED_DEP" && hmrClient.logger.error(`An error happened during full reload\n${err.message}\n${err.stack}`);
+					}
+				}
+				break;
+			}
+			case "prune":
+				await hmrClient.notifyListeners("vite:beforePrune", payload), await hmrClient.prunePaths(payload.paths);
+				break;
+			case "error": {
+				await hmrClient.notifyListeners("vite:error", payload);
+				let err = payload.err;
+				hmrClient.logger.error(`Internal Server Error\n${err.message}\n${err.stack}`);
+				break;
+			}
+			case "ping": break;
+			default: return payload;
+		}
+	});
+}
+function getModulesByFile(runner, file) {
+	let nodes = runner.evaluatedModules.getModulesByFile(file);
+	return nodes ? [...nodes].map((node) => node.id) : [];
+}
+function getModulesEntrypoints(runner, modules, visited = /* @__PURE__ */ new Set(), entrypoints = /* @__PURE__ */ new Set()) {
+	for (let moduleId of modules) {
+		if (visited.has(moduleId)) continue;
+		visited.add(moduleId);
+		let module = runner.evaluatedModules.getModuleById(moduleId);
+		if (module) {
+			if (!module.importers.size) {
+				entrypoints.add(module.url);
+				continue;
+			}
+			for (let importer of module.importers) getModulesEntrypoints(runner, [importer], visited, entrypoints);
+		}
+	}
+	return entrypoints;
+}
+function findAllEntrypoints(runner, entrypoints = /* @__PURE__ */ new Set()) {
+	for (let mod of runner.evaluatedModules.idToModuleMap.values()) mod.importers.size || entrypoints.add(mod.url);
+	return entrypoints;
+}
+//#endregion
+//#region src/module-runner/sourcemap/interceptor.ts
+const sourceMapCache = {}, fileContentsCache = {}, evaluatedModulesCache = /* @__PURE__ */ new Set(), retrieveFileHandlers = /* @__PURE__ */ new Set(), retrieveSourceMapHandlers = /* @__PURE__ */ new Set(), createExecHandlers = (handlers) => ((...args) => {
+	for (let handler of handlers) {
+		let result = handler(...args);
+		if (result) return result;
+	}
+	return null;
+}), retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers), retrieveSourceMapFromHandlers = createExecHandlers(retrieveSourceMapHandlers);
+let overridden = !1;
+const originalPrepare = Error.prepareStackTrace;
+function resetInterceptor(runner, options) {
+	evaluatedModulesCache.delete(runner.evaluatedModules), options.retrieveFile && retrieveFileHandlers.delete(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.delete(options.retrieveSourceMap), evaluatedModulesCache.size === 0 && (Error.prepareStackTrace = originalPrepare, overridden = !1);
+}
+function interceptStackTrace(runner, options = {}) {
+	return overridden ||= (Error.prepareStackTrace = prepareStackTrace, !0), evaluatedModulesCache.add(runner.evaluatedModules), options.retrieveFile && retrieveFileHandlers.add(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.add(options.retrieveSourceMap), () => resetInterceptor(runner, options);
+}
+function supportRelativeURL(file, url) {
+	if (!file) return url;
+	let dir = posixDirname(slash(file)), match = /^\w+:\/\/[^/]*/.exec(dir), protocol = match ? match[0] : "", startPath = dir.slice(protocol.length);
+	return protocol && /^\/\w:/.test(startPath) ? (protocol += "/", protocol + slash(posixResolve(startPath, url))) : protocol + posixResolve(startPath, url);
+}
+function getRunnerSourceMap(position) {
+	for (let moduleGraph of evaluatedModulesCache) {
+		let sourceMap = moduleGraph.getModuleSourceMapById(position.source);
+		if (sourceMap) return {
+			url: position.source,
+			map: sourceMap,
+			vite: !0
+		};
+	}
+	return null;
+}
+function retrieveFile(path) {
+	if (path in fileContentsCache) return fileContentsCache[path];
+	let content = retrieveFileFromHandlers(path);
+	return typeof content == "string" ? (fileContentsCache[path] = content, content) : null;
+}
+function retrieveSourceMapURL(source) {
+	let fileData = retrieveFile(source);
+	if (!fileData) return null;
+	let re = /\/\/[@#]\s*sourceMappingURL=([^\s'"]+)\s*$|\/\*[@#]\s*sourceMappingURL=[^\s*'"]+\s*\*\/\s*$/gm, lastMatch, match;
+	for (; match = re.exec(fileData);) lastMatch = match;
+	return lastMatch ? lastMatch[1] : null;
+}
+const reSourceMap = /^data:application\/json[^,]+base64,/;
+function retrieveSourceMap(source) {
+	let urlAndMap = retrieveSourceMapFromHandlers(source);
+	if (urlAndMap) return urlAndMap;
+	let sourceMappingURL = retrieveSourceMapURL(source);
+	if (!sourceMappingURL) return null;
+	let sourceMapData;
+	if (reSourceMap.test(sourceMappingURL)) {
+		let rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1);
+		sourceMapData = Buffer.from(rawData, "base64").toString(), sourceMappingURL = source;
+	} else sourceMappingURL = supportRelativeURL(source, sourceMappingURL), sourceMapData = retrieveFile(sourceMappingURL);
+	return sourceMapData ? {
+		url: sourceMappingURL,
+		map: sourceMapData
+	} : null;
+}
+function mapSourcePosition(position) {
+	if (!position.source) return position;
+	let sourceMap = getRunnerSourceMap(position);
+	if (sourceMap ||= sourceMapCache[position.source], !sourceMap) {
+		let urlAndMap = retrieveSourceMap(position.source);
+		if (urlAndMap && urlAndMap.map) {
+			let url = urlAndMap.url;
+			sourceMap = sourceMapCache[position.source] = {
+				url,
+				map: new DecodedMap(typeof urlAndMap.map == "string" ? JSON.parse(urlAndMap.map) : urlAndMap.map, url)
+			};
+			let contents = sourceMap.map?.map.sourcesContent;
+			sourceMap.map && contents && sourceMap.map.resolvedSources.forEach((source, i) => {
+				let content = contents[i];
+				if (content && source && url) {
+					let contentUrl = supportRelativeURL(url, source);
+					fileContentsCache[contentUrl] = content;
+				}
+			});
+		} else sourceMap = sourceMapCache[position.source] = {
+			url: null,
+			map: null
+		};
+	}
+	if (sourceMap.map && sourceMap.url) {
+		let originalPosition = getOriginalPosition(sourceMap.map, position);
+		if (originalPosition && originalPosition.source != null) return originalPosition.source = supportRelativeURL(sourceMap.url, originalPosition.source), sourceMap.vite && (originalPosition._vite = !0), originalPosition;
+	}
+	return position;
+}
+function mapEvalOrigin(origin) {
+	let match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
+	if (match) {
+		let position = mapSourcePosition({
+			name: null,
+			source: match[2],
+			line: +match[3],
+			column: match[4] - 1
+		});
+		return `eval at ${match[1]} (${position.source}:${position.line}:${position.column + 1})`;
+	}
+	return match = /^eval at ([^(]+) \((.+)\)$/.exec(origin), match ? `eval at ${match[1]} (${mapEvalOrigin(match[2])})` : origin;
+}
+function CallSiteToString() {
+	let fileName, fileLocation = "";
+	if (this.isNative()) fileLocation = "native";
+	else {
+		fileName = this.getScriptNameOrSourceURL(), !fileName && this.isEval() && (fileLocation = this.getEvalOrigin(), fileLocation += ", "), fileName ? fileLocation += fileName : fileLocation += "<anonymous>";
+		let lineNumber = this.getLineNumber();
+		if (lineNumber != null) {
+			fileLocation += `:${lineNumber}`;
+			let columnNumber = this.getColumnNumber();
+			columnNumber && (fileLocation += `:${columnNumber}`);
+		}
+	}
+	let line = "", functionName = this.getFunctionName(), addSuffix = !0, isConstructor = this.isConstructor();
+	if (this.isToplevel() || isConstructor) isConstructor ? line += `new ${functionName || "<anonymous>"}` : functionName ? line += functionName : (line += fileLocation, addSuffix = !1);
+	else {
+		let typeName = this.getTypeName();
+		typeName === "[object Object]" && (typeName = "null");
+		let methodName = this.getMethodName();
+		functionName ? (typeName && functionName.indexOf(typeName) !== 0 && (line += `${typeName}.`), line += functionName, methodName && functionName.indexOf(`.${methodName}`) !== functionName.length - methodName.length - 1 && (line += ` [as ${methodName}]`)) : line += `${typeName}.${methodName || "<anonymous>"}`;
+	}
+	return addSuffix && (line += ` (${fileLocation})`), line;
+}
+function cloneCallSite(frame) {
+	let object = {};
+	return Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach((name) => {
+		let key = name;
+		object[key] = /^(?:is|get)/.test(name) ? function() {
+			return frame[key].call(frame);
+		} : frame[key];
+	}), object.toString = CallSiteToString, object;
+}
+function wrapCallSite(frame, state) {
+	if (state === void 0 && (state = {
+		nextPosition: null,
+		curPosition: null
+	}), frame.isNative()) return state.curPosition = null, frame;
+	let source = frame.getFileName() || frame.getScriptNameOrSourceURL();
+	if (source) {
+		let position = mapSourcePosition({
+			name: null,
+			source,
+			line: frame.getLineNumber() ?? 0,
+			column: (frame.getColumnNumber() ?? 1) - 1
+		});
+		state.curPosition = position, frame = cloneCallSite(frame);
+		let originalFunctionName = frame.getFunctionName;
+		return frame.getFunctionName = function() {
+			let name = state.nextPosition == null ? originalFunctionName() : state.nextPosition.name || originalFunctionName();
+			return name === "eval" && "_vite" in position ? null : name;
+		}, frame.getFileName = function() {
+			return position.source ?? null;
+		}, frame.getLineNumber = function() {
+			return position.line;
+		}, frame.getColumnNumber = function() {
+			return position.column + 1;
+		}, frame.getScriptNameOrSourceURL = function() {
+			return position.source;
+		}, frame;
+	}
+	let origin = frame.isEval() && frame.getEvalOrigin();
+	return origin ? (origin = mapEvalOrigin(origin), frame = cloneCallSite(frame), frame.getEvalOrigin = function() {
+		return origin || void 0;
+	}, frame) : frame;
+}
+function prepareStackTrace(error, stack) {
+	let errorString = `${error.name || "Error"}: ${error.message || ""}`, state = {
+		nextPosition: null,
+		curPosition: null
+	}, processedStack = [];
+	for (let i = stack.length - 1; i >= 0; i--) processedStack.push(`\n    at ${wrapCallSite(stack[i], state)}`), state.nextPosition = state.curPosition;
+	return state.curPosition = state.nextPosition = null, errorString + processedStack.reverse().join("");
+}
+//#endregion
+//#region src/module-runner/sourcemap/index.ts
+function enableSourceMapSupport(runner) {
+	if (runner.options.sourcemapInterceptor === "node") {
+		if (typeof process > "u") throw TypeError("Cannot use \"sourcemapInterceptor: 'node'\" because global \"process\" variable is not available.");
+		if (typeof process.setSourceMapsEnabled != "function") throw TypeError("Cannot use \"sourcemapInterceptor: 'node'\" because \"process.setSourceMapsEnabled\" function is not available. Please use Node >= 16.6.0.");
+		let isEnabledAlready = process.sourceMapsEnabled ?? !1;
+		return process.setSourceMapsEnabled(!0), () => !isEnabledAlready && process.setSourceMapsEnabled(!1);
+	}
+	return interceptStackTrace(runner, typeof runner.options.sourcemapInterceptor == "object" ? runner.options.sourcemapInterceptor : void 0);
+}
+//#endregion
+//#region src/module-runner/esmEvaluator.ts
+var ESModulesEvaluator = class {
+	startOffset = getAsyncFunctionDeclarationPaddingLineCount();
+	async runInlinedModule(context, code) {
+		await new AsyncFunction(ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey, ssrExportNameKey, "\"use strict\";" + code)(context[ssrModuleExportsKey], context[ssrImportMetaKey], context[ssrImportKey], context[ssrDynamicImportKey], context[ssrExportAllKey], context[ssrExportNameKey]), Object.seal(context[ssrModuleExportsKey]);
+	}
+	runExternalModule(filepath) {
+		return import(filepath);
+	}
+};
+//#endregion
+//#region src/module-runner/importMetaResolver.ts
+const customizationHookNamespace = "vite-module-runner:import-meta-resolve/v1/", customizationHooksModule = `
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier.startsWith(${JSON.stringify(customizationHookNamespace)})) {
+    const data = specifier.slice(${JSON.stringify(customizationHookNamespace)}.length)
+    const [parsedSpecifier, parsedImporter] = JSON.parse(data)
+    specifier = parsedSpecifier
+    context.parentURL = parsedImporter
+  }
+  return nextResolve(specifier, context)
+}
+
+`;
+function customizationHookResolve(specifier, context, nextResolve) {
+	if (specifier.startsWith(customizationHookNamespace)) {
+		let data = specifier.slice(42), [parsedSpecifier, parsedImporter] = JSON.parse(data);
+		specifier = parsedSpecifier, context.parentURL = parsedImporter;
+	}
+	return nextResolve(specifier, context);
+}
+let isHookRegistered = !1;
+function createImportMetaResolver() {
+	if (isHookRegistered) return importMetaResolveWithCustomHook;
+	let module;
+	try {
+		module = typeof process < "u" ? process.getBuiltinModule("node:module").Module : void 0;
+	} catch {
+		return;
+	}
+	if (module) {
+		if (module.registerHooks) return module.registerHooks({ resolve: customizationHookResolve }), isHookRegistered = !0, importMetaResolveWithCustomHook;
+		if (module.register) {
+			try {
+				let hookModuleContent = `data:text/javascript,${encodeURI(customizationHooksModule)}`;
+				module.register(hookModuleContent);
+			} catch (e) {
+				if ("code" in e && e.code === "ERR_NETWORK_IMPORT_DISALLOWED") return;
+				throw e;
+			}
+			return isHookRegistered = !0, importMetaResolveWithCustomHook;
+		}
+	}
+}
+function importMetaResolveWithCustomHook(specifier, importer) {
+	return import.meta.resolve(`${customizationHookNamespace}${JSON.stringify([specifier, importer])}`);
+}
+`${customizationHookNamespace}`;
+//#endregion
+//#region src/module-runner/createImportMeta.ts
+const envProxy = new Proxy({}, { get(_, p) {
+	throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
+} });
+function createDefaultImportMeta(modulePath) {
+	let href = posixPathToFileHref(modulePath), filename = modulePath, dirname = posixDirname(modulePath);
+	return {
+		filename: isWindows ? toWindowsPath(filename) : filename,
+		dirname: isWindows ? toWindowsPath(dirname) : dirname,
+		url: href,
+		env: envProxy,
+		resolve(_id, _parent) {
+			throw Error("[module runner] \"import.meta.resolve\" is not supported.");
+		},
+		glob() {
+			throw Error("[module runner] \"import.meta.glob\" is statically replaced during file transformation. Make sure to reference it by the full name.");
+		}
+	};
+}
+/**
+* Create import.meta object for Node.js.
+*/
+function createNodeImportMeta(modulePath) {
+	let defaultMeta = createDefaultImportMeta(modulePath), href = defaultMeta.url, importMetaResolver = createImportMetaResolver();
+	return {
+		...defaultMeta,
+		main: !1,
+		resolve(id, parent) {
+			return (importMetaResolver ?? defaultMeta.resolve)(id, parent ?? href);
+		}
+	};
+}
+//#endregion
+//#region src/module-runner/runner.ts
+var ModuleRunner = class {
+	options;
+	evaluator;
+	debug;
+	evaluatedModules;
+	hmrClient;
+	transport;
+	resetSourceMapSupport;
+	concurrentModuleNodePromises = /* @__PURE__ */ new Map();
+	isBuiltin;
+	builtinsPromise;
+	closed = !1;
+	constructor(options, evaluator = new ESModulesEvaluator(), debug) {
+		if (this.options = options, this.evaluator = evaluator, this.debug = debug, this.evaluatedModules = options.evaluatedModules ?? new EvaluatedModules(), this.transport = normalizeModuleRunnerTransport(options.transport), options.hmr !== !1) {
+			let optionsHmr = options.hmr ?? !0, resolvedHmrLogger = optionsHmr === !0 || optionsHmr.logger === void 0 ? hmrLogger : optionsHmr.logger === !1 ? silentConsole : optionsHmr.logger;
+			if (this.hmrClient = new HMRClient(resolvedHmrLogger, this.transport, ({ acceptedPath }) => this.import(acceptedPath)), !this.transport.connect) throw Error("HMR is not supported by this runner transport, but `hmr` option was set to true");
+			this.transport.connect(createHMRHandlerForRunner(this));
+		} else this.transport.connect?.();
+		options.sourcemapInterceptor !== !1 && (this.resetSourceMapSupport = enableSourceMapSupport(this));
+	}
+	/**
+	* URL to execute. Accepts file path, server path or id relative to the root.
+	*/
+	async import(url) {
+		let fetchedModule = await this.cachedModule(url);
+		return await this.cachedRequest(url, fetchedModule);
+	}
+	/**
+	* Clear all caches including HMR listeners.
+	*/
+	clearCache() {
+		this.evaluatedModules.clear(), this.hmrClient?.clear();
+	}
+	/**
+	* Clears all caches, removes all HMR listeners, and resets source map support.
+	* This method doesn't stop the HMR connection.
+	*/
+	async close() {
+		this.resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this.closed = !0, await this.transport.disconnect?.();
+	}
+	/**
+	* Returns `true` if the runtime has been closed by calling `close()` method.
+	*/
+	isClosed() {
+		return this.closed;
+	}
+	processImport(exports, fetchResult, metadata) {
+		if (!("externalize" in fetchResult)) return exports;
+		let { url, type } = fetchResult;
+		return type !== "module" && type !== "commonjs" || analyzeImportedModDifference(exports, url, type, metadata), exports;
+	}
+	isCircularRequest(mod, callstack, visited = /* @__PURE__ */ new Set()) {
+		if (visited.has(mod.id)) return !1;
+		visited.add(mod.id);
+		for (let importedModuleId of mod.imports) {
+			if (callstack.includes(importedModuleId)) return !0;
+			let importedModule = this.evaluatedModules.getModuleById(importedModuleId);
+			if (importedModule?.promise && !importedModule.evaluated && this.isCircularRequest(importedModule, callstack, visited)) return !0;
+		}
+		return !1;
+	}
+	async cachedRequest(url, mod, callstack = [], metadata) {
+		let meta = mod.meta, moduleId = meta.id, importee = callstack[callstack.length - 1];
+		if (importee && mod.importers.add(importee), mod.evaluated && mod.promise) return this.processImport(await mod.promise, meta, metadata);
+		if (mod.promise) return mod.exports && (callstack.includes(moduleId) || this.isCircularRequest(mod, callstack)) ? this.processImport(mod.exports, meta, metadata) : this.processImport(await mod.promise, meta, metadata);
+		let debugTimer;
+		this.debug && (debugTimer = setTimeout(() => {
+			this.debug(`[module runner] module ${moduleId} takes over 2s to load.\n${`stack:\n${[...callstack, moduleId].reverse().map((p) => `  - ${p}`).join("\n")}`}`);
+		}, 2e3));
+		try {
+			let promise = this.directRequest(url, mod, callstack);
+			return mod.promise = promise, mod.evaluated = !1, this.processImport(await promise, meta, metadata);
+		} finally {
+			mod.evaluated = !0, debugTimer && clearTimeout(debugTimer);
+		}
+	}
+	async cachedModule(url, importer) {
+		let cached = this.concurrentModuleNodePromises.get(url);
+		if (cached) this.debug?.("[module runner] using cached module info for", url);
+		else {
+			let cachedModule = this.evaluatedModules.getModuleByUrl(url);
+			cached = this.getModuleInformation(url, importer, cachedModule).finally(() => {
+				this.concurrentModuleNodePromises.delete(url);
+			}), this.concurrentModuleNodePromises.set(url, cached);
+		}
+		return cached;
+	}
+	ensureBuiltins() {
+		if (!this.isBuiltin) return this.builtinsPromise ??= (async () => {
+			try {
+				this.debug?.("[module runner] fetching builtins from server");
+				let builtins = (await this.transport.invoke("getBuiltins", [])).map((builtin) => typeof builtin == "object" && builtin && "type" in builtin ? builtin.type === "string" ? builtin.value : new RegExp(builtin.source, builtin.flags) : builtin);
+				this.isBuiltin = createIsBuiltin(builtins), this.debug?.("[module runner] builtins loaded:", builtins);
+			} finally {
+				this.builtinsPromise = void 0;
+			}
+		})(), this.builtinsPromise;
+	}
+	async getModuleInformation(url, importer, cachedModule) {
+		if (this.closed) throw Error("Vite module runner has been closed.");
+		await this.ensureBuiltins(), this.debug?.("[module runner] fetching", url);
+		let isCached = !!(typeof cachedModule == "object" && cachedModule.meta), fetchedModule = url.startsWith("data:") || this.isBuiltin?.(url) ? {
+			externalize: url,
+			type: "builtin"
+		} : await this.transport.invoke("fetchModule", [
+			url,
+			importer,
+			{
+				cached: isCached,
+				startOffset: this.evaluator.startOffset
+			}
+		]);
+		if ("cache" in fetchedModule) {
+			if (!cachedModule || !cachedModule.meta) throw Error(`Module "${url}" was mistakenly invalidated during fetch phase.`);
+			return cachedModule;
+		}
+		let moduleId = "externalize" in fetchedModule ? fetchedModule.externalize : fetchedModule.id, moduleUrl = "url" in fetchedModule ? fetchedModule.url : url, module = this.evaluatedModules.ensureModule(moduleId, moduleUrl);
+		return "invalidate" in fetchedModule && fetchedModule.invalidate && this.evaluatedModules.invalidateModule(module), fetchedModule.url = moduleUrl, fetchedModule.id = moduleId, module.meta = fetchedModule, module;
+	}
+	async directRequest(url, mod, _callstack) {
+		let fetchResult = mod.meta, moduleId = fetchResult.id, callstack = [..._callstack, moduleId], request = async (dep, metadata) => {
+			let importer = "file" in fetchResult && fetchResult.file || moduleId, depMod = await this.cachedModule(dep, importer);
+			return depMod.importers.add(moduleId), mod.imports.add(depMod.id), this.cachedRequest(dep, depMod, callstack, metadata);
+		}, dynamicRequest = async (dep) => (dep = String(dep), dep[0] === "." && (dep = posixResolve(posixDirname(url), dep)), request(dep, { isDynamicImport: !0 }));
+		if ("externalize" in fetchResult) {
+			let { externalize } = fetchResult;
+			this.debug?.("[module runner] externalizing", externalize);
+			let exports = await this.evaluator.runExternalModule(externalize);
+			return mod.exports = exports, exports;
+		}
+		let { code, file } = fetchResult;
+		if (code == null) {
+			let importer = callstack[callstack.length - 2];
+			throw Error(`[module runner] Failed to load "${url}"${importer ? ` imported from ${importer}` : ""}`);
+		}
+		let createImportMeta = this.options.createImportMeta ?? createDefaultImportMeta, modulePath = cleanUrl(file || moduleId), href = posixPathToFileHref(modulePath), meta = await createImportMeta(modulePath), exports = Object.create(null);
+		Object.defineProperty(exports, Symbol.toStringTag, {
+			value: "Module",
+			enumerable: !1,
+			configurable: !1
+		}), mod.exports = exports;
+		let hotContext;
+		this.hmrClient && Object.defineProperty(meta, "hot", {
+			enumerable: !0,
+			get: () => {
+				if (!this.hmrClient) throw Error("[module runner] HMR client was closed.");
+				return this.debug?.("[module runner] creating hmr context for", mod.url), hotContext ||= new HMRContext(this.hmrClient, mod.url), hotContext;
+			},
+			set: (value) => {
+				hotContext = value;
+			}
+		});
+		let context = {
+			[ssrImportKey]: request,
+			[ssrDynamicImportKey]: dynamicRequest,
+			[ssrModuleExportsKey]: exports,
+			[ssrExportAllKey]: (obj) => exportAll(exports, obj),
+			[ssrExportNameKey]: (name, getter) => Object.defineProperty(exports, name, {
+				enumerable: !0,
+				configurable: !0,
+				get: getter
+			}),
+			[ssrImportMetaKey]: meta
+		};
+		return this.debug?.("[module runner] executing", href), await this.evaluator.runInlinedModule(context, code, mod), exports;
+	}
+};
+function exportAll(exports, sourceModule) {
+	if (exports !== sourceModule && !(isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise)) {
+		for (let key in sourceModule) if (key !== "default" && key !== "__esModule" && !(key in exports)) try {
+			Object.defineProperty(exports, key, {
+				enumerable: !0,
+				configurable: !0,
+				get: () => sourceModule[key]
+			});
+		} catch {}
+	}
+}
+//#endregion
+export { ESModulesEvaluator, EvaluatedModules, ModuleRunner, createDefaultImportMeta, createNodeImportMeta, createWebSocketModuleRunnerTransport, normalizeModuleId, ssrDynamicImportKey, ssrExportAllKey, ssrExportNameKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/misc/false.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/misc/false.js
new file mode 100644
index 0000000..2693369
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/misc/false.js
@@ -0,0 +1 @@
+export default false
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/misc/true.js b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/misc/true.js
new file mode 100644
index 0000000..186b120
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/misc/true.js
@@ -0,0 +1 @@
+export default true
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/package.json b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/package.json
new file mode 100644
index 0000000..2fbb695
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/package.json
@@ -0,0 +1,192 @@
+{
+  "name": "vite",
+  "version": "8.0.13",
+  "type": "module",
+  "license": "MIT",
+  "author": "Evan You",
+  "description": "Native-ESM powered web dev build tool",
+  "bin": {
+    "vite": "bin/vite.js"
+  },
+  "keywords": [
+    "frontend",
+    "framework",
+    "hmr",
+    "dev-server",
+    "build-tool",
+    "vite"
+  ],
+  "exports": {
+    ".": "./dist/node/index.js",
+    "./client": {
+      "types": "./client.d.ts"
+    },
+    "./module-runner": "./dist/node/module-runner.js",
+    "./internal": "./dist/node/internal.js",
+    "./dist/client/*": "./dist/client/*",
+    "./types/*": {
+      "types": "./types/*"
+    },
+    "./types/internal/*": null,
+    "./package.json": "./package.json"
+  },
+  "imports": {
+    "#module-sync-enabled": {
+      "module-sync": "./misc/true.js",
+      "default": "./misc/false.js"
+    },
+    "#types/*": "./types/*.d.ts",
+    "#dep-types/*": "./src/types/*.d.ts"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "misc/**/*.js",
+    "client.d.ts",
+    "types"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitejs/vite.git",
+    "directory": "packages/vite"
+  },
+  "bugs": {
+    "url": "https://github.com/vitejs/vite/issues"
+  },
+  "homepage": "https://vite.dev",
+  "funding": "https://github.com/vitejs/vite?sponsor=1",
+  "//": "READ CONTRIBUTING.md to understand what to put under deps vs. devDeps!",
+  "dependencies": {
+    "lightningcss": "^1.32.0",
+    "picomatch": "^4.0.4",
+    "postcss": "^8.5.14",
+    "rolldown": "1.0.1",
+    "tinyglobby": "^0.2.16"
+  },
+  "optionalDependencies": {
+    "fsevents": "~2.3.3"
+  },
+  "devDependencies": {
+    "@babel/parser": "^7.29.3",
+    "@jridgewell/remapping": "^2.3.5",
+    "@jridgewell/trace-mapping": "^0.3.31",
+    "@polka/compression": "^1.0.0-next.25",
+    "@rollup/plugin-alias": "^6.0.0",
+    "@rollup/plugin-dynamic-import-vars": "2.1.4",
+    "@rollup/pluginutils": "^5.3.0",
+    "@vercel/detect-agent": "^1.2.3",
+    "@types/escape-html": "^1.0.4",
+    "@types/pnpapi": "^0.0.5",
+    "@vitest/utils": "4.1.5",
+    "@vitejs/devtools": "^0.1.21",
+    "artichokie": "^0.4.3",
+    "baseline-browser-mapping": "^2.10.29",
+    "cac": "^7.0.0",
+    "chokidar": "^3.6.0",
+    "connect": "^3.7.0",
+    "convert-source-map": "^2.0.0",
+    "cors": "^2.8.6",
+    "cross-spawn": "^7.0.6",
+    "dotenv-expand": "^13.0.0",
+    "es-module-lexer": "^1.7.0",
+    "esbuild": "^0.28.0",
+    "escape-html": "^1.0.3",
+    "estree-walker": "^3.0.3",
+    "etag": "^1.8.1",
+    "host-validation-middleware": "^0.1.4",
+    "http-proxy-3": "^1.23.2",
+    "launch-editor-middleware": "^2.13.2",
+    "magic-string": "^0.30.21",
+    "mlly": "^1.8.2",
+    "mrmime": "^2.0.1",
+    "nanoid": "^5.1.11",
+    "obug": "^1.0.2",
+    "open": "^10.2.0",
+    "parse5": "^8.0.1",
+    "pathe": "^2.0.3",
+    "periscopic": "^4.0.3",
+    "picocolors": "^1.1.1",
+    "postcss-import": "^16.1.1",
+    "postcss-load-config": "^6.0.1",
+    "postcss-modules": "^6.0.1",
+    "premove": "^4.0.0",
+    "resolve.exports": "^2.0.3",
+    "rolldown-plugin-dts": "^0.25.0",
+    "rollup": "^4.59.0",
+    "rollup-plugin-license": "^3.7.1",
+    "sass": "^1.99.0",
+    "sass-embedded": "^1.99.0",
+    "sirv": "^3.0.2",
+    "strip-literal": "^3.1.0",
+    "terser": "^5.47.1",
+    "ufo": "^1.6.4",
+    "ws": "^8.20.0"
+  },
+  "peerDependencies": {
+    "@types/node": "^20.19.0 || >=22.12.0",
+    "@vitejs/devtools": "^0.1.18",
+    "esbuild": "^0.27.0 || ^0.28.0",
+    "jiti": ">=1.21.0",
+    "less": "^4.0.0",
+    "sass": "^1.70.0",
+    "sass-embedded": "^1.70.0",
+    "stylus": ">=0.54.8",
+    "sugarss": "^5.0.0",
+    "terser": "^5.16.0",
+    "tsx": "^4.8.1",
+    "yaml": "^2.4.2"
+  },
+  "peerDependenciesMeta": {
+    "@types/node": {
+      "optional": true
+    },
+    "@vitejs/devtools": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    },
+    "jiti": {
+      "optional": true
+    },
+    "sass": {
+      "optional": true
+    },
+    "sass-embedded": {
+      "optional": true
+    },
+    "stylus": {
+      "optional": true
+    },
+    "less": {
+      "optional": true
+    },
+    "sugarss": {
+      "optional": true
+    },
+    "terser": {
+      "optional": true
+    },
+    "tsx": {
+      "optional": true
+    },
+    "yaml": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "dev": "premove dist && pnpm build-bundle -w",
+    "build": "premove dist && pnpm build-bundle && pnpm build-types",
+    "build-bundle": "rolldown --config rolldown.config.ts",
+    "build-types": "pnpm build-types-roll && pnpm build-types-check",
+    "build-types-roll": "rolldown --config rolldown.dts.config.ts",
+    "build-types-check": "tsc --project tsconfig.check.json",
+    "typecheck": "tsc && tsc -p src/node && tsc -p src/client && tsc -p src/module-runner && tsc -p src/shared && tsc -p src/node/__tests_dts__ && tsc -p src/module-runner/__tests_dts__",
+    "lint": "eslint --cache --ext .ts src/**",
+    "format": "oxfmt",
+    "generate-target": "tsx scripts/generateTarget.ts"
+  }
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/customEvent.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/customEvent.d.ts
new file mode 100644
index 0000000..7ca8388
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/customEvent.d.ts
@@ -0,0 +1,79 @@
+import type {
+  ErrorPayload,
+  FullReloadPayload,
+  PrunePayload,
+  UpdatePayload,
+} from './hmrPayload.js'
+
+export interface CustomEventMap {
+  // client events
+  'vite:beforeUpdate': UpdatePayload
+  'vite:afterUpdate': UpdatePayload
+  'vite:beforePrune': PrunePayload
+  'vite:beforeFullReload': FullReloadPayload
+  'vite:error': ErrorPayload
+  'vite:invalidate': InvalidatePayload
+  'vite:ws:connect': WebSocketConnectionPayload
+  'vite:ws:disconnect': WebSocketConnectionPayload
+  /** @internal */
+  'vite:forward-console': ForwardConsolePayload
+  /** @internal */
+  'vite:module-loaded': { modules: string[]; clientId: string }
+
+  // server events
+  'vite:client:connect': undefined
+  'vite:client:disconnect': undefined
+}
+
+export interface WebSocketConnectionPayload {
+  /**
+   * @experimental
+   * We expose this instance experimentally to see potential usage.
+   * This might be removed in the future if we didn't find reasonable use cases.
+   * If you find this useful, please open an issue with details so we can discuss and make it stable API.
+   */
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+  webSocket: WebSocket
+}
+
+export interface InvalidatePayload {
+  path: string
+  message: string | undefined
+  firstInvalidatedBy: string
+}
+
+export type ForwardConsolePayload =
+  | {
+      type: 'error'
+      data: {
+        name: string
+        message: string
+        stack?: string
+      }
+    }
+  | {
+      type: 'unhandled-rejection'
+      data: {
+        name: string
+        message: string
+        stack?: string
+      }
+    }
+  | {
+      type: 'log'
+      data: {
+        level: string
+        message: string
+      }
+    }
+
+/**
+ * provides types for payloads of built-in Vite events
+ */
+export type InferCustomEventPayload<T extends string> =
+  T extends keyof CustomEventMap ? CustomEventMap[T] : any
+
+/**
+ * provides types for names of built-in Vite events
+ */
+export type CustomEventName = keyof CustomEventMap | (string & {})
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/hmrPayload.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/hmrPayload.d.ts
new file mode 100644
index 0000000..8796a6b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/hmrPayload.d.ts
@@ -0,0 +1,80 @@
+/** @deprecated use HotPayload */
+export type HMRPayload = HotPayload
+export type HotPayload =
+  | ConnectedPayload
+  | PingPayload
+  | UpdatePayload
+  | FullReloadPayload
+  | CustomPayload
+  | ErrorPayload
+  | PrunePayload
+
+export interface ConnectedPayload {
+  type: 'connected'
+}
+
+export interface PingPayload {
+  type: 'ping'
+}
+
+export interface UpdatePayload {
+  type: 'update'
+  updates: Update[]
+}
+
+export interface Update {
+  type: 'js-update' | 'css-update'
+  /**
+   * URL of HMR patch chunk
+   *
+   * This only exists when full-bundle mode is enabled.
+   */
+  url?: string
+  path: string
+  acceptedPath: string
+  timestamp: number
+  /** @internal */
+  explicitImportRequired?: boolean
+  /** @internal */
+  isWithinCircularImport?: boolean
+  /** @internal */
+  firstInvalidatedBy?: string
+  /** @internal */
+  invalidates?: string[]
+}
+
+export interface PrunePayload {
+  type: 'prune'
+  paths: string[]
+}
+
+export interface FullReloadPayload {
+  type: 'full-reload'
+  path?: string
+  /** @internal */
+  triggeredBy?: string
+}
+
+export interface CustomPayload {
+  type: 'custom'
+  event: string
+  data?: any
+}
+
+export interface ErrorPayload {
+  type: 'error'
+  err: {
+    [name: string]: any
+    message: string
+    stack: string
+    id?: string
+    frame?: string
+    plugin?: string
+    pluginCode?: string
+    loc?: {
+      file?: string
+      line: number
+      column: number
+    }
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/hot.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/hot.d.ts
new file mode 100644
index 0000000..7d9a5b0
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/hot.d.ts
@@ -0,0 +1,39 @@
+import type { CustomEventName, InferCustomEventPayload } from './customEvent.js'
+
+export type ModuleNamespace = Record<string, any> & {
+  [Symbol.toStringTag]: 'Module'
+}
+
+export interface ViteHotContext {
+  readonly data: any
+
+  accept(): void
+  accept(cb: (mod: ModuleNamespace | undefined) => void): void
+  accept(dep: string, cb: (mod: ModuleNamespace | undefined) => void): void
+  accept(
+    deps: readonly string[],
+    cb: (mods: Array<ModuleNamespace | undefined>) => void,
+  ): void
+
+  acceptExports(
+    exportNames: string | readonly string[],
+    cb?: (mod: ModuleNamespace | undefined) => void,
+  ): void
+
+  dispose(cb: (data: any) => void): void
+  prune(cb: (data: any) => void): void
+  invalidate(message?: string): void
+
+  on<T extends CustomEventName>(
+    event: T,
+    cb: (payload: InferCustomEventPayload<T>) => void,
+  ): void
+  off<T extends CustomEventName>(
+    event: T,
+    cb: (payload: InferCustomEventPayload<T>) => void,
+  ): void
+  send<T extends CustomEventName>(
+    event: T,
+    data?: InferCustomEventPayload<T>,
+  ): void
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/import-meta.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/import-meta.d.ts
new file mode 100644
index 0000000..ee00ff5
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/import-meta.d.ts
@@ -0,0 +1,5 @@
+/// <reference path="./importMeta.d.ts" />
+
+// https://github.com/microsoft/TypeScript/issues/45096
+// TypeScript has a bug that makes <reference types="vite/types/importMeta" />
+// not possible in userland. This file provides a workaround for now.
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/importGlob.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/importGlob.d.ts
new file mode 100644
index 0000000..dfd6f6f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/importGlob.d.ts
@@ -0,0 +1,89 @@
+export interface ImportGlobOptions<
+  Eager extends boolean,
+  AsType extends string,
+> {
+  /**
+   * Import type for the import url.
+   *
+   * @deprecated Use `query` instead, e.g. `as: 'url'` -> `query: '?url', import: 'default'`
+   */
+  as?: AsType
+  /**
+   * Import as static or dynamic
+   *
+   * @default false
+   */
+  eager?: Eager
+  /**
+   * Import only the specific named export. Set to `default` to import the default export.
+   */
+  import?: string
+  /**
+   * Custom queries
+   */
+  query?: string | Record<string, string | number | boolean>
+  /**
+   * Search files also inside `node_modules/` and hidden directories (e.g. `.git/`). This might have impact on performance.
+   *
+   * @default false
+   */
+  exhaustive?: boolean
+  /**
+   * Base path to resolve relative paths.
+   */
+  base?: string
+}
+
+export type GeneralImportGlobOptions = ImportGlobOptions<boolean, string>
+
+/**
+ * Declare Worker in case DOM is not added to the tsconfig lib causing
+ * Worker interface is not defined. For developers with DOM lib added,
+ * the Worker interface will be merged correctly.
+ */
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface Worker {}
+}
+
+export interface KnownAsTypeMap {
+  raw: string
+  url: string
+  worker: Worker
+}
+
+export interface ImportGlobFunction {
+  /**
+   * Import a list of files with a glob pattern.
+   *
+   * Overload 1: No generic provided, infer the type from `eager` and `as`
+   */
+  <
+    Eager extends boolean,
+    As extends string,
+    T = As extends keyof KnownAsTypeMap ? KnownAsTypeMap[As] : unknown,
+  >(
+    glob: string | string[],
+    options?: ImportGlobOptions<Eager, As>,
+  ): (Eager extends true ? true : false) extends true
+    ? Record<string, T>
+    : Record<string, () => Promise<T>>
+  /**
+   * Import a list of files with a glob pattern.
+   *
+   * Overload 2: Module generic provided, infer the type from `eager: false`
+   */
+  <M>(
+    glob: string | string[],
+    options?: ImportGlobOptions<false, string>,
+  ): Record<string, () => Promise<M>>
+  /**
+   * Import a list of files with a glob pattern.
+   *
+   * Overload 3: Module generic provided, infer the type from `eager: true`
+   */
+  <M>(
+    glob: string | string[],
+    options: ImportGlobOptions<true, string>,
+  ): Record<string, M>
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/importMeta.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/importMeta.d.ts
new file mode 100644
index 0000000..f859a2b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/importMeta.d.ts
@@ -0,0 +1,30 @@
+// This file is an augmentation to the built-in ImportMeta interface
+// Thus cannot contain any top-level imports
+// <https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation>
+
+// This is tested in `packages/vite/src/node/__tests_dts__/typeOptions.ts`
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- to allow extending by users
+interface ViteTypeOptions {
+  // strictImportMetaEnv: unknown
+}
+
+type ImportMetaEnvFallbackKey =
+  'strictImportMetaEnv' extends keyof ViteTypeOptions ? never : string
+
+interface ImportMetaEnv extends Record<ImportMetaEnvFallbackKey, any> {
+  BASE_URL: string
+  MODE: string
+  DEV: boolean
+  PROD: boolean
+  SSR: boolean
+}
+
+interface ImportMeta {
+  url: string
+
+  readonly hot?: import('./hot.js').ViteHotContext
+
+  readonly env: ImportMetaEnv
+
+  glob: import('./importGlob.js').ImportGlobFunction
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/cssPreprocessorOptions.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/cssPreprocessorOptions.d.ts
new file mode 100644
index 0000000..ca87ba8
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/cssPreprocessorOptions.d.ts
@@ -0,0 +1,44 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+
+// @ts-ignore `sass` may not be installed
+import type DartSass from 'sass'
+// @ts-ignore `sass-embedded` may not be installed
+import type SassEmbedded from 'sass-embedded'
+// @ts-ignore `less` may not be installed
+import type Less from 'less'
+// @ts-ignore `stylus` may not be installed
+import type Stylus from 'stylus'
+
+/* eslint-enable @typescript-eslint/ban-ts-comment */
+
+// https://github.com/type-challenges/type-challenges/issues/29285
+type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false
+
+type DartSassStringOptionsAsync = DartSass.StringOptions<'async'>
+type SassEmbeddedStringOptionsAsync = SassEmbedded.StringOptions<'async'>
+type SassStringOptionsAsync =
+  IsAny<SassEmbeddedStringOptionsAsync> extends false
+    ? SassEmbeddedStringOptionsAsync
+    : DartSassStringOptionsAsync
+
+export type SassModernPreprocessBaseOptions = Omit<
+  SassStringOptionsAsync,
+  'url' | 'sourceMap'
+>
+
+export type LessPreprocessorBaseOptions = Omit<
+  Less.Options,
+  'sourceMap' | 'filename'
+>
+
+export type StylusPreprocessorBaseOptions = Omit<
+  Stylus.RenderOptions,
+  'filename'
+> & { define?: Record<string, any> }
+
+declare global {
+  // LESS' types somewhat references this which doesn't make sense in Node,
+  // so we have to shim it
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface HTMLLinkElement {}
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/esbuildOptions.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/esbuildOptions.d.ts
new file mode 100644
index 0000000..f1637a6
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/esbuildOptions.d.ts
@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+
+// @ts-ignore `esbuild` may not be installed
+import type esbuild from 'esbuild'
+
+/* eslint-enable @typescript-eslint/ban-ts-comment */
+
+export type EsbuildTarget = string | string[]
+
+export type EsbuildLoader = esbuild.Loader
+export type EsbuildTransformOptions = esbuild.TransformOptions
+export type EsbuildTransformResult = esbuild.TransformResult
+
+export type EsbuildMessage = esbuild.Message
+
+export type DepsOptimizerEsbuildOptions = Omit<
+  esbuild.BuildOptions,
+  | 'bundle'
+  | 'entryPoints'
+  | 'external'
+  | 'write'
+  | 'watch'
+  | 'outdir'
+  | 'outfile'
+  | 'outbase'
+  | 'outExtension'
+  | 'metafile'
+>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/lightningcssOptions.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/lightningcssOptions.d.ts
new file mode 100644
index 0000000..48d7114
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/lightningcssOptions.d.ts
@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+
+// @ts-ignore `lightningcss` may not be installed
+import type Lightningcss from 'lightningcss'
+
+/* eslint-enable @typescript-eslint/ban-ts-comment */
+
+export type LightningCSSOptions = Omit<
+  Lightningcss.BundleAsyncOptions<Lightningcss.CustomAtRules>,
+  | 'filename'
+  | 'resolver'
+  | 'minify'
+  | 'sourceMap'
+  | 'analyzeDependencies'
+  // properties not overridden by Vite, but does not make sense to set by end users
+  | 'inputSourceMap'
+  | 'projectRoot'
+>
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/rollupTypeCompat.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/rollupTypeCompat.d.ts
new file mode 100644
index 0000000..e7634c7
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/rollupTypeCompat.d.ts
@@ -0,0 +1,24 @@
+import type * as Rolldown from 'rolldown'
+
+export * from 'rolldown'
+
+/** @deprecated use RolldownBuild instead */
+export type RollupBuild = Rolldown.RolldownBuild
+
+/** @deprecated use RolldownOptions instead */
+export type RollupOptions = Rolldown.RolldownOptions
+
+/** @deprecated use RolldownOutput instead */
+export type RollupOutput = Rolldown.RolldownOutput
+
+/** @deprecated use RolldownPlugin instead */
+export type RollupPlugin = Rolldown.RolldownPlugin
+
+/** @deprecated use RolldownPluginOption instead */
+export type RollupPluginOption = Rolldown.RolldownPluginOption
+
+/** @deprecated use RolldownWatcher instead */
+export type RollupWatcher = Rolldown.RolldownWatcher
+
+/** @deprecated use RollupWatcherEvent instead */
+export type RollupWatcherEvent = Rolldown.RolldownWatcherEvent
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/terserOptions.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/terserOptions.d.ts
new file mode 100644
index 0000000..3d5e08f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/internal/terserOptions.d.ts
@@ -0,0 +1,11 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+
+// @ts-ignore `terser` may not be installed
+export type * as Terser from 'terser'
+// @ts-ignore `terser` may not be installed
+import type * as Terser from 'terser'
+
+/* eslint-enable @typescript-eslint/ban-ts-comment */
+
+export type TerserMinifyOptions = Terser.MinifyOptions
+export type TerserMinifyOutput = Terser.MinifyOutput
diff --git a/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/metadata.d.ts b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/metadata.d.ts
new file mode 100644
index 0000000..8e317f9
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/node_modules/vite/types/metadata.d.ts
@@ -0,0 +1,47 @@
+export interface AssetMetadata {
+  importedAssets: Set<string>
+  importedCss: Set<string>
+}
+
+export interface ChunkMetadata {
+  importedAssets: Set<string>
+  importedCss: Set<string>
+  /** @internal */
+  __modules: any
+}
+
+export interface CustomPluginOptionsVite {
+  /**
+   * If this is a CSS Rollup module, you can scope to its importer's exports
+   * so that if those exports are treeshaken away, the CSS module will also
+   * be treeshaken.
+   *
+   * The "importerId" must import the CSS Rollup module statically.
+   *
+   * Example config if the CSS id is `/src/App.vue?vue&type=style&lang.css`:
+   * ```js
+   * cssScopeTo: ['/src/App.vue', 'default']
+   * ```
+   */
+  cssScopeTo?: readonly [importerId: string, exportName: string | undefined]
+
+  /** @deprecated no-op since Vite 6.1 */
+  lang?: string
+}
+
+declare module 'rolldown' {
+  export interface OutputAsset {
+    viteMetadata?: AssetMetadata
+  }
+
+  export interface RenderedChunk {
+    viteMetadata?: ChunkMetadata
+  }
+  export interface OutputChunk {
+    viteMetadata?: ChunkMetadata
+  }
+
+  export interface CustomPluginOptions {
+    vite?: CustomPluginOptionsVite
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/package-lock.json b/TicTacToe-Compare/ministral-3-14b/package-lock.json
new file mode 100644
index 0000000..fb85c14
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/package-lock.json
@@ -0,0 +1,922 @@
+{
+  "name": "tictactoe",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "tictactoe",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "create-vite": "^9.0.7"
+      },
+      "devDependencies": {
+        "vite": "^8.0.13"
+      }
+    },
+    "node_modules/@emnapi/core": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
+      "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.1",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
+      "integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
+      "integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.4.tgz",
+      "integrity": "sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@tybys/wasm-util": "^0.10.1"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1"
+      }
+    },
+    "node_modules/@oxc-project/types": {
+      "version": "0.130.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.130.0.tgz",
+      "integrity": "sha512-ibD2usx9JRu7f5pu2tMKMI4cpA4NgXJQoYRP4pQ7Pxmn1l6k/53qWtQWZayhYy3X4QZkt90Ot+mJEaeXouio6Q==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
+    },
+    "node_modules/@rolldown/binding-android-arm64": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.1.tgz",
+      "integrity": "sha512-fJI3I0r3C3Oj/zdBCpaCmBRZYf07xpaq4yCfDDoSFm+beWNzbIl26puW8RraUdugoJw/95zerNOn6jasAhzSmg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-arm64": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.1.tgz",
+      "integrity": "sha512-cKnAhWEsV7TPcA/5EAteDp6KcJZBQ2G+BqE7zayMMi7kMvwRsbv7WT9aOnn0WNl4SKEIf43vjS31iUPu80nzXg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-x64": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.1.tgz",
+      "integrity": "sha512-YKrVwQjIRBPo+5G/u03wGjbdy4q7pyzCe93DK9VJ7zkVmeg8LJ7GbgsiHWdR4xSoe4CAXRD7Bcjgbtr64bkXNg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-freebsd-x64": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.1.tgz",
+      "integrity": "sha512-z/oBsREo46SsFqBwYtFe0kpJeBijAT48O/WXLI4suiCLBkr03RTtTJMCzSdDd2znlh8VJizL09XVkQgk8IZonw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.1.tgz",
+      "integrity": "sha512-ik8q7GM11zxvYxFc2PeDcT6TBvhCQMaUxfph/M5l9sKuTs/Sjg3L+Byw0F7w0ZVLBZmx30P+gG0ECzzN+MFcmQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-gnu": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.1.tgz",
+      "integrity": "sha512-QoSx2EkyrrdZ6kcyE8stqZ62t0Yra8Fs5ia9lOxJrh6TMQJK7gQKmscdTHf7pOXKREKrVwOtJcQG3qVSfc866A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-musl": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.1.tgz",
+      "integrity": "sha512-uwNwFpwKeNiZawfAWBgg0VIztPTV3ihhh1vV334h9ivnNLorxnQMU6Fz8wG1Zb4Qh9LC1/MkcyT3YlDXG3Rsgg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.1.tgz",
+      "integrity": "sha512-zY1bul7OWr7DFBiJ++wofXvnr8B45ce3QsQUhKrIhXsygAh7bTkwyeM1bi1a2g5C/yC/N8TZyGDEoMfm/l9mpg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-s390x-gnu": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.1.tgz",
+      "integrity": "sha512-0frlsT/f4Ft6I7SMESTKnF3cZsdicQn1dCMkF/jT9wDLE+gGoiQfv1nmT9e+s7s/fekvvy6tZM2jHvI2tkbJDQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.1.tgz",
+      "integrity": "sha512-XABVmGp9Tg0WspTVvwduTc4fpqy6JnAUrSQe6OuyqD/03nI7r0O9OWUkMIwFrjKAIqolvqoA4ZrJppgwE0Gxmw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.1.tgz",
+      "integrity": "sha512-bV4fzswuzVcKD90o/VM6QqKxnxlDq0g2BISDLNVmxrnhpv1DDbyPhCIjYfvzYLV+MvkKKnQt2Q6AO86SEBULUQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-openharmony-arm64": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.1.tgz",
+      "integrity": "sha512-/Mh0Zhq3OP7fVs0kcQHZP6lZEthMGTaSf8UBQYSFEZDWGXXlEC+nJ6EqenaK2t4LBXMe3A+K/G2BVXXdtOr4PQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.1.tgz",
+      "integrity": "sha512-+1xc9X45l8ufsBAm6Gjvx2qDRIY9lTVt0cgWNcJ+1gdhXvkbxePA60yRTwSTuXL09CMhyJmjpV7E3NoyxbqFQQ==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "1.10.0",
+        "@emnapi/runtime": "1.10.0",
+        "@napi-rs/wasm-runtime": "^1.1.4"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-arm64-msvc": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.1.tgz",
+      "integrity": "sha512-1D+UqZdfnuR+Jy1GgMJwi85bD40H21uNmOPRWQhw4oRSuolZ/B5rixZ45DK2KXOTCvmVCecauWgEhbw8bI7tOw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.1.tgz",
+      "integrity": "sha512-INAycaWuhlOK3wk4mRHGsdgwYWmd9cChdPdE9bwWmy6rn9VqVNYNFGhOdXrofXUxwHIncSiPNb8tNm8knDVIeQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+      "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.2",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.2.tgz",
+      "integrity": "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/create-vite": {
+      "version": "9.0.7",
+      "resolved": "https://registry.npmjs.org/create-vite/-/create-vite-9.0.7.tgz",
+      "integrity": "sha512-TyuOQvwX4i/QN9acJzC7wzM7FfC12/1XlH3+d05PeD7Kj5o4BObuq78fB1x84SrEoi5KcQOi+b9K3JV+PWNHvw==",
+      "license": "MIT",
+      "bin": {
+        "create-vite": "index.js",
+        "cva": "index.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
+      "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
+      "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
+      "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
+      "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
+      "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
+      "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
+      "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
+      "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.14",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.14.tgz",
+      "integrity": "sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rolldown": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.1.tgz",
+      "integrity": "sha512-X0KQHljNnEkWNqqiz9zJrGunh1B0HgOxLXvnFpCOcadzcy5qohZ3tqMEUg00vncoRovXuK3ZqCT9KnnKzoInFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/types": "=0.130.0",
+        "@rolldown/pluginutils": "^1.0.0"
+      },
+      "bin": {
+        "rolldown": "bin/cli.mjs"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "@rolldown/binding-android-arm64": "1.0.1",
+        "@rolldown/binding-darwin-arm64": "1.0.1",
+        "@rolldown/binding-darwin-x64": "1.0.1",
+        "@rolldown/binding-freebsd-x64": "1.0.1",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.0.1",
+        "@rolldown/binding-linux-arm64-gnu": "1.0.1",
+        "@rolldown/binding-linux-arm64-musl": "1.0.1",
+        "@rolldown/binding-linux-ppc64-gnu": "1.0.1",
+        "@rolldown/binding-linux-s390x-gnu": "1.0.1",
+        "@rolldown/binding-linux-x64-gnu": "1.0.1",
+        "@rolldown/binding-linux-x64-musl": "1.0.1",
+        "@rolldown/binding-openharmony-arm64": "1.0.1",
+        "@rolldown/binding-wasm32-wasi": "1.0.1",
+        "@rolldown/binding-win32-arm64-msvc": "1.0.1",
+        "@rolldown/binding-win32-x64-msvc": "1.0.1"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.16",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
+      "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/vite": {
+      "version": "8.0.13",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.13.tgz",
+      "integrity": "sha512-MFtjBYgzmSxmgA4RAfjIyXWpGe1oALnjgUTzzV7QLx/TKxCzjtMH6Fd9/eVK+5Fg1qNoz5VAwsmMs/NofrmJvw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "lightningcss": "^1.32.0",
+        "picomatch": "^4.0.4",
+        "postcss": "^8.5.14",
+        "rolldown": "1.0.1",
+        "tinyglobby": "^0.2.16"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.1.18",
+        "esbuild": "^0.27.0 || ^0.28.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "@vitejs/devtools": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    }
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/package.json b/TicTacToe-Compare/ministral-3-14b/package.json
new file mode 100644
index 0000000..975ee9b
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "tictactoe",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "vite src",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "description": "A web-based Tic-Tac-Toe game with AI",
+  "main": "index.js",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "create-vite": "^9.0.7"
+  },
+  "devDependencies": {
+    "vite": "^8.0.13"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/src/game.ts b/TicTacToe-Compare/ministral-3-14b/src/game.ts
new file mode 100644
index 0000000..14ea35f
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/src/game.ts
@@ -0,0 +1,116 @@
+/**
+ * Core game logic for Tic-Tac-Toe (X, O, and AI)
+ */
+
+// Game constants
+const PLAYERS = {
+  X: 'X',
+  O: 'O',
+} as const;
+
+// Game board is 3x3
+const BOARD_SIZE = 3;
+
+/** Represents the current game state */
+interface GameState {
+  board: string[][];
+  currentPlayer: keyof typeof PLAYERS;
+  history: string[][][];
+  isGameOver: boolean;
+}
+/** Creates a blank game state */
+const initializeGame(): GameState {
+  const emptyBoard = Array(BOARD_SIZE).fill().map(() => Array(BOARD_SIZE).fill(null));
+  return {
+    board: emptyBoard,
+    currentPlayer: Math.random() < 0.5 ? PLAYERS.O : PLAYERS.X, // Random assign X for coin flip 
+    history: [],
+    isGameOver: false,
+  };
+}
+
+/**
+ * Check if a player (X or O) has won the current board
+ */
+function hasWin(board: string[][], player: keyof typeof PLAYERS): boolean {
+  // Check rows/columns
+  for (let i = 0; i < BOARD_SIZE; i++) {
+    if (board[i].every(cell => cell === player) || board.every(row => row[i] === player))
+      return true;
+  }
+
+  // Check diagonals
+  if (
+    board[0][0] === player && board[1][1] === player && board[2][2] === player ||
+    board[2][0] === player && board[1][1] === player && board[0][2] === player
+  )
+    return true;
+
+  return false;
+}
+
+/**
+ * Check if the game ended in a draw
+ */
+function hasDraw(board: string[][]): boolean {
+  return !board.flat().includes(null);
+}
+
+/**
+ * Check if a move is valid (within bounds and board position is empty)
+ */
+function isValidMove(board: string[][], row: number, col: number): boolean {
+  return row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE && board[row][col] === null;
+}
+
+/**
+ * Makes a valid AI move (randomly chooses from legal moves)
+ */
+function makeAIMove(game: GameState): { row: number, col: number } {
+  const { board } = game;
+
+  // Collect all valid (empty) positions
+  const emptyPositions = [];
+  for (let r = 0; r < BOARD_SIZE; r++) {
+    for (let c = 0; c < BOARD_SIZE; c++) {
+      if (!board[r][c]) emptyPositions.push({ r, c });
+    }
+  }
+
+  // Randomly select an empty position 
+  const randomPos = emptyPositions[Math.floor(Math.random() * emptyPositions.length)];
+
+  return { row: randomPos.r, col: randomPos.c };
+}
+
+/**
+ * Update game state with the given move (row, col)
+ * @returns game state after move
+ */
+function updateGameState(game: GameState, row: number, col: number): GameState {
+  const newBoard = game.board.map(row => [...row]);
+  const current = game.currentPlayer;
+
+  if (isValidMove(newBoard, row, col)) {
+    newBoard[row][col] = current;
+    const gameEnded = hasWin(newBoard, current) || hasDraw(newBoard);
+
+    return { ...game,
+      board: newBoard,
+      history: [...game.history, newBoard],
+      isGameOver: gameEnded,
+      currentPlayer: (current === PLAYERS.X ? PLAYERS.O : PLAYERS.X),
+    };
+  }
+
+  return game; // Invalid move? No state update
+}
+
+/**
+ * Reset game to a clean state (after win/draw)
+ */
+function resetGame(): GameState {
+  return initializeGame();
+}
+
+export { PLAYERS, BOARD_SIZE, initializeGame, updateGameState, makeAIMove, resetGame, hasWin, hasDraw };
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/src/node_modules/.vite/deps/_metadata.json b/TicTacToe-Compare/ministral-3-14b/src/node_modules/.vite/deps/_metadata.json
new file mode 100644
index 0000000..e66b6cf
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/src/node_modules/.vite/deps/_metadata.json
@@ -0,0 +1,8 @@
+{
+  "hash": "e82e9607",
+  "configHash": "02e799c0",
+  "lockfileHash": "a18784c0",
+  "browserHash": "a10e1803",
+  "optimized": {},
+  "chunks": {}
+}
\ No newline at end of file
diff --git a/TicTacToe-Compare/ministral-3-14b/src/node_modules/.vite/deps/package.json b/TicTacToe-Compare/ministral-3-14b/src/node_modules/.vite/deps/package.json
new file mode 100644
index 0000000..3dbc1ca
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/src/node_modules/.vite/deps/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/src/package.json b/TicTacToe-Compare/ministral-3-14b/src/package.json
new file mode 100644
index 0000000..97af3dc
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/src/package.json
@@ -0,0 +1,17 @@
+{
+  "name": "ministral-3-14b",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "create-vite": "^9.0.7",
+    "vite": "^8.0.13"
+  }
+}
diff --git a/TicTacToe-Compare/ministral-3-14b/vite.config.ts b/TicTacToe-Compare/ministral-3-14b/vite.config.ts
new file mode 100644
index 0000000..b49fd4e
--- /dev/null
+++ b/TicTacToe-Compare/ministral-3-14b/vite.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  base: './',
+  build: {
+    outDir: 'dist',
+    emptyOutDir: true,
+    input: './index.html'
+  }
+})
\ No newline at end of file
diff --git a/TicTacToe-Compare/models.txt b/TicTacToe-Compare/models.txt
new file mode 100644
index 0000000..b42114c
--- /dev/null
+++ b/TicTacToe-Compare/models.txt
@@ -0,0 +1,24 @@
+Model
+64500165/openclaw-omnicoder-2:9b
+codemate-ai/mini-coder:latest
+codellama:13b
+Codetru-DevOps/payroll-llama-3.2-1b:1.1
+cogito:14b
+deepcoder:14b
+deepseek-coder-v2:16b
+deepseek-r1:14b
+dolphin-phi:2.7b
+dolphincoder:15b
+gemma3:12b
+granite-code:8b
+granite-code:20b
+granite3.3
+llama3.1:8b
+llama3.2:3b
+ministral-3:14b
+opencoder:latest
+phi4-mini-reasoning
+phi4-reasoning:14b
+qwen3.5:9b
+qwen3.6:27b
+yi-coder:9b
diff --git a/TicTacToe-Compare/openclaw-omnicoder-2-9b/index.html b/TicTacToe-Compare/openclaw-omnicoder-2-9b/index.html
new file mode 100644
index 0000000..fac0601
--- /dev/null
+++ b/TicTacToe-Compare/openclaw-omnicoder-2-9b/index.html
@@ -0,0 +1,433 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Tic Tac Toe vs Computer</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #a8edea 0%, #fed6e3 100%);
+            min-height: 100vh;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            padding: 20px;
+        }
+
+        .game-container {
+            background: white;
+            border-radius: 25px;
+            padding: 40px;
+            box-shadow: 0 10px 40px rgba(0,0,0,0.2);
+            text-align: center;
+            max-width: 450px;
+        }
+
+        h1 {
+            font-size: 2rem;
+            margin-bottom: 20px;
+            background: linear-gradient(90deg, #ff6b6b, #ff9500);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            font-weight: 700;
+        }
+
+        .coin-container {
+            display: none;
+            margin: 20px auto;
+        }
+
+        .coin-container.active {
+            display: block;
+        }
+
+        .coin-message {
+            font-size: 1.2rem;
+            color: #555;
+            margin-bottom: 10px;
+            font-weight: 500;
+        }
+
+        .coin {
+            width: 120px;
+            height: 120px;
+            border-radius: 50%;
+            margin: 0 auto;
+            position: relative;
+            transition: transform 1.5s ease-in-out;
+        }
+
+        .coin.heads {
+            background: linear-gradient(135deg, #ffd700, #ffa500);
+        }
+
+        .coin.tails {
+            background: linear-gradient(135deg, #3498db, #2980b9);
+        }
+
+        .coin-header {
+            position: absolute;
+            top: 40px;
+            left: 50%;
+            transform: translateX(-50%);
+            font-size: 2rem;
+            font-weight: bold;
+            color: white;
+            text-shadow: 1px 1px 3px rgba(0,0,0,0.3);
+        }
+
+        .coin-tails .coin-header {
+            top: 40px;
+        }
+
+        .result-message {
+            font-size: 1.5rem;
+            font-weight: bold;
+            min-height: 40px;
+            margin: 15px 0;
+            color: #333;
+        }
+
+        .heads-result {
+            background: linear-gradient(90deg, #ffd700, #ffa500);
+            padding: 15px 25px;
+            border-radius: 15px;
+            color: white;
+            font-size: 1.3rem;
+            box-shadow: 0 4px 15px rgba(255,165,0,0.4);
+        }
+
+        .tails-result {
+            background: linear-gradient(90deg, #3498db, #2980b9);
+            padding: 15px 25px;
+            border-radius: 15px;
+            color: white;
+            font-size: 1.3rem;
+            box-shadow: 0 4px 15px rgba(52,152,219,0.4);
+        }
+
+        .board {
+            display: grid;
+            grid-template-columns: repeat(3, 85px);
+            grid-template-rows: repeat(3, 85px);
+            gap: 8px;
+            margin: 30px auto 0;
+            justify-content: center;
+        }
+
+        .cell {
+            width: 85px;
+            height: 85px;
+            background: linear-gradient(135deg, #87CEEB, #B0E0E6);
+            border: none;
+            border-radius: 12px;
+            cursor: pointer;
+            font-size: 2.5rem;
+            font-weight: bold;
+            transition: transform 0.15s ease, background 0.3s ease;
+            box-shadow: 0 3px 0 rgba(0,0,0,0.15);
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+
+        .cell:hover:not(:disabled) {
+            transform: scale(1.05);
+            background: linear-gradient(135deg, #98DCE8, #C4E2F0);
+        }
+
+        .cell:active:not(:disabled) {
+            transform: scale(0.98);
+            box-shadow: none;
+        }
+
+        .cell.x {
+            color: #3498db;
+            text-shadow: 0 2px 10px rgba(52,152,219,0.4);
+        }
+
+        .cell.o {
+            color: #ff9500;
+            text-shadow: 0 2px 10px rgba(255,149,0,0.4);
+        }
+
+        .cell.winning {
+            background: linear-gradient(135deg, #2ecc71, #27ae60);
+            transform: scale(1.03);
+            box-shadow: 0 5px 20px rgba(46,204,113,0.5);
+        }
+
+        .cell.disabled {
+            cursor: not-allowed;
+            opacity: 0.7;
+        }
+
+        .game-message {
+            min-height: 70px;
+            margin: 20px auto;
+            font-size: 1.3rem;
+            font-weight: 600;
+            padding: 15px 25px;
+            border-radius: 15px;
+            max-width: 95%;
+            word-wrap: break-word;
+        }
+
+        .message-player-wins {
+            background: linear-gradient(90deg, #2ecc71, #27ae60);
+            color: white;
+            animation: bounceIn 0.6s ease;
+        }
+
+        .message-computer-wins {
+            background: linear-gradient(90deg, #ff6b6b, #ff9500);
+            color: white;
+            animation: bounceIn 0.6s ease;
+        }
+
+        .message-draw {
+            background: linear-gradient(90deg, #a29bfe, #6c5ce7);
+            color: white;
+            animation: fadeIn 0.6s ease;
+        }
+
+        .message-start {
+            background: linear-gradient(90deg, #fdcb6e, #ffd700);
+            color: #333;
+            animation: scaleIn 0.6s ease;
+        }
+
+        @keyframes bounceIn {
+            0% { opacity: 0; transform: scale(0.3); }
+            50% { opacity: 1; transform: scale(1.1); }
+            70% { transform: scale(0.9); }
+            100% { transform: scale(1); }
+        }
+
+        @keyframes fadeIn {
+            0% { opacity: 0; }
+            100% { opacity: 1; }
+        }
+
+        @keyframes scaleIn {
+            0% { opacity: 0; transform: scale(0.8); }
+            100% { opacity: 1; transform: scale(1); }
+        }
+
+        @keyframes wave {
+            0% { transform: scale(1); }
+            50% { transform: scale(1.2); }
+            100% { transform: scale(1); }
+        }
+
+        .cell-animating {
+            animation: wave 0.3s ease;
+        }
+
+        .status-indicator {
+            font-size: 1rem;
+            color: #666;
+            margin: 0 0 10px 0;
+            font-style: italic;
+        }
+
+        .thinking {
+            color: #ff9500;
+            font-weight: 600;
+        }
+    </style>
+</head>
+<body>
+    <div class="game-container">
+        <h1>✏️ Tic Tac Toe vs Computer 🤖</h1>
+        
+        <div class="coin-container" id="coinContainer">
+            <div class="coin-message" id="coinMessage">Flipping the coin...</div>
+            <div class="coin" id="coin">
+                <div class="coin-header H">H</div>
+            </div>
+        </div>
+        
+        <div class="result-message" id="resultMessage"></div>
+        
+        <div class="status-indicator" id="statusIndicator"></div>
+        
+        <div class="board" id="board">
+            <button class="cell" data-index="0"></button>
+            <button class="cell" data-index="1"></button>
+            <button class="cell" data-index="2"></button>
+            <button class="cell" data-index="3"></button>
+            <button class="cell" data-index="4"></button>
+            <button class="cell" data-index="5"></button>
+            <button class="cell" data-index="6"></button>
+            <button class="cell" data-index="7"></button>
+            <button class="cell" data-index="8"></button>
+        </div>
+        
+        <div class="game-message" id="gameMessage"></div>
+    </div>
+
+    <script>
+        const board = [null, null, null, null, null, null, null, null, null];
+        let player = 'X';
+        let computer = 'O';
+        let playerNext = true;
+        let gameActive = false;
+
+        const coinContainer = document.getElementById('coinContainer');
+        const coin = document.getElementById('coin');
+        const coinMessage = document.getElementById('coinMessage');
+        const resultMessage = document.getElementById('resultMessage');
+        const gameMessage = document.getElementById('gameMessage');
+        const statusIndicator = document.getElementById('statusIndicator');
+        const cells = document.querySelectorAll('.cell');
+
+        function randomMove() {
+            let available = [];
+            board.forEach((cell, index) => {
+                if (cell === null) available.push(index);
+            });
+            return available[Math.floor(Math.random() * available.length)];
+        }
+
+        function startCoinFlip() {
+            setTimeout(() => {
+                if (!gameActive) {
+                    gameActive = true;
+                    coinContainer.classList.add('active');
+                    coinMessage.textContent = 'Flipping...';
+                    coin.classList.add('active');
+                    
+                    setTimeout(() => {
+                        const isHeads = Math.random() < 0.5;
+                        coin.className = 'coin ' + (isHeads ? 'heads' : 'tails');
+                        coinMessage.textContent = isHeads ? 'Heads!' : 'Tails!';
+                        resultMessage.innerHTML = isHeads 
+                            ? '<div class="heads-result"><span>Heads, <strong>you\'re X!</strong></span></div>'
+                            : '<div class="tails-result"><span>Tails, <strong>computer is <span class="player">\'X\'</span></strong>!</span></div>';
+                        
+                        setTimeout(startGame, 500);
+                    }, 1500);
+                }
+            }, 1000);
+        }
+
+        function startGame() {
+            coinMessage.textContent = 'Ready!';
+            cells.forEach(cell => {
+                cell.textContent = '';
+                cell.className = 'cell';
+                cell.disabled = false;
+            });
+            statusIndicator.textContent = '';
+            gameMessage.innerHTML = '<div class="message-start">Your Turn!</div>';
+            gameActive = true;
+
+            setTimeout(() => {
+                gameActive = false;
+                computerMove();
+            }, 500);
+        }
+
+        function computerMove() {
+            if (!gameActive) return;
+            statusIndicator.textContent = '🤖 Computer is thinking...';
+
+            setTimeout(() => {
+                const move = randomMove();
+                if (move !== undefined) {
+                    makeMove(move, computer, true);
+                    playerNext = true;
+                    gameActive = false;
+                }
+            }, 500);
+        }
+
+        function makeMove(index, mark, isComputer = false) {
+            const cell = cells[index];
+            board[index] = mark;
+            cell.textContent = mark;
+            cell.classList.add(mark.toLowerCase());
+            cell.classList.add('cell-animating');
+
+            setTimeout(() => cell.classList.remove('cell-animating'), 300);
+
+            if (isComputer) {
+                statusIndicator.textContent = '';
+                checkResult();
+            } else {
+                gameActive = false;
+                if (board.includes(null)) {
+                    statusIndicator.textContent = 'Your Turn!';
+                    playerNext = true;
+                } else {
+                    gameMessage.textContent = '🤝';
+                }
+                checkResult();
+            }
+        }
+
+        function checkResult() {
+            const wins = [
+                [0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]
+            ];
+
+            let winner = null;
+            for (let i = 0; i < 8; i++) {
+                if (board[wins[i][0]] === board[wins[i][1]] && 
+                    board[wins[i][1]] === board[wins[i][2]] &&
+                    board[wins[i][0]] !== null) {
+                    winner = board[wins[i][0]];
+                }
+            }
+
+            if (winner) {
+                cells.forEach(cell => {
+                    if (board[parseInt(cell.dataset.index)] === winner) {
+                        cell.classList.add('winning');
+                    }
+                });
+
+                setTimeout(() => {
+                    gameMessage.innerHTML = winner === computer
+                        ? '<div class="message-computer-wins">😄 Computer wins! Better luck next time! 🎮</div>'
+                        : '<div class="message-player-wins">🎉 You win! Great job! 🎮</div>';
+                }, 500);
+            } else if (board.every(cell => cell !== null)) {
+                setTimeout(() => {
+                    gameMessage.textContent = '🤝 It is a draw! 🎮';
+                }, 500);
+            }
+        }
+
+        function restart() {
+            cells.forEach(cell => {
+                cell.textContent = '';
+                cell.className = 'cell';
+            });
+
+            setTimeout(() => {
+                gameMessage.innerHTML = '<div class="message-start">Play Again!</div>';
+                startCoinFlip();
+            }, 300);
+        }
+
+        cells.forEach(cell => {
+            cell.addEventListener('click', () => {
+                if (playerNext) {
+                    makeMove(parseInt(cell.dataset.index), player);
+                }
+            });
+        });
+
+        startCoinFlip();
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/TicTacToe-Compare/prompt - Create a web-based tic-tac-toe game.txt b/TicTacToe-Compare/prompt - Create a web-based tic-tac-toe game.txt
new file mode 100644
index 0000000..3d795c2
--- /dev/null
+++ b/TicTacToe-Compare/prompt - Create a web-based tic-tac-toe game.txt	
@@ -0,0 +1 @@
+Create a web-based tic-tac-toe game. One player will play against the computer. On start, ask the computer to call it for a coin flip to see who gets to go first. The computer will enforce the rules and detect when the game is over and announce the winner or a draw and encourage the player to play again. The computer will select a legal move randomly when it is their turn.
\ No newline at end of file
diff --git a/TicTacToe-Compare/qwen-3-5-9b/index.html b/TicTacToe-Compare/qwen-3-5-9b/index.html
new file mode 100644
index 0000000..6b4d0b6
--- /dev/null
+++ b/TicTacToe-Compare/qwen-3-5-9b/index.html
@@ -0,0 +1,587 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Tic-Tac-Toe Challenge</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            overflow: hidden;
+        }
+
+        .game-container {
+            text-align: center;
+            padding: 40px;
+            background: rgba(255, 255, 255, 0.95);
+            border-radius: 20px;
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+            max-width: 450px;
+            width: 90%;
+        }
+
+        h1 {
+            color: #4a4a4a;
+            margin-bottom: 10px;
+            font-size: 2.5rem;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.1);
+        }
+
+        .subtitle {
+            color: #888;
+            margin-bottom: 30px;
+            font-size: 1rem;
+        }
+
+        .legend {
+            display: flex;
+            justify-content: center;
+            gap: 20px;
+            margin-bottom: 20px;
+            font-size: 0.9rem;
+        }
+
+        .legend-item {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .legend-icon {
+            width: 32px;
+            height: 32px;
+            border-radius: 8px;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            font-size: 1.2rem;
+            font-weight: bold;
+            background: linear-gradient(180deg, #667eea, #5a6fcf);
+            box-shadow: inset 2px 2px 4px rgba(255, 255, 255, 0.3),
+                        inset -2px -2px 4px rgba(0, 0, 0, 0.2);
+        }
+
+        .legend-label {
+            color: #888;
+        }
+
+        .coin-flip-container {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 20px;
+            padding: 20px;
+        }
+
+        .coin {
+            width: 150px;
+            height: 150px;
+            border-radius: 50%;
+            position: relative;
+            margin: 20px auto;
+            font-size: 6rem;
+            font-weight: bold;
+            color: #5d4037;
+            box-shadow: 
+                inset 15px 15px 30px rgba(255, 255, 255, 0.5),
+                inset -15px -15px 30px rgba(139, 69, 19, 0.3),
+                0 15px 40px rgba(0, 0, 0, 0.3);
+            cursor: pointer;
+            transition: transform 0.05s linear;
+            text-shadow: 2px 2px 4px rgba(255, 255, 255, 0.3);
+        }
+
+        .coin.h {
+            transform: rotateY(0deg) scale(1);
+            background: linear-gradient(45deg, #ffd700, #ffb700, #ffd700, #ffeb3b);
+            z-index: 2;
+        }
+
+        .coin.h::before {
+            content: 'H';
+            position: absolute;
+            inset: 0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            background: linear-gradient(180deg, #ffd700, #ffb700);
+            z-index: 1;
+        }
+
+        .coin.t {
+            transform: rotateY(180deg) scale(1);
+            background: linear-gradient(45deg, #8B4513, #A0522D, #8B4513, #6f4e37);
+        }
+
+        .coin.t::before {
+            content: 'T';
+            position: absolute;
+            inset: 0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            background: linear-gradient(180deg, #8B4513, #6f4e37);
+        }
+
+        .flip-btn {
+            padding: 12px 35px;
+            font-size: 1.2rem;
+            background: linear-gradient(45deg, #667eea, #764ba2);
+            color: white;
+            border: none;
+            border-radius: 50px;
+            cursor: pointer;
+            font-weight: bold;
+            box-shadow: 0 5px 20px rgba(102, 126, 234, 0.4);
+            transition: all 0.3s ease;
+            letter-spacing: 1px;
+            margin-top: 10px;
+        }
+
+        .flip-btn:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(102, 126, 234, 0.5);
+        }
+
+        .flip-btn:active {
+            transform: translateY(2px);
+            box-shadow: 0 3px 15px rgba(102, 126, 234, 0.3);
+        }
+
+        .game-board {
+            display: grid;
+            grid-template-columns: repeat(3, 1fr);
+            gap: 12px;
+            margin: 30px 0;
+            max-width: 350px;
+            margin-left: auto;
+            margin-right: auto;
+        }
+
+        .cell {
+            aspect-ratio: 1;
+            background: linear-gradient(145deg, #f5f5f5, #e8e8e8);
+            border: 3px solid #d0d0d0;
+            border-radius: 15px;
+            font-size: 3.5rem;
+            font-weight: bold;
+            cursor: pointer;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            transition: all 0.2s ease;
+            user-select: none;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.1);
+        }
+
+        .cell:hover:not(.x):not(.o) {
+            background: linear-gradient(145deg, #ececec, #e0e0e0);
+            box-shadow: inset 3px 3px 7px rgba(0, 0, 0, 0.1),
+                        inset -3px -3px 7px rgba(255, 255, 255, 0.8);
+            border-color: #b0b0b0;
+        }
+
+        .cell.x {
+            color: #667eea;
+        }
+
+        .cell.o {
+            color: #e91e63;
+        }
+
+        .cell.winning {
+            background: linear-gradient(145deg, #a8e6cf, #8edcbb);
+            transform: scale(1.05);
+            box-shadow: 0 0 25px rgba(136, 198, 178, 0.6);
+        }
+
+        .status {
+            font-size: 1.4rem;
+            margin-bottom: 20px;
+            padding: 15px;
+            border-radius: 10px;
+            background: linear-gradient(135deg, #f8f9fa, #e9ecef);
+            color: #495057;
+            font-weight: 600;
+            min-height: 2em;
+            text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.05);
+        }
+
+        .restart-btn {
+            padding: 12px 40px;
+            font-size: 1.1rem;
+            background: linear-gradient(45deg, #48bb78, #38a169);
+            color: white;
+            border: none;
+            border-radius: 50px;
+            cursor: pointer;
+            font-weight: bold;
+            box-shadow: 0 5px 20px rgba(72, 187, 120, 0.4);
+            transition: all 0.3s ease;
+            letter-spacing: 0.5px;
+        }
+
+        .restart-btn:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(72, 187, 120, 0.5);
+            background: linear-gradient(45deg, #45a049, #359456);
+        }
+
+        .restart-btn:active {
+            transform: translateY(2px);
+            background: linear-gradient(45deg, #45a049, #359456);
+        }
+
+        .turn-indicator {
+            font-size: 1.2rem;
+            margin-bottom: 20px;
+            color: #555;
+        }
+
+        .turn-indicator span {
+            font-weight: bold;
+            padding: 10px 20px;
+            border-radius: 20px;
+            display: inline-block;
+            margin: 0 5px;
+            transition: all 0.3s ease;
+        }
+
+        .turn-indicator .active {
+            background: linear-gradient(45deg, #667eea, #764ba2);
+            color: white;
+            box-shadow: 0 3px 10px rgba(102, 126, 234, 0.3);
+            transform: scale(1.05);
+        }
+
+        .turn-indicator .inactive {
+            background: #e9ecef;
+            color: #adb5bd;
+        }
+
+        .confetti {
+            position: fixed;
+            width: 12px;
+            height: 12px;
+            animation: fall linear forwards;
+            will-change: transform;
+        }
+
+        @keyframes fall {
+            to {
+                transform: translateY(100vh) rotate(720deg);
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="game-container">
+        <h1>🎮 Tic-Tac-Toe</h1>
+        <p class="subtitle">Human vs Computer Challenge!</p>
+
+        <div class="legend">
+            <div class="legend-item">
+                <div class="legend-icon" id="legend-icon"></div>
+                <span class="legend-label" id="legend-x-label">You</span>
+            </div>
+            <div class="legend-item">
+                <div class="legend-icon legend-computer"></div>
+                <span class="legend-label">Computer</span>
+            </div>
+        </div>
+
+        <div id="coinSection" class="coin-flip-container">
+            <div class="coin h">H</div>
+            <p id="coinMessage" style="color: #666; font-weight: 500; text-align: center;">
+                Click the coin to flip! <br>
+                <span style="font-size: 0.9rem; color: #888; display: block; margin-top: 5px;">
+                    🪙 H = Heads (You go first) <br>
+                    🪙 T = Tails (Computer goes first)
+                </span>
+            </p>
+            <button class="flip-btn" id="flipBtn" onclick="flipCoin()">🪙 Flip Coin</button>
+        </div>
+
+        <div id="gameSection" style="display: none;">
+            <div class="turn-indicator">
+                Current Turn:
+                <span id="currentPlayer" class="active">YOU</span>
+                <span id="computerPlayer" class="inactive">COMPUTER</span>
+            </div>
+            <div class="status" id="status"></div>
+            <div class="game-board" id="board">
+                <div class="cell" data-index="0" onclick="makeMove(0)"></div>
+                <div class="cell" data-index="1" onclick="makeMove(1)"></div>
+                <div class="cell" data-index="2" onclick="makeMove(2)"></div>
+                <div class="cell" data-index="3" onclick="makeMove(3)"></div>
+                <div class="cell" data-index="4" onclick="makeMove(4)"></div>
+                <div class="cell" data-index="5" onclick="makeMove(5)"></div>
+                <div class="cell" data-index="6" onclick="makeMove(6)"></div>
+                <div class="cell" data-index="7" onclick="makeMove(7)"></div>
+                <div class="cell" data-index="8" onclick="makeMove(8)"></div>
+            </div>
+            <button class="restart-btn" onclick="restartGame()">🔄 Play Again</button>
+        </div>
+    </div>
+
+    <script>
+        let board = [];
+        let gameActive = false;
+        let myPlayer = 'X';
+        let computerPlayer = 'O';
+        let myTurn = true;
+        let myGoesFirst = false;
+
+        const winPatterns = [
+            [0, 1, 2], [3, 4, 5], [6, 7, 8],
+            [0, 3, 6], [1, 4, 7], [2, 5, 8],
+            [0, 4, 8], [2, 4, 6]
+        ];
+
+        function flipCoin() {
+            const coin = document.querySelector('.coin');
+            const button = document.getElementById('flipBtn');
+            
+            button.disabled = true;
+            coin.style.transition = 'transform 1s ease-in-out';
+            coin.style.transform = 'rotateY(0deg)';
+
+            setTimeout(() => {
+                coin.style.transition = 'none';
+                const result = Math.random() < 0.5 ? 'H' : 'T';
+                coin.style.transition = 'transform 0.5s linear';
+                
+                if (result === 'H') {
+                    coin.className = 'coin h';
+                    myGoesFirst = true;
+                    myPlayer = 'X';
+                    computerPlayer = 'O';
+                    updateLegend();
+                    coin.style.transform = 'rotateY(0deg)';
+                } else {
+                    coin.className = 'coin t';
+                    myGoesFirst = false;
+                    myPlayer = 'O';
+                    computerPlayer = 'X';
+                    updateLegend();
+                    coin.style.transform = 'rotateY(180deg)';
+                }
+
+                document.getElementById('coinMessage').innerHTML =
+                    `🎲 Result: <strong>${result === 'H' ? 'Heads' : 'Tails'}</strong>!<br>` +
+                    (myGoesFirst 
+                        ? `👨 <strong>You</strong> will go first! 🎯 You play as <span style="color: #667eea; font-weight: bold">${myPlayer}</span>` 
+                        : `🤖 <strong>Computer</strong> will go first! 💻 Computer plays as <span style="color: #667eea; font-weight: bold;">${myPlayer}</span>, You play as <span style="color: #e91e63; font-weight: bold;">${computerPlayer}</span>` 
+                    );
+
+                setTimeout(startGame, 2000);
+            }, 1000);
+        }
+
+        function updateLegend() {
+            document.getElementById('legend-x-label').textContent = myTurn 
+                ? `You (${myPlayer}) - Your Turn!` 
+                : `You (${myPlayer}) - Wait for Computer`;
+            
+            if (myGoesFirst && myPlayer === 'X') {
+                document.getElementById('legend-icon').textContent = 'X';
+            } else if (!myGoesFirst && myPlayer === 'X') {
+                document.getElementById('legend-icon').textContent = 'X';
+            }
+        }
+
+        function startGame() {
+            document.getElementById('coinSection').style.display = 'none';
+            document.getElementById('gameSection').style.display = 'block';
+            gameActive = true;
+            
+            if (myGoesFirst) {
+                // Player X (which could be human or computer) goes first
+                if (myPlayer === 'X') {
+                    // Human is X, goes first
+                    myTurn = true;
+                    document.getElementById('currentPlayer').classList.remove('inactive');
+                    document.getElementById('currentPlayer').classList.add('active');
+                    document.getElementById('computerPlayer').classList.remove('active');
+                    document.getElementById('computerPlayer').classList.add('inactive');
+                } else {
+                    // Computer is X, goes first
+                    computerMove();
+                }
+                document.getElementById('status').textContent = 'Choose a cell to make your move!';
+            } else if (!myGoesFirst) {
+                // Computer goes first
+                computerMove();
+            }
+        }
+
+        function computerMove() {
+            if (!gameActive) return;
+
+            const cells = Array.from(document.querySelectorAll('.cell'));
+            const possibleMoves = [];
+
+            cells.forEach((cell) => {
+                if (!cell.textContent) {
+                    possibleMoves.push(parseInt(cell.dataset.index));
+                }
+            });
+
+            if (possibleMoves.length === 0) {
+                return;
+            }
+
+            const randomMove = possibleMoves[Math.floor(Math.random() * possibleMoves.length)];
+            board[randomMove] = 'O';
+            cells[randomMove].textContent = 'O';
+            cells[randomMove].classList.add('o');
+
+            if (checkWin('O')) {
+                endGame('computer');
+            } else if (checkDraw()) {
+                endGame('draw');
+            } else {
+                myTurn = true;
+                updateTurnStatus();
+                document.getElementById('status').textContent = 'Your turn! Click any cell.';
+            }
+        }
+
+        function makeMove(index) {
+            if (!gameActive) return;
+            if (!myTurn) return;
+            if (board[index]) return;
+
+            board[index] = myPlayer;
+            const cells = Array.from(document.querySelectorAll('.cell'));
+            cells[index].textContent = myPlayer;
+            cells[index].classList.add(myPlayer.toLowerCase());
+
+            if (checkWin(myPlayer)) {
+                endGame('human');
+                return;
+            }
+
+            if (checkDraw()) {
+                endGame('draw');
+                return;
+            }
+
+            myTurn = false;
+            updateTurnStatus();
+            document.getElementById('status').textContent = "Computer is thinking...";
+            setTimeout(computerMove, 800);
+        }
+
+        function checkWin(player) {
+            return winPatterns.some(pattern => {
+                return pattern.every(index => board[index] === player);
+            });
+        }
+
+        function checkDraw() {
+            return board.length > 0 && !board.includes('');
+        }
+
+        function updateTurnStatus() {
+            const humanSpan = document.getElementById('currentPlayer');
+            const computerSpan = document.getElementById('computerPlayer');
+
+            if (myTurn) {
+                humanSpan.classList.add('active');
+                humanSpan.classList.remove('inactive');
+                computerSpan.classList.remove('active');
+                computerSpan.classList.add('inactive');
+                document.getElementById('status').textContent = 'Your turn! Click any cell.';
+            } else {
+                humanSpan.classList.remove('active');
+                humanSpan.classList.add('inactive');
+                computerSpan.classList.add('active');
+                computerSpan.classList.remove('inactive');
+            }
+        }
+
+        function endGame(result) {
+            gameActive = false;
+            const statusEl = document.getElementById('status');
+
+            if (result === 'human') {
+                statusEl.textContent = '🎉 YOU WON! Congratulations! Play again!';
+                statusEl.style.background = 'linear-gradient(135deg, #a8e6cf, #8edcbb)';
+                createConfetti();
+            } else if (result === 'computer') {
+                statusEl.textContent = '😅 COMPUTER WINS! Better luck next time! Play again!';
+                statusEl.style.background = 'linear-gradient(135deg, #ffecd2, #fcb69f)';
+            } else {
+                statusEl.textContent = '🤝 DRAW GAME! Well played! Try again!';
+                statusEl.style.background = 'linear-gradient(135deg, #d4fc79, #96e6a1)';
+            }
+        }
+
+        function createConfetti() {
+            const colors = ['#ff6b6b', '#feca57', '#48dbfb', '#ff9ff3', '#54a0ff', '#1dd1a1'];
+            for (let i = 0; i < 60; i++) {
+                const confetti = document.createElement('div');
+                confetti.classList.add('confetti');
+                confetti.style.left = Math.random() * 100 + 'vw';
+                confetti.style.top = -10 + 'px';
+                confetti.style.background = colors[Math.floor(Math.random() * colors.length)];
+                confetti.style.borderRadius = Math.random() > 0.5 ? '50%' : '2px 0 2px 2px';
+                confetti.style.animationDuration = (Math.random() * 3 + 2) + 's';
+                document.body.appendChild(confetti);
+                setTimeout(() => confetti.remove(), 5000);
+            }
+        }
+
+        function restartGame() {
+            // Reset everything for fresh game
+            board = [];
+            gameActive = false;
+            myTurn = true;
+            
+            // Reset board display
+            Array.from(document.querySelectorAll('.cell')).forEach(cell => {
+                cell.textContent = '';
+                cell.classList.remove('x', 'o', 'winning');
+            });
+            
+            // Reset message to show coin page
+            if (document.getElementById('coinSection').style.display === 'none') {
+                document.getElementById('coinSection').style.display = 'flex';
+                document.getElementById('gameSection').style.display = 'none';
+                
+                // Reset coin to default
+                const coin = document.querySelector('.coin');
+                coin.textContent = 'H';
+                coin.className = 'coin h';
+                coin.style.transform = 'rotateY(0deg)';
+                document.getElementById('coinMessage').innerHTML = 'Click the coin to flip!<br><span style="font-size: 0.9rem; color: #888; display: block; margin-top: 5px;">🪙 H = Heads (You go first)<br>🪙 T = Tails (Computer goes first)</span>';
+                document.getElementById('flipBtn').disabled = false;
+            }
+            
+            document.getElementById('currentPlayer').classList.remove('active');
+            document.getElementById('currentPlayer').classList.add('inactive');
+            document.getElementById('computerPlayer').classList.remove('inactive');
+            document.getElementById('computerPlayer').classList.add('active');
+            document.getElementById('status').textContent = '';
+            document.getElementById('legend-x-label').textContent = 'You - Your Turn!';
+        }
+
+        function cleanUp() {
+            const confettis = document.querySelectorAll('.confetti');
+            confettis.forEach(c => c.remove());
+        }
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/TicTacToe-Compare/qwen3.6-27b/index.html b/TicTacToe-Compare/qwen3.6-27b/index.html
new file mode 100644
index 0000000..2b60f5f
--- /dev/null
+++ b/TicTacToe-Compare/qwen3.6-27b/index.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Tic-Tac-Toe</title>
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+
+body {
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  background: #1a1a2e;
+  color: #eee;
+  font-family: 'Segoe UI', system-ui, sans-serif;
+}
+
+h1 {
+  font-size: 2.4rem;
+  margin-bottom: 0.5rem;
+  letter-spacing: 2px;
+}
+
+#status {
+  font-size: 1.2rem;
+  min-height: 2rem;
+  margin-bottom: 1rem;
+  color: #aaa;
+}
+
+#board {
+  display: grid;
+  grid-template-columns: repeat(3, 110px);
+  grid-template-rows: repeat(3, 110px);
+  gap: 6px;
+}
+
+.cell {
+  width: 110px;
+  height: 110px;
+  background: #16213e;
+  border: 2px solid #0f3460;
+  border-radius: 8px;
+  font-size: 3rem;
+  font-weight: bold;
+  color: #eee;
+  cursor: pointer;
+  transition: background 0.15s;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.cell:hover { background: #1a2a50; }
+.cell.taken { cursor: default; }
+.cell.x { color: #e94560; }
+.cell.o { color: #53d8fb; }
+
+/* ---- overlays ---- */
+.overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(10, 10, 30, 0.92);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  z-index: 10;
+}
+
+.overlay.hidden { display: none; }
+
+#coin {
+  width: 120px;
+  height: 120px;
+  border-radius: 50%;
+  background: radial-gradient(circle at 40% 40%, #ffd700, #b8860b);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 2rem;
+  font-weight: 800;
+  color: #1a1a2e;
+  margin-bottom: 1.5rem;
+}
+
+#coin.flip {
+  animation: coinFlip 0.8s ease-in-out;
+}
+
+@keyframes coinFlip {
+  0%   { transform: scale(1) rotateY(0); }
+  40%  { transform: scale(1.3) rotateY(900deg); }
+  60%  { transform: scale(1.3) rotateY(1800deg); }
+  100% { transform: scale(1) rotateY(3600deg); }
+}
+
+#coin-text {
+  font-size: 1.5rem;
+  margin-bottom: 0.6rem;
+}
+
+.result-title {
+  font-size: 2.8rem;
+  font-weight: 700;
+  margin-bottom: 1rem;
+}
+
+.result-sub {
+  font-size: 1.2rem;
+  color: #aaa;
+  margin-bottom: 1.5rem;
+}
+
+button {
+  padding: 0.7rem 2rem;
+  font-size: 1.1rem;
+  border: none;
+  border-radius: 6px;
+  background: #e94560;
+  color: #fff;
+  cursor: pointer;
+  transition: background 0.15s;
+}
+
+button:hover { background: #c73a52; }
+
+.win-line {
+  background: #0a3d62 !important;
+  border-color: #e94560 !important;
+}
+</style>
+</head>
+<body>
+
+<h1>Tic-Tac-Toe</h1>
+<div id="status"></div>
+<div id="board"></div>
+
+<!-- Coin flip overlay -->
+<div class="overlay" id="coinOverlay">
+  <div id="coin">?</div>
+  <div id="coin-text">Flipping a coin…</div>
+</div>
+
+<!-- Game over overlay -->
+<div class="overlay hidden" id="endOverlay">
+  <div class="result-title" id="endTitle"></div>
+  <div class="result-sub" id="endSub"></div>
+  <button id="restartBtn">Play Again</button>
+</div>
+
+<script>
+const WIN_PATTERNS = [
+  [0,1,2],[3,4,5],[6,7,8],
+  [0,3,6],[1,4,7],[2,5,8],
+  [0,4,8],[2,4,6]
+];
+
+let board, playerMark, compMark, currentPlayer, gameOver;
+
+const boardEl = document.getElementById('board');
+const statusEl = document.getElementById('status');
+const coinOverlay = document.getElementById('coinOverlay');
+const coinEl = document.getElementById('coin');
+const coinText = document.getElementById('coin-text');
+const endOverlay = document.getElementById('endOverlay');
+const endTitle = document.getElementById('endTitle');
+const endSub = document.getElementById('endSub');
+
+// ---------- init ----------
+function init() {
+  board = Array(9).fill(null);
+  gameOver = false;
+  endOverlay.classList.add('hidden');
+  buildBoard();
+
+  coinText.textContent = 'Flipping a coin…';
+  coinEl.textContent = '?';
+  coinEl.classList.remove('flip');
+  coinOverlay.classList.remove('hidden');
+
+  void coinEl.offsetWidth;
+  coinEl.classList.add('flip');
+
+  setTimeout(() => {
+    const heads = Math.random() < 0.5;
+    coinEl.textContent = heads ? 'H' : 'T';
+
+    if (heads) {
+      playerMark = 'X';
+      compMark = 'O';
+      currentPlayer = 'player';
+      coinText.textContent = 'Heads! You go first as X.';
+    } else {
+      playerMark = 'O';
+      compMark = 'X';
+      currentPlayer = 'computer';
+      coinText.textContent = 'Tails! Computer goes first as X.';
+    }
+
+    statusEl.textContent = currentPlayer === 'player'
+      ? 'Your turn'
+      : "Computer's turn";
+
+    setTimeout(() => {
+      coinOverlay.classList.add('hidden');
+      if (currentPlayer === 'computer') {
+        setTimeout(compMove, 1000);
+      }
+    }, 1400);
+  }, 850);
+}
+
+function buildBoard() {
+  boardEl.innerHTML = '';
+  for (let i = 0; i < 9; i++) {
+    const cell = document.createElement('div');
+    cell.classList.add('cell');
+    cell.dataset.index = i;
+    cell.addEventListener('click', () => handleClick(i));
+    boardEl.appendChild(cell);
+  }
+}
+
+function render() {
+  const cells = boardEl.querySelectorAll('.cell');
+  cells.forEach((c, i) => {
+    c.textContent = board[i] || '';
+    c.classList.remove('x', 'o', 'taken');
+    if (board[i]) {
+      c.classList.add(board[i], 'taken');
+    }
+  });
+}
+
+function handleClick(i) {
+  if (gameOver || board[i] || currentPlayer !== 'player') return;
+  board[i] = playerMark;
+  render();
+  if (checkEnd()) return;
+  currentPlayer = 'computer';
+  statusEl.textContent = "Computer's turn";
+  setTimeout(compMove, 600);
+}
+
+function compMove() {
+  if (gameOver) return;
+  const empties = board.map((v, i) => v === null ? i : -1).filter(i => i !== -1);
+  if (!empties.length) return;
+  board[empties[Math.floor(Math.random() * empties.length)]] = compMark;
+  render();
+  checkEnd();
+}
+
+function checkEnd() {
+  const winner = checkWinner();
+  if (winner) {
+    gameOver = true;
+    const cells = boardEl.querySelectorAll('.cell');
+    const line = WIN_PATTERNS.find(p => p.every(i => board[i] === winner));
+    if (line) line.forEach(i => cells[i].classList.add('win-line'));
+
+    const isPlayer = winner === playerMark;
+    endTitle.textContent = isPlayer ? 'You Win!' : 'Computer Wins!';
+    endSub.textContent = isPlayer
+      ? 'Great job! Want to play again?'
+      : 'Better luck next time. Play again?';
+    setTimeout(() => endOverlay.classList.remove('hidden'), 700);
+    return true;
+  }
+  if (board.every(c => c !== null)) {
+    gameOver = true;
+    endTitle.textContent = 'It\'s a Draw!';
+    endSub.textContent = 'No winner this round. Try again?';
+    setTimeout(() => endOverlay.classList.remove('hidden'), 700);
+    return true;
+  }
+  if (!gameOver) {
+    currentPlayer = (currentPlayer === 'player') ? 'computer' : 'player';
+    statusEl.textContent = currentPlayer === 'player' ? 'Your turn' : "Computer's turn";
+  }
+  return false;
+}
+
+function checkWinner() {
+  for (const [a, b, c] of WIN_PATTERNS) {
+    if (board[a] && board[a] === board[b] && board[a] === board[c]) return board[a];
+  }
+  return null;
+}
+
+document.getElementById('restartBtn').addEventListener('click', init);
+init();
+</script>
+</body>
+</html>
diff --git a/TicTacToe/TicTacGaming/vite.config.ts b/TicTacToe/TicTacGaming/vite.config.ts
new file mode 100644
index 0000000..731208b
--- /dev/null
+++ b/TicTacToe/TicTacGaming/vite.config.ts
@@ -0,0 +1,20 @@
+import path from 'path'
+import { defineConfig } from 'vite'
+
+const config = defineConfig({
+  base: './', 
+  resolve: {
+    alias: {
+      '@/game': path.resolve('src', 'game.ts'),
+      '@/ui': path.resolve('src', 'ui.ts')
+    }},
+  build: {
+    outDir: 'dist',
+    emptyOutDir: true,
+    rollupOptions: {
+      input: { main: './index.html' },
+    }
+  }
+})
+
+export default config