Initial commit: AI思维导图生成器项目

- 基于Django + Vue.js的智能思维导图生成和管理系统 - 支持AI驱动的文档分析和可视化思维导图创建 - 包含完整的前后端代码和文档
2025-09-04 13:47:42 +08:00 · 2025-09-04 13:47:42 +08:00 · 5b73857835
commit 5b73857835
2643 changed files with 1489467 additions and 0 deletions
--- a/.DS_Store
+++ b/.DS_Store
--- a/README.md
+++ b/README.md
@ -0,0 +1,396 @@
+# AI思维导图生成器
+
+基于Django + Vue.js的智能思维导图生成和管理系统，支持AI驱动的文档分析和可视化思维导图创建。
+
+## ✨ 功能特性
+
+### 🧠 AI智能分析
+- **文档智能解析**: 支持DOCX、PDF、TXT、MD等多种格式
+- **AI内容提取**: 自动识别文档结构，生成层次化思维导图
+- **智能标题识别**: 基于视觉特征和语义逻辑的标题层级分析
+- **内容结构化**: 将非结构化文档转换为结构化思维导图
+
+### 🎨 可视化编辑
+- **交互式思维导图**: 基于MindElixir的可视化编辑界面
+- **拖拽操作**: 支持节点拖拽、移动、编辑
+- **实时保存**: 自动保存编辑内容到数据库
+- **缩放控制**: 支持思维导图缩放和居中显示
+
+### 💾 数据管理
+- **云端存储**: 思维导图数据持久化存储
+- **历史记录**: 自动保存操作历史，支持快速恢复
+- **数据导入导出**: 支持JSON格式的数据交换
+- **版本管理**: 自动记录创建和更新时间
+
+### 🔧 技术特性
+- **响应式设计**: 适配不同屏幕尺寸
+- **实时协作**: 支持多用户同时编辑
+- **API接口**: 完整的RESTful API
+- **模块化架构**: 前后端分离，易于扩展
+
+## 🛠️ 技术栈
+
+### 后端技术
+- **框架**: Django 4.2.7 + Django REST Framework
+- **数据库**: SQLite（生产环境可配置PostgreSQL/MySQL）
+- **AI服务**: OpenAI API + 智谱AI GLM-4.5
+- **文件处理**: python-docx, PyPDF2, markdown
+- **跨域支持**: django-cors-headers
+
+### 前端技术
+- **框架**: Vue.js 3.3.4 + Vite 4.4.9
+- **思维导图**: MindElixir 3.0.0
+- **文件处理**: mammoth.js (DOCX), pdfjs-dist (PDF)
+- **HTTP客户端**: Axios 1.5.0
+- **Markdown处理**: marked 16.2.1
+
+### AI内容分析
+- **TypeScript**: 类型安全的Markdown转JSON转换
+- **流式处理**: 支持大文档的流式AI分析
+- **多模型支持**: 支持多种AI模型切换
+
+## 🚀 快速开始
+
+### 环境要求
+- Python 3.8+
+- Node.js 16+
+- npm 或 yarn
+
+### 1. 克隆项目
+```bash
+git clone <repository-url>
+cd siweidaotu
+```
+
+### 2. 后端设置
+
+#### 进入后端目录
+```bash
+cd backend
+```
+
+#### 安装Python依赖
+```bash
+pip install -r requirements.txt
+```
+
+#### 数据库迁移
+```bash
+python manage.py makemigrations
+python manage.py migrate
+```
+
+#### 创建超级用户（可选）
+```bash
+python manage.py createsuperuser
+```
+
+#### 启动Django服务器
+```bash
+python manage.py runserver
+```
+
+### 3. 前端设置
+
+#### 安装Node.js依赖
+```bash
+cd frontend
+npm install
+```
+
+#### 启动前端开发服务器
+```bash
+npm run dev
+```
+
+### 4. 访问应用
+- 前端界面: http://localhost:5173
+- 后端API: http://localhost:8000
+- Django管理后台: http://localhost:8000/admin
+
+## 📡 API接口
+
+### 思维导图管理
+- `GET /api/mindMaps/{id}` - 获取思维导图数据
+- `POST /api/mindMaps` - 创建新思维导图
+
+### 节点操作
+- `POST /api/mindMaps/addNodes` - 批量添加节点
+- `PATCH /api/mindMaps/updateNode` - 更新节点信息
+- `DELETE /api/mindMaps/deleteNodes` - 批量删除节点
+
+### AI服务
+- `POST /api/ai/generate-markdown` - AI生成Markdown内容
+
+### 数据格式
+所有API返回的数据都遵循MindElixir格式规范，支持树形结构的数据交换。
+
+## 📁 项目结构
+
+```
+siweidaotu/
+├── backend/                    # 后端代码
+│   ├── django_mindmap/        # Django项目配置
+│   │   ├── settings.py        # 项目设置
+│   │   ├── urls.py           # 主URL配置
+│   │   └── wsgi.py          # WSGI配置
+│   ├── mindmap/              # 主应用
+│   │   ├── models.py         # 数据模型（mindMap, Node）
+│   │   ├── views_doc.py      # API视图函数
+│   │   ├── serializers.py    # 数据序列化器
+│   │   ├── ai_service.py     # AI服务集成
+│   │   ├── services.py       # 业务逻辑服务
+│   │   └── urls.py          # 应用URL配置
+│   ├── manage.py             # Django管理脚本
+│   ├── requirements.txt      # Python依赖
+│   └── mindmap.db           # SQLite数据库
+├── frontend/                  # Vue.js前端
+│   ├── src/
+│   │   ├── components/       # Vue组件
+│   │   │   ├── MindMap.vue   # 思维导图组件
+│   │   │   └── AISidebar.vue # AI助手侧边栏
+│   │   ├── api/             # API接口
+│   │   │   └── mindmap.js   # 思维导图API
+│   │   └── App.vue          # 主应用组件
+│   ├── package.json         # 前端依赖
+│   └── vite.config.js       # Vite配置
+├── others_deletable/         # 其他文件（可删除）
+│   ├── ai-content-analyzer/  # AI内容分析工具
+│   │   ├── markdownToJSON.ts # Markdown转JSON
+│   │   ├── json_openai.py    # AI服务调用
+│   │   └── package.json      # TypeScript依赖
+│   └── json_openai.py        # 独立AI服务文件
+├── json、接口文档.md          # API接口文档
+└── README.md                 # 项目文档
+```
+
+## ⚙️ 配置说明
+
+### AI服务配置
+
+在 `backend/mindmap/ai_service.py` 中配置AI服务：
+
+```python
+# 智谱AI配置
+API_KEY = "your_glm_api_key"
+BASE_URL = "https://open.bigmodel.cn/api/paas/v4/"
+MODEL = "glm-4.5"
+
+# OpenAI配置（可选）
+OPENAI_API_KEY = "your_openai_api_key"
+```
+
+### 数据库配置
+
+默认使用SQLite，生产环境建议使用PostgreSQL：
+
+```python
+# backend/django_mindmap/settings.py
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.postgresql',
+        'NAME': 'mindmap_db',
+        'USER': 'your_username',
+        'PASSWORD': 'your_password',
+        'HOST': 'localhost',
+        'PORT': '5432',
+    }
+}
+```
+
+### 文件上传配置
+
+```python
+# backend/django_mindmap/settings.py
+MAX_UPLOAD_SIZE = 16 * 1024 * 1024  # 16MB
+ALLOWED_FILE_TYPES = ['.docx', '.pdf', '.txt', '.md']
+MEDIA_ROOT = BASE_DIR / 'media'
+MEDIA_URL = '/media/'
+```
+
+### 前端配置
+
+```javascript
+// frontend/src/api/mindmap.js
+const API_BASE_URL = "http://127.0.0.1:8000/api";
+```
+
+## 🛠️ 开发指南
+
+### 添加新数据模型
+
+1. 在 `backend/mindmap/models.py` 中定义模型
+2. 运行数据库迁移：
+   ```bash
+   cd backend
+   python manage.py makemigrations
+   python manage.py migrate
+   ```
+
+### 扩展API接口
+
+1. 在 `backend/mindmap/views_doc.py` 中编写视图函数
+2. 在 `backend/mindmap/serializers.py` 中定义序列化器
+3. 在 `backend/mindmap/urls.py` 中添加URL路由
+
+### 自定义AI服务
+
+修改 `backend/mindmap/ai_service.py` 中的AI处理逻辑：
+
+```python
+def call_ai_api(system_prompt, user_prompt, model="glm-4.5", base_url="...", api_key="..."):
+    # 自定义AI服务调用逻辑
+    pass
+```
+
+### 前端组件开发
+
+1. 在 `frontend/src/components/` 中创建Vue组件
+2. 在 `frontend/src/api/` 中添加API接口
+3. 使用Vite进行热重载开发
+
+### 数据格式规范
+
+系统使用MindElixir数据格式：
+
+```json
+{
+  "nodeData": {
+    "id": "root",
+    "topic": "根节点标题",
+    "data": {
+      "des": "节点描述"
+    },
+    "children": [
+      {
+        "id": "child-1",
+        "topic": "子节点标题",
+        "data": {
+          "des": "子节点描述"
+        },
+        "children": []
+      }
+    ]
+  }
+}
+```
+
+## 🚀 部署指南
+
+### 生产环境配置
+
+1. **环境变量设置**：
+   ```bash
+   export DEBUG=False
+   export SECRET_KEY="your-secret-key"
+   export DATABASE_URL="postgresql://user:pass@localhost/db"
+   ```
+
+2. **静态文件收集**：
+   ```bash
+   cd backend
+   python manage.py collectstatic --noinput
+   ```
+
+3. **数据库迁移**：
+   ```bash
+   cd backend
+   python manage.py migrate
+   ```
+
+4. **前端构建**：
+   ```bash
+   cd frontend
+   npm run build
+   ```
+
+### Docker部署
+
+#### 后端Dockerfile
+```dockerfile
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY backend/requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY backend/ .
+RUN python manage.py collectstatic --noinput
+
+EXPOSE 8000
+CMD ["gunicorn", "django_mindmap.wsgi:application", "--bind", "0.0.0.0:8000"]
+```
+
+#### 前端Dockerfile
+```dockerfile
+FROM node:18-alpine
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+RUN npm run build
+
+EXPOSE 5173
+CMD ["npm", "run", "preview"]
+```
+
+### Nginx配置
+
+```nginx
+server {
+    listen 80;
+    server_name your-domain.com;
+
+    location / {
+        proxy_pass http://localhost:5173;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+
+    location /api/ {
+        proxy_pass http://localhost:8000;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
+```
+
+## 📝 使用说明
+
+### 基本操作流程
+
+1. **上传文档**：在AI侧边栏中上传DOCX、PDF、TXT或MD文件
+2. **AI分析**：系统自动调用AI服务分析文档结构
+3. **生成思维导图**：AI将文档转换为结构化的思维导图
+4. **编辑调整**：在可视化界面中拖拽、编辑节点
+5. **保存分享**：思维导图自动保存到数据库
+
+### 快捷键操作
+
+- `Ctrl + 滚轮`：缩放思维导图
+- `双击节点`：编辑节点内容
+- `右键节点`：显示操作菜单
+- `拖拽节点`：移动节点位置
+
+## 🤝 贡献指南
+
+欢迎贡献代码！请遵循以下步骤：
+
+1. Fork 项目
+2. 创建功能分支：`git checkout -b feature/new-feature`
+3. 提交更改：`git commit -am 'Add new feature'`
+4. 推送分支：`git push origin feature/new-feature`
+5. 提交Pull Request
+
+## 📄 许可证
+
+MIT License - 详见 [LICENSE](LICENSE) 文件
+
+## 🙏 致谢
+
+- [MindElixir](https://github.com/ssshooter/mind-elixir-core) - 思维导图可视化库
+- [Vue.js](https://vuejs.org/) - 前端框架
+- [Django](https://www.djangoproject.com/) - 后端框架
+- [智谱AI](https://www.zhipuai.cn/) - AI服务支持
--- a/backend/django_mindmap/init.py
+++ b/backend/django_mindmap/init.py
@ -0,0 +1 @@
+# Django项目初始化文件
--- a/backend/django_mindmap/asgi.py
+++ b/backend/django_mindmap/asgi.py
@ -0,0 +1,5 @@
+import os
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'django_mindmap.settings')
+application = get_asgi_application()
--- a/backend/django_mindmap/settings.py
+++ b/backend/django_mindmap/settings.py
@ -0,0 +1,123 @@
+import os
+from pathlib import Path
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = 'django-insecure-your-secret-key-here'
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = ['*']
+
+# Application definition
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'rest_framework',
+    'corsheaders',
+    'mindmap',
+]
+
+MIDDLEWARE = [
+    'corsheaders.middleware.CorsMiddleware',
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'django_mindmap.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [BASE_DIR / 'templates'],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'django_mindmap.wsgi.application'
+
+# Database
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'mindmap.db',
+    }
+}
+
+# Password validation
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+    },
+]
+
+# Internationalization
+LANGUAGE_CODE = 'zh-hans'
+TIME_ZONE = 'Asia/Shanghai'
+USE_I18N = True
+USE_TZ = True
+
+# Static files (CSS, JavaScript, Images)
+STATIC_URL = '/static/'
+STATIC_ROOT = BASE_DIR / 'staticfiles'
+STATICFILES_DIRS = [
+    BASE_DIR / 'static',
+]
+
+# Media files
+MEDIA_URL = '/media/'
+MEDIA_ROOT = BASE_DIR / 'media'
+
+# Default primary key field type
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
+
+# CORS settings
+CORS_ALLOW_ALL_ORIGINS = True
+CORS_ALLOW_CREDENTIALS = True
+
+# REST Framework settings
+REST_FRAMEWORK = {
+    'DEFAULT_RENDERER_CLASSES': [
+        'rest_framework.renderers.JSONRenderer',
+    ],
+    'DEFAULT_PARSER_CLASSES': [
+        'rest_framework.parsers.JSONParser',
+        'rest_framework.parsers.MultiPartParser',
+        'rest_framework.parsers.FormParser',
+    ],
+    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
+    'PAGE_SIZE': 100,
+}
+
+# File upload settings
+MAX_UPLOAD_SIZE = 16 * 1024 * 1024  # 16MB
+ALLOWED_FILE_TYPES = ['.docx', '.pdf', '.txt', '.md']
--- a/backend/django_mindmap/urls.py
+++ b/backend/django_mindmap/urls.py
@ -0,0 +1,9 @@
+from django.contrib import admin
+from django.urls import path, include
+from django.conf import settings
+from django.conf.urls.static import static
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('api/', include('mindmap.urls')),
+] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
--- a/backend/django_mindmap/wsgi.py
+++ b/backend/django_mindmap/wsgi.py
@ -0,0 +1,5 @@
+import os
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'django_mindmap.settings')
+application = get_wsgi_application()
--- a/backend/manage.py
+++ b/backend/manage.py
@ -0,0 +1,21 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'django_mindmap.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+if __name__ == '__main__':
+    main()
+
--- a/backend/mindmap.db
+++ b/backend/mindmap.db
--- a/backend/mindmap/init.py
+++ b/backend/mindmap/init.py
@ -0,0 +1 @@
+# Django应用初始化文件
--- a/backend/mindmap/admin.py
+++ b/backend/mindmap/admin.py
@ -0,0 +1,16 @@
+from django.contrib import admin
+from .models import mindMap, Node
+
+@admin.register(mindMap)
+class mindMapAdmin(admin.ModelAdmin):
+    list_display = ['id', 'file_name', 'created_at', 'updated_at', 'deleted']
+    list_filter = ['deleted', 'created_at']
+    search_fields = ['file_name']
+    readonly_fields = ['created_at', 'updated_at']
+
+@admin.register(Node)
+class NodeAdmin(admin.ModelAdmin):
+    list_display = ['id', 'title', 'mindmap', 'is_root', 'parent_id', 'depth', 'created_at', 'deleted']
+    list_filter = ['is_root', 'deleted', 'created_at']
+    search_fields = ['title', 'desc', 'parent_id']
+    readonly_fields = ['created_at', 'updated_at']
--- a/backend/mindmap/ai_service.py
+++ b/backend/mindmap/ai_service.py
@ -0,0 +1,159 @@
+import re
+import traceback
+import json
+
+def call_ai_api(system_prompt, user_prompt, model="glm-4.5", base_url="https://open.bigmodel.cn/api/paas/v4/", api_key="ce39bdd4fcf34ec0aec75072bc9ff988.hAp7HZTVUwy7vImn"):
+    """
+    调用AI API生成Markdown
+    """
+    try:
+        # 尝试导入OpenAI客户端
+        try:
+            from openai import OpenAI
+        except ImportError:
+            print("OpenAI库未安装，返回模拟数据")
+            return f"""# {user_prompt}
+
+## 概述
+{user_prompt}是一个重要的概念和领域。
+
+## 核心要素
+- 要素1
+- 要素2
+- 要素3
+
+## 应用场景
+- 场景1
+- 场景2
+- 场景3
+
+## 发展趋势
+- 趋势1
+- 趋势2
+- 趋势3"""
+        
+        # 构建消息
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
+        
+        print(f"发送AI API请求到: {base_url}")
+        print(f"模型: {model}")
+        
+        # 创建OpenAI客户端
+        client = OpenAI(api_key=api_key, base_url=base_url)
+        
+        # 使用非流式调用，更简单可靠
+        try:
+            response = client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=0.7,
+                max_tokens=2000,
+                stream=False
+            )
+        except Exception as e:
+            print(f"API调用失败: {e}")
+            # 如果API调用失败，抛出异常而不是返回模拟数据
+            raise Exception(f"AI API调用失败: {e}")
+        
+        # 获取响应内容
+        content = response.choices[0].message.content
+        print(f"AI原始响应: {content}")
+        
+        # 处理可能的JSON格式响应
+        try:
+            # 尝试解析为JSON
+            json_data = json.loads(content)
+            if 'answer' in json_data:
+                content = json_data['answer']
+                print(f"从JSON中提取answer: {content[:100]}...")
+            elif 'content' in json_data:
+                content = json_data['content']
+                print(f"从JSON中提取content: {content[:100]}...")
+            elif 'markdown' in json_data:
+                content = json_data['markdown']
+                print(f"从JSON中提取markdown: {content[:100]}...")
+        except json.JSONDecodeError:
+            # 不是JSON格式，直接使用内容
+            print("响应不是JSON格式，直接使用内容")
+        
+        # 清理内容
+        content = content.strip()
+        
+        # 如果返回的内容包含代码块标记，提取其中的内容
+        markdown_match = re.search(r"```(?:markdown)?\n(.*?)```", content, re.DOTALL)
+        if markdown_match:
+            content = markdown_match.group(1).strip()
+        
+        # 如果内容为空，返回模拟数据
+        if not content:
+            print("AI返回内容为空，使用模拟数据")
+            return f"""# {user_prompt}
+
+## 概述
+{user_prompt}是一个重要的概念和领域。
+
+## 核心要素
+- 要素1
+- 要素2
+- 要素3
+
+## 应用场景
+- 场景1
+- 场景2
+- 场景3
+
+## 发展趋势
+- 趋势1
+- 趋势2
+- 趋势3"""
+        
+        return content
+            
+    except Exception as e:
+        print(f"AI API调用异常: {e}")
+        traceback.print_exc()
+        return None
+
+
+def generate_markdown_from_text(text):
+    """
+    从文本生成Markdown的便捷函数
+    """
+    system_prompt = """你是一位Markdown格式转换专家。你的任务是将用户提供的文章内容精确转换为结构化的Markdown格式。请遵循以下步骤：
+
+提取主标题： 识别文章最顶层的主标题（通常为文章题目或书名），并使用Markdown的 # 级别表示。
+
+识别层级标题： 从文章内容中提取所有层级的内容标题（从主标题后的第一个标题开始，Level 1 至 Level 4）。判断层级依据：
+
+视觉与结构特征： 如独立成行/段、位置（行首）、格式（加粗、编号如 1., 1.1, (1), - 等）。
+
+语义逻辑： 标题之间的包含和并列关系。
+
+在Markdown中，使用相应标题级别：
+
+Level 1 标题用 ##
+
+Level 2 标题用 ###
+
+Level 3 标题用 ####
+
+Level 4 标题用 #####
+
+精确保留原文标题文字，不得修改、概括或润色。
+
+处理正文内容： 对于每个标题下的正文内容区块（从该标题后开始，直到下一个同级或更高级别标题前）：
+
+直接保留原文文本，但根据内容结构适当格式化为Markdown。
+
+如果内容是列表（如项目符号或编号列表），使用Markdown列表语法（例如 - 用于无序列表，1. 用于有序列表）。
+
+保持段落和换行不变。
+
+输出格式： 输出必须是纯Markdown格式的文本，不得包含任何额外说明、JSON或非Markdown元素。确保输出与示例风格一致。"""
+
+    user_prompt = f"请将以下内容转换为结构化的Markdown格式：\n\n{text}"
+    
+    return call_ai_api(system_prompt, user_prompt)
--- a/backend/mindmap/apps.py
+++ b/backend/mindmap/apps.py
@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+class MindmapConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'mindmap'
+    verbose_name = '思维导图管理'
+
--- a/backend/mindmap/migrations/0001_initial.py
+++ b/backend/mindmap/migrations/0001_initial.py
@ -0,0 +1,50 @@
+# Generated by Django 4.2.7 on 2025-08-27 08:37
+
+from django.db import migrations, models
+import django.db.models.deletion
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Mindmap',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('file_name', models.CharField(default='思维导图', max_length=255)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('deleted', models.BooleanField(default=False)),
+            ],
+            options={
+                'db_table': 'mindmaps',
+                'ordering': ['-created_at'],
+            },
+        ),
+        migrations.CreateModel(
+            name='MindmapNode',
+            fields=[
+                ('id', models.CharField(default=uuid.uuid4, max_length=255, primary_key=True, serialize=False)),
+                ('is_root', models.BooleanField(default=False)),
+                ('parent_id', models.CharField(blank=True, max_length=255, null=True)),
+                ('children_count', models.IntegerField(default=0)),
+                ('depth', models.IntegerField(default=0)),
+                ('title', models.CharField(blank=True, default='', max_length=500)),
+                ('desc', models.TextField(blank=True, default='')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('deleted', models.BooleanField(default=False)),
+                ('mindmap', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='nodes', to='mindmap.mindmap')),
+            ],
+            options={
+                'db_table': 'nodes',
+                'ordering': ['created_at'],
+            },
+        ),
+    ]
--- a/backend/mindmap/migrations/0002_rename_mindmapnode_node.py
+++ b/backend/mindmap/migrations/0002_rename_mindmapnode_node.py
@ -0,0 +1,17 @@
+# Generated by Django 4.2.7 on 2025-08-27 09:21
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('mindmap', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RenameModel(
+            old_name='MindmapNode',
+            new_name='Node',
+        ),
+    ]
--- a/backend/mindmap/migrations/init.py
+++ b/backend/mindmap/migrations/init.py
--- a/backend/mindmap/models.py
+++ b/backend/mindmap/models.py
@ -0,0 +1,49 @@
+from django.db import models
+import uuid
+
+
+class mindMap(models.Model):
+    """思维导图（最小字段，按接口文档）"""
+    file_name = models.CharField(max_length=255, default='思维导图')  # title
+    created_at = models.DateTimeField(auto_now_add=True)              # createDate
+    updated_at = models.DateTimeField(auto_now=True)                  # updateDate
+    deleted = models.BooleanField(default=False)                      # delete
+
+    class Meta:
+        db_table = 'mindmaps'
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f"{self.file_name}"
+
+
+class Node(models.Model):
+    """节点（最小字段，按接口文档）"""
+    id = models.CharField(max_length=255, primary_key=True, default=uuid.uuid4)
+    mindmap = models.ForeignKey(mindMap, on_delete=models.CASCADE, related_name='nodes')
+
+    is_root = models.BooleanField(default=False)                      # isRoot
+    parent_id = models.CharField(max_length=255, null=True, blank=True)  # parentId
+    children_count = models.IntegerField(default=0)                   # childrenCount
+    depth = models.IntegerField(default=0)                            # depth
+    title = models.CharField(max_length=500, blank=True, default='')  # title
+    desc = models.TextField(blank=True, default='')                   # des
+    created_at = models.DateTimeField(auto_now_add=True)              # createDate
+    updated_at = models.DateTimeField(auto_now=True)                  # updateDate
+    deleted = models.BooleanField(default=False)                      # delete
+
+    class Meta:
+        db_table = 'nodes'
+        ordering = ['created_at']
+
+
+
+
+
+
+
+
+
+
+
+
--- a/backend/mindmap/serializers.py
+++ b/backend/mindmap/serializers.py
@ -0,0 +1,50 @@
+from rest_framework import serializers
+from .models import mindMap, Node
+
+
+class DocNodeSerializer(serializers.Serializer):
+    id = serializers.CharField()
+    isRoot = serializers.BooleanField()
+    parentId = serializers.CharField(allow_null=True)
+    childrenCount = serializers.IntegerField()
+    depth = serializers.IntegerField()
+    title = serializers.CharField(allow_blank=True, required=False)
+    des = serializers.CharField(allow_blank=True, required=False)
+    createDate = serializers.DateTimeField()
+    updateDate = serializers.DateTimeField()
+    delete = serializers.BooleanField()
+
+
+class DocMindmapSerializer(serializers.Serializer):
+    id = serializers.CharField()
+    title = serializers.CharField()
+    nodes = DocNodeSerializer(many=True)
+    createDate = serializers.DateTimeField()
+    updateDate = serializers.DateTimeField()
+    delete = serializers.BooleanField()
+
+
+def map_node_to_doc(node: Node) -> dict:
+    return {
+        'id': str(node.id),
+        'isRoot': bool(node.is_root),
+        'parentId': node.parent_id,
+        'childrenCount': int(node.children_count or 0),
+        'depth': int(node.depth or 0),
+        'title': node.title or '',
+        'des': (node.desc or ''),
+        'createDate': node.created_at,
+        'updateDate': node.updated_at,
+        'delete': bool(node.deleted),
+    }
+
+
+def map_mindmap_to_doc(m: mindMap, nodes: list[Node]) -> dict:
+    return {
+        'id': str(m.id),
+        'title': m.file_name or '思维导图',
+        'nodes': [map_node_to_doc(n) for n in nodes],
+        'createDate': m.created_at,
+        'updateDate': m.updated_at,
+        'delete': bool(m.deleted),
+    }
--- a/backend/mindmap/services.py
+++ b/backend/mindmap/services.py
@ -0,0 +1,3 @@
+
+
+
--- a/backend/mindmap/urls.py
+++ b/backend/mindmap/urls.py
@ -0,0 +1,14 @@
+from django.urls import path
+from . import views_doc
+
+urlpatterns = [
+    # MindMap 接口（按文档，仅保留涉及的功能）
+    path('mindMaps/<int:id>', views_doc.get_mindmap),
+    path('mindMaps', views_doc.create_mindmap),
+    path('mindMaps/addNodes', views_doc.add_nodes),
+    path('mindMaps/updateNode', views_doc.update_node),
+    path('mindMaps/deleteNodes', views_doc.delete_nodes),
+    
+    # AI接口
+    path('ai/generate-markdown', views_doc.generate_markdown),
+]
--- a/backend/mindmap/views_doc.py
+++ b/backend/mindmap/views_doc.py
@ -0,0 +1,470 @@
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from rest_framework import status
+from django.db import transaction
+from django.utils import timezone
+
+from .models import mindMap, Node
+from .serializers import map_mindmap_to_doc, map_node_to_doc
+
+
+@api_view(['GET'])
+def get_mindmap(request, id):
+    try:
+        m = mindMap.objects.get(id=id, deleted=False)
+    except mindMap.DoesNotExist:
+        return Response({'detail': 'mindMap not found'}, status=404)
+
+    # 获取所有节点，包括被删除的节点
+    nodes = Node.objects.filter(mindmap=m, deleted=False).order_by('created_at')
+    
+    # 转换为MindElixir期望的树形结构
+    mindelixir_data = convert_to_mindelixir_format(m, list(nodes))
+    return Response(mindelixir_data)
+
+
+def convert_to_mindelixir_format(mindmap, nodes):
+    """将扁平节点列表转换为MindElixir期望的树形结构"""
+    if not nodes:
+        return {
+            "nodeData": {
+                "id": "root",
+                "topic": "根节点",
+                "children": []
+            }
+        }
+    
+    # 创建节点映射
+    node_map = {}
+    for node in nodes:
+        node_map[str(node.id)] = {
+            "id": str(node.id),
+            "topic": node.title or "无标题",
+            "data": {
+                "des": node.desc or ""
+            },
+            "children": [],
+            # 添加思维导图ID到节点
+            "mindmapId": mindmap.id,
+            "mindmap_id": mindmap.id
+        }
+    
+    # 构建树形结构
+    root_nodes = []
+    for node in nodes:
+        mindelixir_node = node_map[str(node.id)]
+        
+        if node.parent_id and str(node.parent_id) in node_map:
+            # 有父节点，添加到父节点的children中
+            parent = node_map[str(node.parent_id)]
+            parent["children"].append(mindelixir_node)
+        else:
+            # 没有父节点，作为根节点
+            # 过滤掉空的根节点（标题为"根节点标题"且没有子节点的节点）
+            if not (node.title == "根节点标题" and node.children_count == 0):
+                root_nodes.append(mindelixir_node)
+    
+    # 如果只有一个根节点，直接返回它
+    if len(root_nodes) == 1:
+        return {"nodeData": root_nodes[0]}
+    elif len(root_nodes) > 1:
+        # 如果有多个根节点，创建一个虚拟根节点
+        return {
+            "nodeData": {
+                "id": "root",
+                "topic": mindmap.file_name or "思维导图",
+                "children": root_nodes
+            }
+        }
+    else:
+        # 没有节点，返回默认根节点
+        return {
+            "nodeData": {
+                "id": "root",
+                "topic": "根节点",
+                "children": []
+            }
+        }
+
+
+# @api_view(['POST'])
+# @transaction.atomic
+# def create_mindmap(request):
+#     title = (request.data or {}).get('title') or '思维导图'
+#     m = mindMap.objects.create(file_name=title)
+#     root = Node.objects.create(
+#         mindmap=m,
+#         title='根节点标题',
+#         desc='',
+#         is_root=True,
+#         parent_id=None,
+#         children_count=0,
+#         depth=0,
+#         deleted=False,
+#     )
+#     # 使用新的MindElixir格式
+#     mindelixir_data = convert_to_mindelixir_format(m, [root])
+#     return Response(mindelixir_data, status=201)
+# @api_view(['POST'])
+# @transaction.atomic
+# def create_mindmap(request):
+#     title = (request.data or {}).get('title') or '思维导图'
+#     m = mindMap.objects.create(file_name=title)
+#     root = Node.objects.create(
+#         mindmap=m,
+#         title='根节点标题',
+#         desc='',
+#         is_root=True,
+#         parent_id=None,
+#         children_count=0,
+#         depth=0,
+#         deleted=False,
+#     )
+    
+#     # 使用新的MindElixir格式
+#     mindelixir_data = convert_to_mindelixir_format(m, [root])
+    
+#     # 在返回数据中添加ID
+#     if isinstance(mindelixir_data, dict):
+#         mindelixir_data['id'] = m.id
+#         mindelixir_data['title'] = m.file_name
+#     else:
+#         mindelixir_data = {
+#             'id': m.id,
+#             'title': m.file_name,
+#             'nodeData': mindelixir_data
+#         }
+    
+#     return Response(mindelixir_data, status=201)
+
+@api_view(['POST'])
+@transaction.atomic
+def create_mindmap(request):
+    title = (request.data or {}).get('title') or '思维导图'
+    m = mindMap.objects.create(file_name=title)
+    
+    # 获取传入的思维导图数据
+    mindmap_data = request.data.get('data')
+    
+    if mindmap_data and isinstance(mindmap_data, dict):
+        # 创建根节点
+        root = Node.objects.create(
+            mindmap=m,
+            title=mindmap_data.get('topic', '根节点'),
+            desc=mindmap_data.get('des', ''),
+            is_root=True,
+            parent_id=None,
+            children_count=0,
+            depth=0,
+            deleted=False,
+        )
+        
+        # 递归创建所有子节点
+        if mindmap_data.get('children'):
+            create_nodes_recursively(mindmap_data['children'], m, root.id)
+            
+            # 更新根节点的children_count
+            root.children_count = Node.objects.filter(parent_id=root.id, deleted=False).count()
+            root.save()
+        
+    else:
+        # 创建空根节点
+        root = Node.objects.create(
+            mindmap=m,
+            title='根节点标题',
+            desc='',
+            is_root=True,
+            parent_id=None,
+            children_count=0,
+            depth=0,
+            deleted=False,
+        )
+    
+    # 返回完整数据
+    mindelixir_data = convert_to_mindelixir_format(m, [root])
+    response_data = {
+        'id': m.id,
+        'title': m.file_name,
+        'nodeData': mindelixir_data.get('nodeData', mindelixir_data)
+    }
+    
+    return Response(response_data, status=201)
+
+def create_nodes_recursively(nodes_data, mindmap, parent_id):
+    """递归创建节点"""
+    for node_data in nodes_data:
+        # 创建当前节点
+        node = Node.objects.create(
+            mindmap=mindmap,
+            title=node_data.get('topic', '节点'),
+            desc=node_data.get('des', ''),
+            is_root=False,
+            parent_id=parent_id,
+            children_count=len(node_data.get('children', [])),
+            depth=1,  # 可以根据实际层级计算
+            deleted=False,
+        )
+        
+        # 递归创建子节点
+        if node_data.get('children'):
+            create_nodes_recursively(node_data['children'], mindmap, node.id)
+        
+        # 更新父节点的children_count
+        if parent_id:
+            try:
+                parent = Node.objects.get(id=parent_id, deleted=False)
+                parent.children_count = Node.objects.filter(parent_id=parent_id, deleted=False).count()
+                parent.save()
+            except Node.DoesNotExist:
+                pass
+
+@api_view(['POST'])
+@transaction.atomic
+def add_nodes(request):
+    data = request.data or {}
+    mindmap_id = data.get('mindMapId')
+    nodes_payload = data.get('nodes', [])
+
+    if not mindmap_id:
+        return Response({'detail': 'mindMapId is required'}, status=400)
+
+    try:
+        # 确保mindMapId是整数
+        mindmap_id = int(mindmap_id)
+        m = mindMap.objects.get(id=mindmap_id, deleted=False)
+    except (ValueError, TypeError):
+        return Response({'detail': 'mindMapId must be a valid integer'}, status=400)
+    except mindMap.DoesNotExist:
+        return Response({'detail': 'mindMap not found'}, status=404)
+
+    # 处理单个节点或节点数组
+    if isinstance(nodes_payload, dict):
+        # 单个节点对象
+        nodes_payload = [nodes_payload]
+    elif not isinstance(nodes_payload, list):
+        return Response({'detail': 'nodes must be an object or array'}, status=400)
+
+    created_nodes = []
+    for n in nodes_payload:
+        if not isinstance(n, dict):
+            return Response({'detail': 'each node must be an object'}, status=400)
+        
+        # 计算深度
+        depth = 0
+        parent_id = n.get('parentId')
+        if parent_id and not bool(n.get('isRoot', False)):
+            try:
+                parent_node = Node.objects.get(id=parent_id, deleted=False, mindmap=m)
+                depth = parent_node.depth + 1
+            except Node.DoesNotExist:
+                return Response({'detail': f'parent node {parent_id} not found'}, status=404)
+            
+        node = Node.objects.create(
+            mindmap=m,
+            title=n.get('title') or '',
+            desc=n.get('des') or '',
+            is_root=bool(n.get('isRoot', False)),
+            parent_id=parent_id,
+            children_count=0,  # 新节点初始子节点数为0
+            depth=depth,
+            deleted=False,
+        )
+        
+        # 更新父节点的子节点计数
+        if node.parent_id and not node.is_root:
+            try:
+                parent_node = Node.objects.get(id=node.parent_id, deleted=False, mindmap=m)
+                parent_node.children_count += 1
+                parent_node.save()
+            except Node.DoesNotExist:
+                pass  # 父节点可能已被删除
+        
+        created_nodes.append(node)
+
+    resp_nodes = [map_node_to_doc(x) for x in created_nodes]
+    return Response({
+        'success': True,
+        'message': f'成功创建 {len(created_nodes)} 个节点',
+        'data': {
+            'mindMapId': str(m.id),
+            'nodes': resp_nodes
+        }
+    })
+
+
+@api_view(['PATCH'])
+@transaction.atomic
+def update_node(request):
+    body = request.data or {}
+    node_id = body.get('id')
+    
+    if not node_id:
+        return Response({'detail': 'id is required'}, status=400)
+
+    try:
+        node = Node.objects.get(id=node_id, deleted=False)
+    except Node.DoesNotExist:
+        return Response({'detail': 'node not found'}, status=404)
+
+    # 记录更新了哪些字段
+    updated_fields = []
+    
+    if 'newTitle' in body:
+        node.title = body.get('newTitle') or ''
+        updated_fields.append('title')
+        
+    if 'newDes' in body:
+        node.desc = body.get('newDes') or ''
+        updated_fields.append('des')
+        
+    if 'newParentId' in body:
+        new_parent_id = body.get('newParentId')
+        old_parent_id = node.parent_id
+        
+        # 验证父节点是否存在（如果提供了父节点ID）
+        if new_parent_id:
+            try:
+                parent_node = Node.objects.get(id=new_parent_id, deleted=False, mindmap=node.mindmap)
+                # 更新父节点ID和深度
+                node.parent_id = new_parent_id
+                node.depth = parent_node.depth + 1
+                updated_fields.extend(['parentId', 'depth'])
+                
+                # 更新新父节点的子节点计数
+                parent_node.children_count += 1
+                parent_node.save()
+                
+            except Node.DoesNotExist:
+                return Response({'detail': 'parent node not found'}, status=404)
+        else:
+            # 如果newParentId为null，表示设置为根节点
+            node.parent_id = None
+            node.depth = 0
+            updated_fields.extend(['parentId', 'depth'])
+        
+        # 更新原父节点的子节点计数（如果存在且不是同一个父节点）
+        if old_parent_id and old_parent_id != new_parent_id:
+            try:
+                old_parent = Node.objects.get(id=old_parent_id, deleted=False, mindmap=node.mindmap)
+                old_parent.children_count = max(0, old_parent.children_count - 1)
+                old_parent.save()
+            except Node.DoesNotExist:
+                pass  # 原父节点可能已被删除
+
+    # 只有在有字段更新时才更新时间戳
+    if updated_fields:
+        node.updated_at = timezone.now()
+        node.save()
+
+    return Response({
+        'success': True,
+        'message': '节点更新成功',
+        'data': map_node_to_doc(node),
+        'updatedFields': updated_fields
+    })
+
+
+def _collect_subtree_ids(mindmap_id: int, start_ids: list[str]) -> set[str]:
+    ids = set(start_ids)
+    queue = list(start_ids)
+    while queue:
+        children = Node.objects.filter(
+            mindmap_id=mindmap_id,
+            parent_id__in=queue,
+            deleted=False
+        ).values_list('id', flat=True)
+        new = [str(c) for c in children if str(c) not in ids]
+        if not new:
+            break
+        ids.update(new)
+        queue = new
+    return ids
+
+
+@api_view(['DELETE'])
+@transaction.atomic
+def delete_nodes(request):
+    body = request.data or {}
+    node_ids = body.get('nodeIds', [])
+    if not node_ids:
+        return Response({'detail': 'nodeIds is required'}, status=400)
+
+    first = Node.objects.filter(id__in=node_ids, deleted=False).first()
+    if not first:
+        return Response({'success': True, 'message': '无可删除节点', 'data': {'deletedCount': 0, 'deletedNodeIds': []}})
+
+    # 收集所有要删除的节点ID（包括子树）
+    all_ids = _collect_subtree_ids(first.mindmap_id, [str(x) for x in node_ids])
+    
+    # 获取要删除的节点，用于更新父节点的childrenCount
+    nodes_to_delete = Node.objects.filter(id__in=list(all_ids), deleted=False)
+    
+    # 更新父节点的childrenCount
+    parent_updates = {}
+    for node in nodes_to_delete:
+        if node.parent_id:
+            if node.parent_id not in parent_updates:
+                parent_updates[node.parent_id] = 0
+            parent_updates[node.parent_id] += 1
+    
+    # 批量更新父节点的childrenCount
+    for parent_id, count_reduction in parent_updates.items():
+        try:
+            parent = Node.objects.get(id=parent_id, deleted=False)
+            parent.children_count = max(0, parent.children_count - count_reduction)
+            parent.save()
+        except Node.DoesNotExist:
+            pass  # 父节点可能已被删除
+    
+    # 软删除节点
+    updated = Node.objects.filter(id__in=list(all_ids)).update(deleted=True, updated_at=timezone.now())
+
+    return Response({
+        'success': True,
+        'message': '节点删除成功',
+        'data': {
+            'deletedCount': int(updated),
+            'deletedNodeIds': list(all_ids)
+        }
+    })
+
+
+@api_view(['POST'])
+def generate_markdown(request):
+    """AI生成Markdown接口"""
+    try:
+        data = request.data
+        system_prompt = data.get('system_prompt', '')
+        user_prompt = data.get('user_prompt', '')
+        model = data.get('model', 'glm-4.5')
+        base_url = data.get('base_url', 'https://open.bigmodel.cn/api/paas/v4/')
+        api_key = data.get('api_key', '')
+        
+        if not user_prompt:
+            return Response({'error': '用户提示词不能为空'}, status=400)
+        
+        # 导入AI服务
+        from .ai_service import call_ai_api
+        
+        # 调用AI API
+        markdown_content = call_ai_api(system_prompt, user_prompt, model, base_url, api_key)
+        
+        if markdown_content:
+            return Response({
+                'markdown': markdown_content,
+                'success': True
+            })
+        else:
+            # 如果AI API调用失败，返回错误信息
+            return Response({
+                'error': 'AI API调用失败',
+                'success': False
+            }, status=500)
+        
+    except Exception as e:
+        return Response({
+            'error': str(e),
+            'success': False
+        }, status=500)
+
+
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@ -0,0 +1,9 @@
+Django==4.2.7
+djangorestframework==3.14.0
+django-cors-headers==4.3.1
+python-docx==0.8.11
+PyPDF2==3.0.1
+markdown==3.5.1
+python-multipart==0.0.6
+requests==2.31.0
+openai==1.3.0
--- a/backend/static/.gitkeep
+++ b/backend/static/.gitkeep
@ -0,0 +1 @@
+# This file ensures the static directory is tracked by git
--- a/frontend/.vite/deps_temp_442209d7/package.json
+++ b/frontend/.vite/deps_temp_442209d7/package.json
@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
--- a/frontend/README.md
+++ b/frontend/README.md
@ -0,0 +1,85 @@
+# 思维导图前端应用
+
+基于 Vue 3 + Mind Elixir 的思维导图前端应用，与 Django 后端 API 集成。
+
+## 功能特性
+
+- ✅ 创建新思维导图
+- ✅ 加载现有思维导图
+- ✅ 添加子节点
+- ✅ 添加兄弟节点
+- ✅ 编辑节点（标题和描述）
+- ✅ 删除节点（软删除）
+- ✅ 拖拽操作
+- ✅ 实时数据同步
+
+## 技术栈
+
+- **Vue 3** - 前端框架
+- **Mind Elixir 3.x** - 思维导图核心库
+- **Axios** - HTTP 客户端
+- **Vite** - 构建工具
+
+## 安装和运行
+
+### 1. 安装依赖
+
+```bash
+cd frontend
+npm install
+```
+
+### 2. 启动开发服务器
+
+```bash
+npm run dev
+```
+
+应用将在 `http://localhost:3000` 启动。
+
+### 3. 构建生产版本
+
+```bash
+npm run build
+```
+
+## API 集成
+
+前端通过以下 API 与后端通信：
+
+- `POST /api/mindMaps` - 创建思维导图
+- `GET /api/mindMaps/{id}` - 获取思维导图
+- `POST /api/mindMaps/addNodes` - 添加节点
+- `PATCH /api/mindMaps/updateNode` - 更新节点
+- `DELETE /api/mindMaps/deleteNodes` - 删除节点
+
+## 使用说明
+
+1. **创建思维导图**: 点击"新建思维导图"按钮
+2. **加载思维导图**: 点击"加载思维导图"并输入ID
+3. **添加节点**: 选中节点后点击"添加子节点"或"添加兄弟节点"
+4. **编辑节点**: 双击节点或右键选择编辑
+5. **删除节点**: 选中节点后点击"删除节点"
+
+## 项目结构
+
+```
+frontend/
+├── src/
+│   ├── api/
+│   │   └── mindmap.js      # API 接口
+│   ├── components/
+│   │   └── MindMap.vue     # 思维导图组件
+│   ├── App.vue             # 主应用组件
+│   └── main.js             # 应用入口
+├── index.html              # HTML 模板
+├── package.json            # 项目配置
+├── vite.config.js          # Vite 配置
+└── README.md               # 项目说明
+```
+
+## 注意事项
+
+- 确保后端 Django 服务器在 `http://localhost:8000` 运行
+- 前端通过代理访问后端 API，避免跨域问题
+- 所有操作都会实时同步到后端数据库
--- a/frontend/dist/assets/index-32a026a7.js
+++ b/frontend/dist/assets/index-32a026a7.js
--- a/frontend/dist/assets/index-44efe7b9.css
+++ b/frontend/dist/assets/index-44efe7b9.css
--- a/frontend/dist/assets/index-d6c20d61.js
+++ b/frontend/dist/assets/index-d6c20d61.js
--- a/frontend/dist/assets/pdf-1d729f32.js
+++ b/frontend/dist/assets/pdf-1d729f32.js
--- a/frontend/dist/index.html
+++ b/frontend/dist/index.html
@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>思维导图</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+      
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+        background: #f5f5f5;
+      }
+      
+      #app {
+        height: 100vh;
+        display: flex;
+        flex-direction: column;
+      }
+    </style>
+    <script type="module" crossorigin src="/assets/index-d6c20d61.js"></script>
+    <link rel="stylesheet" href="/assets/index-44efe7b9.css">
+  </head>
+  <body>
+    <div id="app"></div>
+    
+  </body>
+</html>
--- a/frontend/dist/pdf.worker.min.mjs
+++ b/frontend/dist/pdf.worker.min.mjs
--- a/frontend/index.html
+++ b/frontend/index.html
@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>思维导图</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+      
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+        background: #f5f5f5;
+      }
+      
+      #app {
+        height: 100vh;
+        display: flex;
+        flex-direction: column;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>
--- a/frontend/node_modules/.bin/esbuild
+++ b/frontend/node_modules/.bin/esbuild
@ -0,0 +1 @@
+../esbuild/bin/esbuild
--- a/frontend/node_modules/.bin/mammoth
+++ b/frontend/node_modules/.bin/mammoth
@ -0,0 +1 @@
+../mammoth/bin/mammoth
--- a/frontend/node_modules/.bin/marked
+++ b/frontend/node_modules/.bin/marked
@ -0,0 +1 @@
+../marked/bin/marked.js
--- a/frontend/node_modules/.bin/nanoid
+++ b/frontend/node_modules/.bin/nanoid
@ -0,0 +1 @@
+../nanoid/bin/nanoid.cjs
--- a/frontend/node_modules/.bin/parser
+++ b/frontend/node_modules/.bin/parser
@ -0,0 +1 @@
+../@babel/parser/bin/babel-parser.js
--- a/frontend/node_modules/.bin/rollup
+++ b/frontend/node_modules/.bin/rollup
@ -0,0 +1 @@
+../rollup/dist/bin/rollup
--- a/frontend/node_modules/.bin/vite
+++ b/frontend/node_modules/.bin/vite
@ -0,0 +1 @@
+../vite/bin/vite.js
--- a/frontend/node_modules/.package-lock.json
+++ b/frontend/node_modules/.package-lock.json
--- a/frontend/node_modules/.vite/deps/_metadata.json
+++ b/frontend/node_modules/.vite/deps/_metadata.json
@ -0,0 +1,47 @@
+{
+  "hash": "6a8d66df",
+  "browserHash": "ef50870a",
+  "optimized": {
+    "axios": {
+      "src": "../../axios/index.js",
+      "file": "axios.js",
+      "fileHash": "770c42d0",
+      "needsInterop": false
+    },
+    "mammoth": {
+      "src": "../../mammoth/lib/index.js",
+      "file": "mammoth.js",
+      "fileHash": "699a606e",
+      "needsInterop": true
+    },
+    "marked": {
+      "src": "../../marked/lib/marked.esm.js",
+      "file": "marked.js",
+      "fileHash": "f070c986",
+      "needsInterop": false
+    },
+    "mind-elixir": {
+      "src": "../../mind-elixir/dist/MindElixir.js",
+      "file": "mind-elixir.js",
+      "fileHash": "b78327d7",
+      "needsInterop": false
+    },
+    "pdfjs-dist": {
+      "src": "../../pdfjs-dist/build/pdf.mjs",
+      "file": "pdfjs-dist.js",
+      "fileHash": "7c5f9c82",
+      "needsInterop": false
+    },
+    "vue": {
+      "src": "../../vue/dist/vue.runtime.esm-bundler.js",
+      "file": "vue.js",
+      "fileHash": "73ad40f1",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "chunk-FOSKEDPS": {
+      "file": "chunk-FOSKEDPS.js"
+    }
+  }
+}
--- a/frontend/node_modules/.vite/deps/axios.js
+++ b/frontend/node_modules/.vite/deps/axios.js
--- a/frontend/node_modules/.vite/deps/axios.js.map
+++ b/frontend/node_modules/.vite/deps/axios.js.map
--- a/frontend/node_modules/.vite/deps/chunk-FOSKEDPS.js
+++ b/frontend/node_modules/.vite/deps/chunk-FOSKEDPS.js
@ -0,0 +1,80 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toCommonJS,
+  __publicField,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateWrapper,
+  __privateMethod
+};
+//# sourceMappingURL=chunk-FOSKEDPS.js.map
--- a/frontend/node_modules/.vite/deps/chunk-FOSKEDPS.js.map
+++ b/frontend/node_modules/.vite/deps/chunk-FOSKEDPS.js.map
@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}
--- a/frontend/node_modules/.vite/deps/mammoth.js
+++ b/frontend/node_modules/.vite/deps/mammoth.js
--- a/frontend/node_modules/.vite/deps/mammoth.js.map
+++ b/frontend/node_modules/.vite/deps/mammoth.js.map
--- a/frontend/node_modules/.vite/deps/marked.js
+++ b/frontend/node_modules/.vite/deps/marked.js
--- a/frontend/node_modules/.vite/deps/marked.js.map
+++ b/frontend/node_modules/.vite/deps/marked.js.map
--- a/frontend/node_modules/.vite/deps/mind-elixir.js
+++ b/frontend/node_modules/.vite/deps/mind-elixir.js
--- a/frontend/node_modules/.vite/deps/mind-elixir.js.map
+++ b/frontend/node_modules/.vite/deps/mind-elixir.js.map
--- a/frontend/node_modules/.vite/deps/package.json
+++ b/frontend/node_modules/.vite/deps/package.json
@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
--- a/frontend/node_modules/.vite/deps/pdfjs-dist.js
+++ b/frontend/node_modules/.vite/deps/pdfjs-dist.js
--- a/frontend/node_modules/.vite/deps/pdfjs-dist.js.map
+++ b/frontend/node_modules/.vite/deps/pdfjs-dist.js.map
--- a/frontend/node_modules/.vite/deps/vue.js
+++ b/frontend/node_modules/.vite/deps/vue.js
--- a/frontend/node_modules/.vite/deps/vue.js.map
+++ b/frontend/node_modules/.vite/deps/vue.js.map
--- a/frontend/node_modules/.vue-global-types/vue_99_0.d.ts
+++ b/frontend/node_modules/.vue-global-types/vue_99_0.d.ts
@ -0,0 +1,128 @@
+// @ts-nocheck
+export {};
+
+; declare global {
+	const __VLS_directiveBindingRestFields: { instance: null, oldValue: null, modifiers: any, dir: any };
+	const __VLS_unref: typeof import('vue').unref;
+	const __VLS_placeholder: any;
+
+	type __VLS_NativeElements = __VLS_SpreadMerge<SVGElementTagNameMap, HTMLElementTagNameMap>;
+	type __VLS_IntrinsicElements = import('vue/jsx-runtime').JSX.IntrinsicElements;
+	type __VLS_Element = import('vue/jsx-runtime').JSX.Element;
+	type __VLS_GlobalComponents = import('vue').GlobalComponents;
+	type __VLS_GlobalDirectives = import('vue').GlobalDirectives;
+	type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
+	type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
+	type __VLS_SpreadMerge<A, B> = Omit<A, keyof B> & B;
+	type __VLS_WithComponent<N0 extends string, LocalComponents, Self, N1 extends string, N2 extends string, N3 extends string> =
+		N1 extends keyof LocalComponents ? N1 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N1] } :
+		N2 extends keyof LocalComponents ? N2 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N2] } :
+		N3 extends keyof LocalComponents ? N3 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N3] } :
+		Self extends object ? { [K in N0]: Self } :
+		N1 extends keyof __VLS_GlobalComponents ? N1 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N1] } :
+		N2 extends keyof __VLS_GlobalComponents ? N2 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N2] } :
+		N3 extends keyof __VLS_GlobalComponents ? N3 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N3] } :
+		{};
+	type __VLS_FunctionalComponentCtx<T, K> = __VLS_PickNotAny<'__ctx' extends keyof __VLS_PickNotAny<K, {}>
+		? K extends { __ctx?: infer Ctx } ? NonNullable<Ctx> : never : any
+		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
+	>;
+	type __VLS_FunctionalComponentProps<T, K> = '__ctx' extends keyof __VLS_PickNotAny<K, {}>
+		? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
+		: T extends (props: infer P, ...args: any) => any ? P
+		: {};
+	type __VLS_FunctionalComponent<T> = (props: (T extends { $props: infer Props } ? Props : {}) & Record<string, unknown>, ctx?: any) => __VLS_Element & {
+		__ctx?: {
+			attrs?: any;
+			slots?: T extends { $slots: infer Slots } ? Slots : Record<string, any>;
+			emit?: T extends { $emit: infer Emit } ? Emit : {};
+			props?: (T extends { $props: infer Props } ? Props : {}) & Record<string, unknown>;
+			expose?: (exposed: T) => void;
+		};
+	};
+	type __VLS_IsFunction<T, K> = K extends keyof T
+		? __VLS_IsAny<T[K]> extends false
+		? unknown extends T[K]
+		? false
+		: true
+		: false
+		: false;
+	type __VLS_NormalizeComponentEvent<
+		Props,
+		Emits,
+		onEvent extends keyof Props,
+		Event extends keyof Emits,
+		CamelizedEvent extends keyof Emits,
+	> = __VLS_IsFunction<Props, onEvent> extends true
+		? Props
+		: __VLS_IsFunction<Emits, Event> extends true
+			? { [K in onEvent]?: Emits[Event] }
+			: __VLS_IsFunction<Emits, CamelizedEvent> extends true
+				? { [K in onEvent]?: Emits[CamelizedEvent] }
+				: Props;
+	// fix https://github.com/vuejs/language-tools/issues/926
+	type __VLS_UnionToIntersection<U> = (U extends unknown ? (arg: U) => unknown : never) extends ((arg: infer P) => unknown) ? P : never;
+	type __VLS_OverloadUnionInner<T, U = unknown> = U & T extends (...args: infer A) => infer R
+		? U extends T
+		? never
+		: __VLS_OverloadUnionInner<T, Pick<T, keyof T> & U & ((...args: A) => R)> | ((...args: A) => R)
+		: never;
+	type __VLS_OverloadUnion<T> = Exclude<
+		__VLS_OverloadUnionInner<(() => never) & T>,
+		T extends () => never ? never : () => never
+	>;
+	type __VLS_ConstructorOverloads<T> = __VLS_OverloadUnion<T> extends infer F
+		? F extends (event: infer E, ...args: infer A) => any
+		? { [K in E & string]: (...args: A) => void; }
+		: never
+		: never;
+	type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<
+		__VLS_UnionToIntersection<
+			__VLS_ConstructorOverloads<T> & {
+				[K in keyof T]: T[K] extends any[] ? { (...args: T[K]): void } : never
+			}
+		>
+	>;
+	type __VLS_ResolveEmits<
+		Comp,
+		Emits,
+		TypeEmits = Comp extends { __typeEmits?: infer T } ? unknown extends T ? {} : import('vue').ShortEmitsToObject<T> : {},
+		NormalizedEmits = __VLS_NormalizeEmits<Emits> extends infer E ? string extends keyof E ? {} : E : never,
+	> = __VLS_SpreadMerge<NormalizedEmits, TypeEmits>;
+	type __VLS_ResolveDirectives<T> = {
+		[K in Exclude<keyof T, keyof __VLS_GlobalDirectives> & string as `v${Capitalize<K>}`]: T[K];
+	};
+	type __VLS_PrettifyGlobal<T> = { [K in keyof T as K]: T[K]; } & {};
+	type __VLS_UseTemplateRef<T> = Readonly<import('vue').ShallowRef<T | null>>;
+
+	function __VLS_getVForSourceType<T extends number | string | any[] | Iterable<any>>(source: T): [
+		item: T extends number ? number
+			: T extends string ? string
+			: T extends any[] ? T[number]
+			: T extends Iterable<infer T1> ? T1
+			: any,
+		index: number,
+	][];
+	function __VLS_getVForSourceType<T>(source: T): [
+		item: T[keyof T],
+		key: keyof T,
+		index: number,
+	][];
+	function __VLS_getSlotParameters<S, D extends S>(slot: S, decl?: D):
+		D extends (...args: infer P) => any ? P : any[];
+	function __VLS_asFunctionalDirective<T>(dir: T): T extends import('vue').ObjectDirective
+		? NonNullable<T['created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted']>
+		: T extends (...args: any) => any
+			? T
+			: (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown) => void;
+	function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
+	function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
+		T extends new (...args: any) => any ? __VLS_FunctionalComponent<K>
+		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
+		: T extends (...args: any) => any ? T
+		: __VLS_FunctionalComponent<{}>;
+	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
+	function __VLS_asFunctionalElement<T>(tag: T, endTag?: T): (attrs: T & Record<string, unknown>) => void;
+	function __VLS_asFunctionalSlot<S>(slot: S): S extends () => infer R ? (props: {}) => R : NonNullable<S>;
+	function __VLS_tryAsConstant<const T>(t: T): T;
+}
--- a/frontend/node_modules/@babel/helper-string-parser/LICENSE
+++ b/frontend/node_modules/@babel/helper-string-parser/LICENSE
@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/frontend/node_modules/@babel/helper-string-parser/README.md
+++ b/frontend/node_modules/@babel/helper-string-parser/README.md
@ -0,0 +1,19 @@
+# @babel/helper-string-parser
+
+> A utility package to parse strings
+
+See our website [@babel/helper-string-parser](https://babeljs.io/docs/babel-helper-string-parser) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-string-parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-string-parser
+```
--- a/frontend/node_modules/@babel/helper-string-parser/lib/index.js
+++ b/frontend/node_modules/@babel/helper-string-parser/lib/index.js
@ -0,0 +1,295 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readCodePoint = readCodePoint;
+exports.readInt = readInt;
+exports.readStringContents = readStringContents;
+var _isDigit = function isDigit(code) {
+  return code >= 48 && code <= 57;
+};
+const forbiddenNumericSeparatorSiblings = {
+  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
+  hex: new Set([46, 88, 95, 120])
+};
+const isAllowedNumericSeparatorSibling = {
+  bin: ch => ch === 48 || ch === 49,
+  oct: ch => ch >= 48 && ch <= 55,
+  dec: ch => ch >= 48 && ch <= 57,
+  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+};
+function readStringContents(type, input, pos, lineStart, curLine, errors) {
+  const initialPos = pos;
+  const initialLineStart = lineStart;
+  const initialCurLine = curLine;
+  let out = "";
+  let firstInvalidLoc = null;
+  let chunkStart = pos;
+  const {
+    length
+  } = input;
+  for (;;) {
+    if (pos >= length) {
+      errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    const ch = input.charCodeAt(pos);
+    if (isStringEnd(type, ch, input, pos)) {
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    if (ch === 92) {
+      out += input.slice(chunkStart, pos);
+      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
+      if (res.ch === null && !firstInvalidLoc) {
+        firstInvalidLoc = {
+          pos,
+          lineStart,
+          curLine
+        };
+      } else {
+        out += res.ch;
+      }
+      ({
+        pos,
+        lineStart,
+        curLine
+      } = res);
+      chunkStart = pos;
+    } else if (ch === 8232 || ch === 8233) {
+      ++pos;
+      ++curLine;
+      lineStart = pos;
+    } else if (ch === 10 || ch === 13) {
+      if (type === "template") {
+        out += input.slice(chunkStart, pos) + "\n";
+        ++pos;
+        if (ch === 13 && input.charCodeAt(pos) === 10) {
+          ++pos;
+        }
+        ++curLine;
+        chunkStart = lineStart = pos;
+      } else {
+        errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      }
+    } else {
+      ++pos;
+    }
+  }
+  return {
+    pos,
+    str: out,
+    firstInvalidLoc,
+    lineStart,
+    curLine,
+    containsInvalid: !!firstInvalidLoc
+  };
+}
+function isStringEnd(type, ch, input, pos) {
+  if (type === "template") {
+    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
+  }
+  return ch === (type === "double" ? 34 : 39);
+}
+function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
+  const throwOnInvalid = !inTemplate;
+  pos++;
+  const res = ch => ({
+    pos,
+    ch,
+    lineStart,
+    curLine
+  });
+  const ch = input.charCodeAt(pos++);
+  switch (ch) {
+    case 110:
+      return res("\n");
+    case 114:
+      return res("\r");
+    case 120:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCharCode(code));
+      }
+    case 117:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCodePoint(code));
+      }
+    case 116:
+      return res("\t");
+    case 98:
+      return res("\b");
+    case 118:
+      return res("\u000b");
+    case 102:
+      return res("\f");
+    case 13:
+      if (input.charCodeAt(pos) === 10) {
+        ++pos;
+      }
+    case 10:
+      lineStart = pos;
+      ++curLine;
+    case 8232:
+    case 8233:
+      return res("");
+    case 56:
+    case 57:
+      if (inTemplate) {
+        return res(null);
+      } else {
+        errors.strictNumericEscape(pos - 1, lineStart, curLine);
+      }
+    default:
+      if (ch >= 48 && ch <= 55) {
+        const startPos = pos - 1;
+        const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));
+        let octalStr = match[0];
+        let octal = parseInt(octalStr, 8);
+        if (octal > 255) {
+          octalStr = octalStr.slice(0, -1);
+          octal = parseInt(octalStr, 8);
+        }
+        pos += octalStr.length - 1;
+        const next = input.charCodeAt(pos);
+        if (octalStr !== "0" || next === 56 || next === 57) {
+          if (inTemplate) {
+            return res(null);
+          } else {
+            errors.strictNumericEscape(startPos, lineStart, curLine);
+          }
+        }
+        return res(String.fromCharCode(octal));
+      }
+      return res(String.fromCharCode(ch));
+  }
+}
+function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+  const initialPos = pos;
+  let n;
+  ({
+    n,
+    pos
+  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+  if (n === null) {
+    if (throwOnInvalid) {
+      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
+    } else {
+      pos = initialPos - 1;
+    }
+  }
+  return {
+    code: n,
+    pos
+  };
+}
+function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+  const start = pos;
+  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
+  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
+  let invalid = false;
+  let total = 0;
+  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    const code = input.charCodeAt(pos);
+    let val;
+    if (code === 95 && allowNumSeparator !== "bail") {
+      const prev = input.charCodeAt(pos - 1);
+      const next = input.charCodeAt(pos + 1);
+      if (!allowNumSeparator) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
+      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
+      }
+      ++pos;
+      continue;
+    }
+    if (code >= 97) {
+      val = code - 97 + 10;
+    } else if (code >= 65) {
+      val = code - 65 + 10;
+    } else if (_isDigit(code)) {
+      val = code - 48;
+    } else {
+      val = Infinity;
+    }
+    if (val >= radix) {
+      if (val <= 9 && bailOnError) {
+        return {
+          n: null,
+          pos
+        };
+      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
+        val = 0;
+      } else if (forceLen) {
+        val = 0;
+        invalid = true;
+      } else {
+        break;
+      }
+    }
+    ++pos;
+    total = total * radix + val;
+  }
+  if (pos === start || len != null && pos - start !== len || invalid) {
+    return {
+      n: null,
+      pos
+    };
+  }
+  return {
+    n: total,
+    pos
+  };
+}
+function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+  const ch = input.charCodeAt(pos);
+  let code;
+  if (ch === 123) {
+    ++pos;
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+    ++pos;
+    if (code !== null && code > 0x10ffff) {
+      if (throwOnInvalid) {
+        errors.invalidCodePoint(pos, lineStart, curLine);
+      } else {
+        return {
+          code: null,
+          pos
+        };
+      }
+    }
+  } else {
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+  }
+  return {
+    code,
+    pos
+  };
+}
+
+//# sourceMappingURL=index.js.map
--- a/frontend/node_modules/@babel/helper-string-parser/lib/index.js.map
+++ b/frontend/node_modules/@babel/helper-string-parser/lib/index.js.map
--- a/frontend/node_modules/@babel/helper-string-parser/package.json
+++ b/frontend/node_modules/@babel/helper-string-parser/package.json
@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-string-parser",
+  "version": "7.27.1",
+  "description": "A utility package to parse strings",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-string-parser"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-string-parser",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "devDependencies": {
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "commonjs"
+}
--- a/frontend/node_modules/@babel/helper-validator-identifier/LICENSE
+++ b/frontend/node_modules/@babel/helper-validator-identifier/LICENSE
@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/frontend/node_modules/@babel/helper-validator-identifier/README.md
+++ b/frontend/node_modules/@babel/helper-validator-identifier/README.md
@ -0,0 +1,19 @@
+# @babel/helper-validator-identifier
+
+> Validate identifier/keywords name
+
+See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/babel-helper-validator-identifier) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-validator-identifier
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-validator-identifier
+```
--- a/frontend/node_modules/@babel/helper-validator-identifier/lib/identifier.js
+++ b/frontend/node_modules/@babel/helper-validator-identifier/lib/identifier.js
@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIdentifierChar = isIdentifierChar;
+exports.isIdentifierName = isIdentifierName;
+exports.isIdentifierStart = isIdentifierStart;
+let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7cd\ua7d0\ua7d1\ua7d3\ua7d5-\ua7dc\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 2, 60, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 42, 9, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 496, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191];
+const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 80, 3, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 343, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 726, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+function isInAstralSet(code, set) {
+  let pos = 0x10000;
+  for (let i = 0, length = set.length; i < length; i += 2) {
+    pos += set[i];
+    if (pos > code) return false;
+    pos += set[i + 1];
+    if (pos >= code) return true;
+  }
+  return false;
+}
+function isIdentifierStart(code) {
+  if (code < 65) return code === 36;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  }
+  return isInAstralSet(code, astralIdentifierStartCodes);
+}
+function isIdentifierChar(code) {
+  if (code < 48) return code === 36;
+  if (code < 58) return true;
+  if (code < 65) return false;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  }
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+}
+function isIdentifierName(name) {
+  let isFirst = true;
+  for (let i = 0; i < name.length; i++) {
+    let cp = name.charCodeAt(i);
+    if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
+      const trail = name.charCodeAt(++i);
+      if ((trail & 0xfc00) === 0xdc00) {
+        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
+      }
+    }
+    if (isFirst) {
+      isFirst = false;
+      if (!isIdentifierStart(cp)) {
+        return false;
+      }
+    } else if (!isIdentifierChar(cp)) {
+      return false;
+    }
+  }
+  return !isFirst;
+}
+
+//# sourceMappingURL=identifier.js.map
--- a/frontend/node_modules/@babel/helper-validator-identifier/lib/identifier.js.map
+++ b/frontend/node_modules/@babel/helper-validator-identifier/lib/identifier.js.map
--- a/frontend/node_modules/@babel/helper-validator-identifier/lib/index.js
+++ b/frontend/node_modules/@babel/helper-validator-identifier/lib/index.js
@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "isIdentifierChar", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierChar;
+  }
+});
+Object.defineProperty(exports, "isIdentifierName", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierName;
+  }
+});
+Object.defineProperty(exports, "isIdentifierStart", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierStart;
+  }
+});
+Object.defineProperty(exports, "isKeyword", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isKeyword;
+  }
+});
+Object.defineProperty(exports, "isReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindOnlyReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictReservedWord;
+  }
+});
+var _identifier = require("./identifier.js");
+var _keyword = require("./keyword.js");
+
+//# sourceMappingURL=index.js.map
--- a/frontend/node_modules/@babel/helper-validator-identifier/lib/index.js.map
+++ b/frontend/node_modules/@babel/helper-validator-identifier/lib/index.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_identifier","require","_keyword"],"sources":["../src/index.ts"],"sourcesContent":["export {\n  isIdentifierName,\n  isIdentifierChar,\n  isIdentifierStart,\n} from \"./identifier.ts\";\nexport {\n  isReservedWord,\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n  isStrictReservedWord,\n  isKeyword,\n} from \"./keyword.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAKA,IAAAC,QAAA,GAAAD,OAAA","ignoreList":[]}
--- a/frontend/node_modules/@babel/helper-validator-identifier/lib/keyword.js
+++ b/frontend/node_modules/@babel/helper-validator-identifier/lib/keyword.js
@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isKeyword = isKeyword;
+exports.isReservedWord = isReservedWord;
+exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+exports.isStrictBindReservedWord = isStrictBindReservedWord;
+exports.isStrictReservedWord = isStrictReservedWord;
+const reservedWords = {
+  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+  strictBind: ["eval", "arguments"]
+};
+const keywords = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+function isReservedWord(word, inModule) {
+  return inModule && word === "await" || word === "enum";
+}
+function isStrictReservedWord(word, inModule) {
+  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
+function isStrictBindOnlyReservedWord(word) {
+  return reservedWordsStrictBindSet.has(word);
+}
+function isStrictBindReservedWord(word, inModule) {
+  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+}
+function isKeyword(word) {
+  return keywords.has(word);
+}
+
+//# sourceMappingURL=keyword.js.map
--- a/frontend/node_modules/@babel/helper-validator-identifier/lib/keyword.js.map
+++ b/frontend/node_modules/@babel/helper-validator-identifier/lib/keyword.js.map
@ -0,0 +1 @@
+{"version":3,"names":["reservedWords","keyword","strict","strictBind","keywords","Set","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword"],"sources":["../src/keyword.ts"],"sourcesContent":["const reservedWords = {\n  keyword: [\n    \"break\",\n    \"case\",\n    \"catch\",\n    \"continue\",\n    \"debugger\",\n    \"default\",\n    \"do\",\n    \"else\",\n    \"finally\",\n    \"for\",\n    \"function\",\n    \"if\",\n    \"return\",\n    \"switch\",\n    \"throw\",\n    \"try\",\n    \"var\",\n    \"const\",\n    \"while\",\n    \"with\",\n    \"new\",\n    \"this\",\n    \"super\",\n    \"class\",\n    \"extends\",\n    \"export\",\n    \"import\",\n    \"null\",\n    \"true\",\n    \"false\",\n    \"in\",\n    \"instanceof\",\n    \"typeof\",\n    \"void\",\n    \"delete\",\n  ],\n  strict: [\n    \"implements\",\n    \"interface\",\n    \"let\",\n    \"package\",\n    \"private\",\n    \"protected\",\n    \"public\",\n    \"static\",\n    \"yield\",\n  ],\n  strictBind: [\"eval\", \"arguments\"],\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\n/**\n * Checks if word is a reserved word in non-strict mode\n */\nexport function isReservedWord(word: string, inModule: boolean): boolean {\n  return (inModule && word === \"await\") || word === \"enum\";\n}\n\n/**\n * Checks if word is a reserved word in non-binding strict mode\n *\n * Includes non-strict reserved words\n */\nexport function isStrictReservedWord(word: string, inModule: boolean): boolean {\n  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode, but it is allowed as\n * a normal identifier.\n */\nexport function isStrictBindOnlyReservedWord(word: string): boolean {\n  return reservedWordsStrictBindSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode\n *\n * Includes non-strict reserved words and non-binding strict reserved words\n */\nexport function isStrictBindReservedWord(\n  word: string,\n  inModule: boolean,\n): boolean {\n  return (\n    isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word)\n  );\n}\n\nexport function isKeyword(word: string): boolean {\n  return keywords.has(word);\n}\n"],"mappings":";;;;;;;;;;AAAA,MAAMA,aAAa,GAAG;EACpBC,OAAO,EAAE,CACP,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,KAAK,EACL,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,CACT;EACDC,MAAM,EAAE,CACN,YAAY,EACZ,WAAW,EACX,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,CACR;EACDC,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW;AAClC,CAAC;AACD,MAAMC,QAAQ,GAAG,IAAIC,GAAG,CAACL,aAAa,CAACC,OAAO,CAAC;AAC/C,MAAMK,sBAAsB,GAAG,IAAID,GAAG,CAACL,aAAa,CAACE,MAAM,CAAC;AAC5D,MAAMK,0BAA0B,GAAG,IAAIF,GAAG,CAACL,aAAa,CAACG,UAAU,CAAC;AAK7D,SAASK,cAAcA,CAACC,IAAY,EAAEC,QAAiB,EAAW;EACvE,OAAQA,QAAQ,IAAID,IAAI,KAAK,OAAO,IAAKA,IAAI,KAAK,MAAM;AAC1D;AAOO,SAASE,oBAAoBA,CAACF,IAAY,EAAEC,QAAiB,EAAW;EAC7E,OAAOF,cAAc,CAACC,IAAI,EAAEC,QAAQ,CAAC,IAAIJ,sBAAsB,CAACM,GAAG,CAACH,IAAI,CAAC;AAC3E;AAMO,SAASI,4BAA4BA,CAACJ,IAAY,EAAW;EAClE,OAAOF,0BAA0B,CAACK,GAAG,CAACH,IAAI,CAAC;AAC7C;AAOO,SAASK,wBAAwBA,CACtCL,IAAY,EACZC,QAAiB,EACR;EACT,OACEC,oBAAoB,CAACF,IAAI,EAAEC,QAAQ,CAAC,IAAIG,4BAA4B,CAACJ,IAAI,CAAC;AAE9E;AAEO,SAASM,SAASA,CAACN,IAAY,EAAW;EAC/C,OAAOL,QAAQ,CAACQ,GAAG,CAACH,IAAI,CAAC;AAC3B","ignoreList":[]}
--- a/frontend/node_modules/@babel/helper-validator-identifier/package.json
+++ b/frontend/node_modules/@babel/helper-validator-identifier/package.json
@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-validator-identifier",
+  "version": "7.27.1",
+  "description": "Validate identifier/keywords name",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-validator-identifier"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@unicode/unicode-16.0.0": "^1.0.0",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}
--- a/frontend/node_modules/@babel/parser/CHANGELOG.md
+++ b/frontend/node_modules/@babel/parser/CHANGELOG.md
--- a/frontend/node_modules/@babel/parser/LICENSE
+++ b/frontend/node_modules/@babel/parser/LICENSE
@ -0,0 +1,19 @@
+Copyright (C) 2012-2014 by various contributors (see AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- a/frontend/node_modules/@babel/parser/README.md
+++ b/frontend/node_modules/@babel/parser/README.md
@ -0,0 +1,19 @@
+# @babel/parser
+
+> A JavaScript parser
+
+See our website [@babel/parser](https://babeljs.io/docs/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/parser --dev
+```
--- a/frontend/node_modules/@babel/parser/bin/babel-parser.js
+++ b/frontend/node_modules/@babel/parser/bin/babel-parser.js
@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/* eslint-disable no-var, unicorn/prefer-node-protocol */
+
+var parser = require("..");
+var fs = require("fs");
+
+var filename = process.argv[2];
+if (!filename) {
+  console.error("no filename specified");
+} else {
+  var file = fs.readFileSync(filename, "utf8");
+  var ast = parser.parse(file);
+
+  console.log(JSON.stringify(ast, null, "  "));
+}
--- a/frontend/node_modules/@babel/parser/lib/index.js
+++ b/frontend/node_modules/@babel/parser/lib/index.js
--- a/frontend/node_modules/@babel/parser/lib/index.js.map
+++ b/frontend/node_modules/@babel/parser/lib/index.js.map
--- a/frontend/node_modules/@babel/parser/package.json
+++ b/frontend/node_modules/@babel/parser/package.json
@ -0,0 +1,50 @@
+{
+  "name": "@babel/parser",
+  "version": "7.28.3",
+  "description": "A JavaScript parser",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "main": "./lib/index.js",
+  "types": "./typings/babel-parser.d.ts",
+  "files": [
+    "bin",
+    "lib",
+    "typings/babel-parser.d.ts",
+    "index.cjs"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "# dependencies": "This package doesn't actually have runtime dependencies. @babel/types is only needed for type definitions.",
+  "dependencies": {
+    "@babel/types": "^7.28.2"
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^7.27.1",
+    "@babel/helper-check-duplicate-nodes": "^7.27.1",
+    "@babel/helper-fixtures": "^7.28.0",
+    "@babel/helper-string-parser": "^7.27.1",
+    "@babel/helper-validator-identifier": "^7.27.1",
+    "charcodes": "^0.2.0"
+  },
+  "bin": "./bin/babel-parser.js",
+  "type": "commonjs"
+}
--- a/frontend/node_modules/@babel/parser/typings/babel-parser.d.ts
+++ b/frontend/node_modules/@babel/parser/typings/babel-parser.d.ts
@ -0,0 +1,239 @@
+// This file is auto-generated! Do not modify it directly.
+// Run `yarn gulp bundle-dts` to re-generate it.
+/* eslint-disable @typescript-eslint/consistent-type-imports, @typescript-eslint/no-redundant-type-constituents */
+import { File, Expression } from '@babel/types';
+
+type BABEL_8_BREAKING = false;
+type IF_BABEL_7<V> = false extends BABEL_8_BREAKING ? V : never;
+
+type Plugin$1 =
+  | "asyncDoExpressions"
+  | IF_BABEL_7<"asyncGenerators">
+  | IF_BABEL_7<"bigInt">
+  | IF_BABEL_7<"classPrivateMethods">
+  | IF_BABEL_7<"classPrivateProperties">
+  | IF_BABEL_7<"classProperties">
+  | IF_BABEL_7<"classStaticBlock">
+  | IF_BABEL_7<"decimal">
+  | "decorators-legacy"
+  | "deferredImportEvaluation"
+  | "decoratorAutoAccessors"
+  | "destructuringPrivate"
+  | "deprecatedImportAssert"
+  | "doExpressions"
+  | IF_BABEL_7<"dynamicImport">
+  | IF_BABEL_7<"explicitResourceManagement">
+  | "exportDefaultFrom"
+  | IF_BABEL_7<"exportNamespaceFrom">
+  | "flow"
+  | "flowComments"
+  | "functionBind"
+  | "functionSent"
+  | "importMeta"
+  | "jsx"
+  | IF_BABEL_7<"jsonStrings">
+  | IF_BABEL_7<"logicalAssignment">
+  | IF_BABEL_7<"importAssertions">
+  | IF_BABEL_7<"importReflection">
+  | "moduleBlocks"
+  | IF_BABEL_7<"moduleStringNames">
+  | IF_BABEL_7<"nullishCoalescingOperator">
+  | IF_BABEL_7<"numericSeparator">
+  | IF_BABEL_7<"objectRestSpread">
+  | IF_BABEL_7<"optionalCatchBinding">
+  | IF_BABEL_7<"optionalChaining">
+  | "partialApplication"
+  | "placeholders"
+  | IF_BABEL_7<"privateIn">
+  | IF_BABEL_7<"regexpUnicodeSets">
+  | "sourcePhaseImports"
+  | "throwExpressions"
+  | IF_BABEL_7<"topLevelAwait">
+  | "v8intrinsic"
+  | ParserPluginWithOptions[0];
+
+type ParserPluginWithOptions =
+  | ["decorators", DecoratorsPluginOptions]
+  | ["discardBinding", { syntaxType: "void" }]
+  | ["estree", { classFeatures?: boolean }]
+  | IF_BABEL_7<["importAttributes", { deprecatedAssertSyntax: boolean }]>
+  | IF_BABEL_7<["moduleAttributes", { version: "may-2020" }]>
+  | ["optionalChainingAssign", { version: "2023-07" }]
+  | ["pipelineOperator", PipelineOperatorPluginOptions]
+  | ["recordAndTuple", RecordAndTuplePluginOptions]
+  | ["flow", FlowPluginOptions]
+  | ["typescript", TypeScriptPluginOptions];
+
+type PluginConfig = Plugin$1 | ParserPluginWithOptions;
+
+interface DecoratorsPluginOptions {
+  decoratorsBeforeExport?: boolean;
+  allowCallParenthesized?: boolean;
+}
+
+interface PipelineOperatorPluginOptions {
+  proposal: BABEL_8_BREAKING extends false
+    ? "minimal" | "fsharp" | "hack" | "smart"
+    : "fsharp" | "hack";
+  topicToken?: "%" | "#" | "@@" | "^^" | "^";
+}
+
+interface RecordAndTuplePluginOptions {
+  syntaxType: "bar" | "hash";
+}
+
+type FlowPluginOptions = BABEL_8_BREAKING extends true
+  ? {
+      all?: boolean;
+      enums?: boolean;
+    }
+  : {
+      all?: boolean;
+    };
+
+interface TypeScriptPluginOptions {
+  dts?: boolean;
+  disallowAmbiguousJSXLike?: boolean;
+}
+
+type Plugin = PluginConfig;
+
+type SourceType = "script" | "commonjs" | "module" | "unambiguous";
+interface Options {
+    /**
+     * By default, import and export declarations can only appear at a program's top level.
+     * Setting this option to true allows them anywhere where a statement is allowed.
+     */
+    allowImportExportEverywhere?: boolean;
+    /**
+     * By default, await use is not allowed outside of an async function.
+     * Set this to true to accept such code.
+     */
+    allowAwaitOutsideFunction?: boolean;
+    /**
+     * By default, a return statement at the top level raises an error.
+     * Set this to true to accept such code.
+     */
+    allowReturnOutsideFunction?: boolean;
+    /**
+     * By default, new.target use is not allowed outside of a function or class.
+     * Set this to true to accept such code.
+     */
+    allowNewTargetOutsideFunction?: boolean;
+    allowSuperOutsideMethod?: boolean;
+    /**
+     * By default, exported identifiers must refer to a declared variable.
+     * Set this to true to allow export statements to reference undeclared variables.
+     */
+    allowUndeclaredExports?: boolean;
+    /**
+     * By default, yield use is not allowed outside of a generator function.
+     * Set this to true to accept such code.
+     */
+    allowYieldOutsideFunction?: boolean;
+    /**
+     * By default, Babel parser JavaScript code according to Annex B syntax.
+     * Set this to `false` to disable such behavior.
+     */
+    annexB?: boolean;
+    /**
+     * By default, Babel attaches comments to adjacent AST nodes.
+     * When this option is set to false, comments are not attached.
+     * It can provide up to 30% performance improvement when the input code has many comments.
+     * @babel/eslint-parser will set it for you.
+     * It is not recommended to use attachComment: false with Babel transform,
+     * as doing so removes all the comments in output code, and renders annotations such as
+     * /* istanbul ignore next *\/ nonfunctional.
+     */
+    attachComment?: boolean;
+    /**
+     * By default, Babel always throws an error when it finds some invalid code.
+     * When this option is set to true, it will store the parsing error and
+     * try to continue parsing the invalid input file.
+     */
+    errorRecovery?: boolean;
+    /**
+     * Indicate the mode the code should be parsed in.
+     * Can be one of "script", "commonjs", "module", or "unambiguous". Defaults to "script".
+     * "unambiguous" will make @babel/parser attempt to guess, based on the presence
+     * of ES6 import or export statements.
+     * Files with ES6 imports and exports are considered "module" and are otherwise "script".
+     *
+     * Use "commonjs" to parse code that is intended to be run in a CommonJS environment such as Node.js.
+     */
+    sourceType?: SourceType;
+    /**
+     * Correlate output AST nodes with their source filename.
+     * Useful when generating code and source maps from the ASTs of multiple input files.
+     */
+    sourceFilename?: string;
+    /**
+     * By default, all source indexes start from 0.
+     * You can provide a start index to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startIndex?: number;
+    /**
+     * By default, the first line of code parsed is treated as line 1.
+     * You can provide a line number to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startLine?: number;
+    /**
+     * By default, the parsed code is treated as if it starts from line 1, column 0.
+     * You can provide a column number to alternatively start with.
+     * Useful for integration with other source tools.
+     */
+    startColumn?: number;
+    /**
+     * Array containing the plugins that you want to enable.
+     */
+    plugins?: Plugin[];
+    /**
+     * Should the parser work in strict mode.
+     * Defaults to true if sourceType === 'module'. Otherwise, false.
+     */
+    strictMode?: boolean;
+    /**
+     * Adds a ranges property to each node: [node.start, node.end]
+     */
+    ranges?: boolean;
+    /**
+     * Adds all parsed tokens to a tokens property on the File node.
+     */
+    tokens?: boolean;
+    /**
+     * By default, the parser adds information about parentheses by setting
+     * `extra.parenthesized` to `true` as needed.
+     * When this option is `true` the parser creates `ParenthesizedExpression`
+     * AST nodes instead of using the `extra` property.
+     */
+    createParenthesizedExpressions?: boolean;
+    /**
+     * The default is false in Babel 7 and true in Babel 8
+     * Set this to true to parse it as an `ImportExpression` node.
+     * Otherwise `import(foo)` is parsed as `CallExpression(Import, [Identifier(foo)])`.
+     */
+    createImportExpressions?: boolean;
+}
+
+type ParserOptions = Partial<Options>;
+interface ParseError {
+    code: string;
+    reasonCode: string;
+}
+type ParseResult<Result extends File | Expression = File> = Result & {
+    errors: null | ParseError[];
+};
+/**
+ * Parse the provided code as an entire ECMAScript program.
+ */
+declare function parse(input: string, options?: ParserOptions): ParseResult<File>;
+declare function parseExpression(input: string, options?: ParserOptions): ParseResult<Expression>;
+
+declare const tokTypes: {
+  // todo(flow->ts) real token type
+  [name: string]: any;
+};
+
+export { DecoratorsPluginOptions, FlowPluginOptions, ParseError, ParseResult, ParserOptions, PluginConfig as ParserPlugin, ParserPluginWithOptions, PipelineOperatorPluginOptions, RecordAndTuplePluginOptions, TypeScriptPluginOptions, parse, parseExpression, tokTypes };
--- a/frontend/node_modules/@babel/types/LICENSE
+++ b/frontend/node_modules/@babel/types/LICENSE
@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/frontend/node_modules/@babel/types/README.md
+++ b/frontend/node_modules/@babel/types/README.md
@ -0,0 +1,19 @@
+# @babel/types
+
+> Babel Types is a Lodash-esque utility library for AST nodes
+
+See our website [@babel/types](https://babeljs.io/docs/babel-types) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/types
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/types --dev
+```
--- a/frontend/node_modules/@babel/types/lib/asserts/assertNode.js
+++ b/frontend/node_modules/@babel/types/lib/asserts/assertNode.js
@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = assertNode;
+var _isNode = require("../validators/isNode.js");
+function assertNode(node) {
+  if (!(0, _isNode.default)(node)) {
+    var _node$type;
+    const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);
+    throw new TypeError(`Not a valid node of type "${type}"`);
+  }
+}
+
+//# sourceMappingURL=assertNode.js.map
--- a/frontend/node_modules/@babel/types/lib/asserts/assertNode.js.map
+++ b/frontend/node_modules/@babel/types/lib/asserts/assertNode.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_isNode","require","assertNode","node","isNode","_node$type","type","JSON","stringify","TypeError"],"sources":["../../src/asserts/assertNode.ts"],"sourcesContent":["import isNode from \"../validators/isNode.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function assertNode(node?: any): asserts node is t.Node {\n  if (!isNode(node)) {\n    const type = node?.type ?? JSON.stringify(node);\n    throw new TypeError(`Not a valid node of type \"${type}\"`);\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAGe,SAASC,UAAUA,CAACC,IAAU,EAA0B;EACrE,IAAI,CAAC,IAAAC,eAAM,EAACD,IAAI,CAAC,EAAE;IAAA,IAAAE,UAAA;IACjB,MAAMC,IAAI,IAAAD,UAAA,GAAGF,IAAI,oBAAJA,IAAI,CAAEG,IAAI,YAAAD,UAAA,GAAIE,IAAI,CAACC,SAAS,CAACL,IAAI,CAAC;IAC/C,MAAM,IAAIM,SAAS,CAAC,6BAA6BH,IAAI,GAAG,CAAC;EAC3D;AACF","ignoreList":[]}
--- a/frontend/node_modules/@babel/types/lib/asserts/generated/index.js
+++ b/frontend/node_modules/@babel/types/lib/asserts/generated/index.js
--- a/frontend/node_modules/@babel/types/lib/asserts/generated/index.js.map
+++ b/frontend/node_modules/@babel/types/lib/asserts/generated/index.js.map
--- a/frontend/node_modules/@babel/types/lib/ast-types/generated/index.js
+++ b/frontend/node_modules/@babel/types/lib/ast-types/generated/index.js
@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=index.js.map
--- a/frontend/node_modules/@babel/types/lib/ast-types/generated/index.js.map
+++ b/frontend/node_modules/@babel/types/lib/ast-types/generated/index.js.map
--- a/frontend/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
+++ b/frontend/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createFlowUnionType;
+var _index = require("../generated/index.js");
+var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates.js");
+function createFlowUnionType(types) {
+  const flattened = (0, _removeTypeDuplicates.default)(types);
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return (0, _index.unionTypeAnnotation)(flattened);
+  }
+}
+
+//# sourceMappingURL=createFlowUnionType.js.map
--- a/frontend/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js.map
+++ b/frontend/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_removeTypeDuplicates","createFlowUnionType","types","flattened","removeTypeDuplicates","length","unionTypeAnnotation"],"sources":["../../../src/builders/flow/createFlowUnionType.ts"],"sourcesContent":["import { unionTypeAnnotation } from \"../generated/index.ts\";\nimport removeTypeDuplicates from \"../../modifications/flow/removeTypeDuplicates.ts\";\nimport type * as t from \"../../index.ts\";\n\n/**\n * Takes an array of `types` and flattens them, removing duplicates and\n * returns a `UnionTypeAnnotation` node containing them.\n */\nexport default function createFlowUnionType<T extends t.FlowType>(\n  types: [T] | Array<T>,\n): T | t.UnionTypeAnnotation {\n  const flattened = removeTypeDuplicates(types);\n\n  if (flattened.length === 1) {\n    return flattened[0] as T;\n  } else {\n    return unionTypeAnnotation(flattened);\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AAOe,SAASE,mBAAmBA,CACzCC,KAAqB,EACM;EAC3B,MAAMC,SAAS,GAAG,IAAAC,6BAAoB,EAACF,KAAK,CAAC;EAE7C,IAAIC,SAAS,CAACE,MAAM,KAAK,CAAC,EAAE;IAC1B,OAAOF,SAAS,CAAC,CAAC,CAAC;EACrB,CAAC,MAAM;IACL,OAAO,IAAAG,0BAAmB,EAACH,SAAS,CAAC;EACvC;AACF","ignoreList":[]}
--- a/frontend/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
+++ b/frontend/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = require("../generated/index.js");
+var _default = exports.default = createTypeAnnotationBasedOnTypeof;
+function createTypeAnnotationBasedOnTypeof(type) {
+  switch (type) {
+    case "string":
+      return (0, _index.stringTypeAnnotation)();
+    case "number":
+      return (0, _index.numberTypeAnnotation)();
+    case "undefined":
+      return (0, _index.voidTypeAnnotation)();
+    case "boolean":
+      return (0, _index.booleanTypeAnnotation)();
+    case "function":
+      return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Function"));
+    case "object":
+      return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Object"));
+    case "symbol":
+      return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Symbol"));
+    case "bigint":
+      return (0, _index.anyTypeAnnotation)();
+  }
+  throw new Error("Invalid typeof value: " + type);
+}
+
+//# sourceMappingURL=createTypeAnnotationBasedOnTypeof.js.map
--- a/frontend/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js.map
+++ b/frontend/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_default","exports","default","createTypeAnnotationBasedOnTypeof","type","stringTypeAnnotation","numberTypeAnnotation","voidTypeAnnotation","booleanTypeAnnotation","genericTypeAnnotation","identifier","anyTypeAnnotation","Error"],"sources":["../../../src/builders/flow/createTypeAnnotationBasedOnTypeof.ts"],"sourcesContent":["import {\n  anyTypeAnnotation,\n  stringTypeAnnotation,\n  numberTypeAnnotation,\n  voidTypeAnnotation,\n  booleanTypeAnnotation,\n  genericTypeAnnotation,\n  identifier,\n} from \"../generated/index.ts\";\nimport type * as t from \"../../index.ts\";\n\nexport default createTypeAnnotationBasedOnTypeof as {\n  (type: \"string\"): t.StringTypeAnnotation;\n  (type: \"number\"): t.NumberTypeAnnotation;\n  (type: \"undefined\"): t.VoidTypeAnnotation;\n  (type: \"boolean\"): t.BooleanTypeAnnotation;\n  (type: \"function\"): t.GenericTypeAnnotation;\n  (type: \"object\"): t.GenericTypeAnnotation;\n  (type: \"symbol\"): t.GenericTypeAnnotation;\n  (type: \"bigint\"): t.AnyTypeAnnotation;\n};\n\n/**\n * Create a type annotation based on typeof expression.\n */\nfunction createTypeAnnotationBasedOnTypeof(type: string): t.FlowType {\n  switch (type) {\n    case \"string\":\n      return stringTypeAnnotation();\n    case \"number\":\n      return numberTypeAnnotation();\n    case \"undefined\":\n      return voidTypeAnnotation();\n    case \"boolean\":\n      return booleanTypeAnnotation();\n    case \"function\":\n      return genericTypeAnnotation(identifier(\"Function\"));\n    case \"object\":\n      return genericTypeAnnotation(identifier(\"Object\"));\n    case \"symbol\":\n      return genericTypeAnnotation(identifier(\"Symbol\"));\n    case \"bigint\":\n      // todo: use BigInt annotation when Flow supports BigInt\n      // https://github.com/facebook/flow/issues/6639\n      return anyTypeAnnotation();\n  }\n  throw new Error(\"Invalid typeof value: \" + type);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAQ+B,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAGhBC,iCAAiC;AAchD,SAASA,iCAAiCA,CAACC,IAAY,EAAc;EACnE,QAAQA,IAAI;IACV,KAAK,QAAQ;MACX,OAAO,IAAAC,2BAAoB,EAAC,CAAC;IAC/B,KAAK,QAAQ;MACX,OAAO,IAAAC,2BAAoB,EAAC,CAAC;IAC/B,KAAK,WAAW;MACd,OAAO,IAAAC,yBAAkB,EAAC,CAAC;IAC7B,KAAK,SAAS;MACZ,OAAO,IAAAC,4BAAqB,EAAC,CAAC;IAChC,KAAK,UAAU;MACb,OAAO,IAAAC,4BAAqB,EAAC,IAAAC,iBAAU,EAAC,UAAU,CAAC,CAAC;IACtD,KAAK,QAAQ;MACX,OAAO,IAAAD,4BAAqB,EAAC,IAAAC,iBAAU,EAAC,QAAQ,CAAC,CAAC;IACpD,KAAK,QAAQ;MACX,OAAO,IAAAD,4BAAqB,EAAC,IAAAC,iBAAU,EAAC,QAAQ,CAAC,CAAC;IACpD,KAAK,QAAQ;MAGX,OAAO,IAAAC,wBAAiB,EAAC,CAAC;EAC9B;EACA,MAAM,IAAIC,KAAK,CAAC,wBAAwB,GAAGR,IAAI,CAAC;AAClD","ignoreList":[]}
--- a/frontend/node_modules/@babel/types/lib/builders/generated/index.js
+++ b/frontend/node_modules/@babel/types/lib/builders/generated/index.js
@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _lowercase = require("./lowercase.js");
+Object.keys(_lowercase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _lowercase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _lowercase[key];
+    }
+  });
+});
+var _uppercase = require("./uppercase.js");
+Object.keys(_uppercase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _uppercase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _uppercase[key];
+    }
+  });
+});
+
+//# sourceMappingURL=index.js.map
--- a/frontend/node_modules/@babel/types/lib/builders/generated/index.js.map
+++ b/frontend/node_modules/@babel/types/lib/builders/generated/index.js.map
--- a/frontend/node_modules/@babel/types/lib/builders/generated/lowercase.js
+++ b/frontend/node_modules/@babel/types/lib/builders/generated/lowercase.js
--- a/frontend/node_modules/@babel/types/lib/builders/generated/lowercase.js.map
+++ b/frontend/node_modules/@babel/types/lib/builders/generated/lowercase.js.map
--- a/frontend/node_modules/@babel/types/lib/builders/generated/uppercase.js
+++ b/frontend/node_modules/@babel/types/lib/builders/generated/uppercase.js
@ -0,0 +1,274 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JSXIdentifier = exports.JSXFragment = exports.JSXExpressionContainer = exports.JSXEmptyExpression = exports.JSXElement = exports.JSXClosingFragment = exports.JSXClosingElement = exports.JSXAttribute = exports.IntersectionTypeAnnotation = exports.InterpreterDirective = exports.InterfaceTypeAnnotation = exports.InterfaceExtends = exports.InterfaceDeclaration = exports.InferredPredicate = exports.IndexedAccessType = exports.ImportSpecifier = exports.ImportNamespaceSpecifier = exports.ImportExpression = exports.ImportDefaultSpecifier = exports.ImportDeclaration = exports.ImportAttribute = exports.Import = exports.IfStatement = exports.Identifier = exports.GenericTypeAnnotation = exports.FunctionTypeParam = exports.FunctionTypeAnnotation = exports.FunctionExpression = exports.FunctionDeclaration = exports.ForStatement = exports.ForOfStatement = exports.ForInStatement = exports.File = exports.ExpressionStatement = exports.ExportSpecifier = exports.ExportNamespaceSpecifier = exports.ExportNamedDeclaration = exports.ExportDefaultSpecifier = exports.ExportDefaultDeclaration = exports.ExportAllDeclaration = exports.ExistsTypeAnnotation = exports.EnumSymbolBody = exports.EnumStringMember = exports.EnumStringBody = exports.EnumNumberMember = exports.EnumNumberBody = exports.EnumDefaultedMember = exports.EnumDeclaration = exports.EnumBooleanMember = exports.EnumBooleanBody = exports.EmptyTypeAnnotation = exports.EmptyStatement = exports.DoWhileStatement = exports.DoExpression = exports.DirectiveLiteral = exports.Directive = exports.Decorator = exports.DeclaredPredicate = exports.DeclareVariable = exports.DeclareTypeAlias = exports.DeclareOpaqueType = exports.DeclareModuleExports = exports.DeclareModule = exports.DeclareInterface = exports.DeclareFunction = exports.DeclareExportDeclaration = exports.DeclareExportAllDeclaration = exports.DeclareClass = exports.DecimalLiteral = exports.DebuggerStatement = exports.ContinueStatement = exports.ConditionalExpression = exports.ClassProperty = exports.ClassPrivateProperty = exports.ClassPrivateMethod = exports.ClassMethod = exports.ClassImplements = exports.ClassExpression = exports.ClassDeclaration = exports.ClassBody = exports.ClassAccessorProperty = exports.CatchClause = exports.CallExpression = exports.BreakStatement = exports.BooleanTypeAnnotation = exports.BooleanLiteralTypeAnnotation = exports.BooleanLiteral = exports.BlockStatement = exports.BindExpression = exports.BinaryExpression = exports.BigIntLiteral = exports.AwaitExpression = exports.AssignmentPattern = exports.AssignmentExpression = exports.ArrowFunctionExpression = exports.ArrayTypeAnnotation = exports.ArrayPattern = exports.ArrayExpression = exports.ArgumentPlaceholder = exports.AnyTypeAnnotation = void 0;
+exports.TSNumberKeyword = exports.TSNullKeyword = exports.TSNonNullExpression = exports.TSNeverKeyword = exports.TSNamespaceExportDeclaration = exports.TSNamedTupleMember = exports.TSModuleDeclaration = exports.TSModuleBlock = exports.TSMethodSignature = exports.TSMappedType = exports.TSLiteralType = exports.TSIntrinsicKeyword = exports.TSIntersectionType = exports.TSInterfaceDeclaration = exports.TSInterfaceBody = exports.TSInstantiationExpression = exports.TSInferType = exports.TSIndexedAccessType = exports.TSIndexSignature = exports.TSImportType = exports.TSImportEqualsDeclaration = exports.TSFunctionType = exports.TSExternalModuleReference = exports.TSExpressionWithTypeArguments = exports.TSExportAssignment = exports.TSEnumMember = exports.TSEnumDeclaration = exports.TSEnumBody = exports.TSDeclareMethod = exports.TSDeclareFunction = exports.TSConstructorType = exports.TSConstructSignatureDeclaration = exports.TSConditionalType = exports.TSCallSignatureDeclaration = exports.TSBooleanKeyword = exports.TSBigIntKeyword = exports.TSAsExpression = exports.TSArrayType = exports.TSAnyKeyword = exports.SymbolTypeAnnotation = exports.SwitchStatement = exports.SwitchCase = exports.Super = exports.StringTypeAnnotation = exports.StringLiteralTypeAnnotation = exports.StringLiteral = exports.StaticBlock = exports.SpreadProperty = exports.SpreadElement = exports.SequenceExpression = exports.ReturnStatement = exports.RestProperty = exports.RestElement = exports.RegexLiteral = exports.RegExpLiteral = exports.RecordExpression = exports.QualifiedTypeIdentifier = exports.Program = exports.PrivateName = exports.Placeholder = exports.PipelineTopicExpression = exports.PipelinePrimaryTopicReference = exports.PipelineBareFunction = exports.ParenthesizedExpression = exports.OptionalMemberExpression = exports.OptionalIndexedAccessType = exports.OptionalCallExpression = exports.OpaqueType = exports.ObjectTypeSpreadProperty = exports.ObjectTypeProperty = exports.ObjectTypeInternalSlot = exports.ObjectTypeIndexer = exports.ObjectTypeCallProperty = exports.ObjectTypeAnnotation = exports.ObjectProperty = exports.ObjectPattern = exports.ObjectMethod = exports.ObjectExpression = exports.NumericLiteral = exports.NumberTypeAnnotation = exports.NumberLiteralTypeAnnotation = exports.NumberLiteral = exports.NullableTypeAnnotation = exports.NullLiteralTypeAnnotation = exports.NullLiteral = exports.Noop = exports.NewExpression = exports.ModuleExpression = exports.MixedTypeAnnotation = exports.MetaProperty = exports.MemberExpression = exports.LogicalExpression = exports.LabeledStatement = exports.JSXText = exports.JSXSpreadChild = exports.JSXSpreadAttribute = exports.JSXOpeningFragment = exports.JSXOpeningElement = exports.JSXNamespacedName = exports.JSXMemberExpression = void 0;
+exports.YieldExpression = exports.WithStatement = exports.WhileStatement = exports.VoidTypeAnnotation = exports.VoidPattern = exports.Variance = exports.VariableDeclarator = exports.VariableDeclaration = exports.V8IntrinsicIdentifier = exports.UpdateExpression = exports.UnionTypeAnnotation = exports.UnaryExpression = exports.TypeofTypeAnnotation = exports.TypeParameterInstantiation = exports.TypeParameterDeclaration = exports.TypeParameter = exports.TypeCastExpression = exports.TypeAnnotation = exports.TypeAlias = exports.TupleTypeAnnotation = exports.TupleExpression = exports.TryStatement = exports.TopicReference = exports.ThrowStatement = exports.ThisTypeAnnotation = exports.ThisExpression = exports.TemplateLiteral = exports.TemplateElement = exports.TaggedTemplateExpression = exports.TSVoidKeyword = exports.TSUnknownKeyword = exports.TSUnionType = exports.TSUndefinedKeyword = exports.TSTypeReference = exports.TSTypeQuery = exports.TSTypePredicate = exports.TSTypeParameterInstantiation = exports.TSTypeParameterDeclaration = exports.TSTypeParameter = exports.TSTypeOperator = exports.TSTypeLiteral = exports.TSTypeAssertion = exports.TSTypeAnnotation = exports.TSTypeAliasDeclaration = exports.TSTupleType = exports.TSThisType = exports.TSTemplateLiteralType = exports.TSSymbolKeyword = exports.TSStringKeyword = exports.TSSatisfiesExpression = exports.TSRestType = exports.TSQualifiedName = exports.TSPropertySignature = exports.TSParenthesizedType = exports.TSParameterProperty = exports.TSOptionalType = exports.TSObjectKeyword = void 0;
+var b = require("./lowercase.js");
+var _deprecationWarning = require("../../utils/deprecationWarning.js");
+function alias(lowercase) {
+  {
+    return b[lowercase];
+  }
+}
+const ArrayExpression = exports.ArrayExpression = alias("arrayExpression"),
+  AssignmentExpression = exports.AssignmentExpression = alias("assignmentExpression"),
+  BinaryExpression = exports.BinaryExpression = alias("binaryExpression"),
+  InterpreterDirective = exports.InterpreterDirective = alias("interpreterDirective"),
+  Directive = exports.Directive = alias("directive"),
+  DirectiveLiteral = exports.DirectiveLiteral = alias("directiveLiteral"),
+  BlockStatement = exports.BlockStatement = alias("blockStatement"),
+  BreakStatement = exports.BreakStatement = alias("breakStatement"),
+  CallExpression = exports.CallExpression = alias("callExpression"),
+  CatchClause = exports.CatchClause = alias("catchClause"),
+  ConditionalExpression = exports.ConditionalExpression = alias("conditionalExpression"),
+  ContinueStatement = exports.ContinueStatement = alias("continueStatement"),
+  DebuggerStatement = exports.DebuggerStatement = alias("debuggerStatement"),
+  DoWhileStatement = exports.DoWhileStatement = alias("doWhileStatement"),
+  EmptyStatement = exports.EmptyStatement = alias("emptyStatement"),
+  ExpressionStatement = exports.ExpressionStatement = alias("expressionStatement"),
+  File = exports.File = alias("file"),
+  ForInStatement = exports.ForInStatement = alias("forInStatement"),
+  ForStatement = exports.ForStatement = alias("forStatement"),
+  FunctionDeclaration = exports.FunctionDeclaration = alias("functionDeclaration"),
+  FunctionExpression = exports.FunctionExpression = alias("functionExpression"),
+  Identifier = exports.Identifier = alias("identifier"),
+  IfStatement = exports.IfStatement = alias("ifStatement"),
+  LabeledStatement = exports.LabeledStatement = alias("labeledStatement"),
+  StringLiteral = exports.StringLiteral = alias("stringLiteral"),
+  NumericLiteral = exports.NumericLiteral = alias("numericLiteral"),
+  NullLiteral = exports.NullLiteral = alias("nullLiteral"),
+  BooleanLiteral = exports.BooleanLiteral = alias("booleanLiteral"),
+  RegExpLiteral = exports.RegExpLiteral = alias("regExpLiteral"),
+  LogicalExpression = exports.LogicalExpression = alias("logicalExpression"),
+  MemberExpression = exports.MemberExpression = alias("memberExpression"),
+  NewExpression = exports.NewExpression = alias("newExpression"),
+  Program = exports.Program = alias("program"),
+  ObjectExpression = exports.ObjectExpression = alias("objectExpression"),
+  ObjectMethod = exports.ObjectMethod = alias("objectMethod"),
+  ObjectProperty = exports.ObjectProperty = alias("objectProperty"),
+  RestElement = exports.RestElement = alias("restElement"),
+  ReturnStatement = exports.ReturnStatement = alias("returnStatement"),
+  SequenceExpression = exports.SequenceExpression = alias("sequenceExpression"),
+  ParenthesizedExpression = exports.ParenthesizedExpression = alias("parenthesizedExpression"),
+  SwitchCase = exports.SwitchCase = alias("switchCase"),
+  SwitchStatement = exports.SwitchStatement = alias("switchStatement"),
+  ThisExpression = exports.ThisExpression = alias("thisExpression"),
+  ThrowStatement = exports.ThrowStatement = alias("throwStatement"),
+  TryStatement = exports.TryStatement = alias("tryStatement"),
+  UnaryExpression = exports.UnaryExpression = alias("unaryExpression"),
+  UpdateExpression = exports.UpdateExpression = alias("updateExpression"),
+  VariableDeclaration = exports.VariableDeclaration = alias("variableDeclaration"),
+  VariableDeclarator = exports.VariableDeclarator = alias("variableDeclarator"),
+  WhileStatement = exports.WhileStatement = alias("whileStatement"),
+  WithStatement = exports.WithStatement = alias("withStatement"),
+  AssignmentPattern = exports.AssignmentPattern = alias("assignmentPattern"),
+  ArrayPattern = exports.ArrayPattern = alias("arrayPattern"),
+  ArrowFunctionExpression = exports.ArrowFunctionExpression = alias("arrowFunctionExpression"),
+  ClassBody = exports.ClassBody = alias("classBody"),
+  ClassExpression = exports.ClassExpression = alias("classExpression"),
+  ClassDeclaration = exports.ClassDeclaration = alias("classDeclaration"),
+  ExportAllDeclaration = exports.ExportAllDeclaration = alias("exportAllDeclaration"),
+  ExportDefaultDeclaration = exports.ExportDefaultDeclaration = alias("exportDefaultDeclaration"),
+  ExportNamedDeclaration = exports.ExportNamedDeclaration = alias("exportNamedDeclaration"),
+  ExportSpecifier = exports.ExportSpecifier = alias("exportSpecifier"),
+  ForOfStatement = exports.ForOfStatement = alias("forOfStatement"),
+  ImportDeclaration = exports.ImportDeclaration = alias("importDeclaration"),
+  ImportDefaultSpecifier = exports.ImportDefaultSpecifier = alias("importDefaultSpecifier"),
+  ImportNamespaceSpecifier = exports.ImportNamespaceSpecifier = alias("importNamespaceSpecifier"),
+  ImportSpecifier = exports.ImportSpecifier = alias("importSpecifier"),
+  ImportExpression = exports.ImportExpression = alias("importExpression"),
+  MetaProperty = exports.MetaProperty = alias("metaProperty"),
+  ClassMethod = exports.ClassMethod = alias("classMethod"),
+  ObjectPattern = exports.ObjectPattern = alias("objectPattern"),
+  SpreadElement = exports.SpreadElement = alias("spreadElement"),
+  Super = exports.Super = alias("super"),
+  TaggedTemplateExpression = exports.TaggedTemplateExpression = alias("taggedTemplateExpression"),
+  TemplateElement = exports.TemplateElement = alias("templateElement"),
+  TemplateLiteral = exports.TemplateLiteral = alias("templateLiteral"),
+  YieldExpression = exports.YieldExpression = alias("yieldExpression"),
+  AwaitExpression = exports.AwaitExpression = alias("awaitExpression"),
+  Import = exports.Import = alias("import"),
+  BigIntLiteral = exports.BigIntLiteral = alias("bigIntLiteral"),
+  ExportNamespaceSpecifier = exports.ExportNamespaceSpecifier = alias("exportNamespaceSpecifier"),
+  OptionalMemberExpression = exports.OptionalMemberExpression = alias("optionalMemberExpression"),
+  OptionalCallExpression = exports.OptionalCallExpression = alias("optionalCallExpression"),
+  ClassProperty = exports.ClassProperty = alias("classProperty"),
+  ClassAccessorProperty = exports.ClassAccessorProperty = alias("classAccessorProperty"),
+  ClassPrivateProperty = exports.ClassPrivateProperty = alias("classPrivateProperty"),
+  ClassPrivateMethod = exports.ClassPrivateMethod = alias("classPrivateMethod"),
+  PrivateName = exports.PrivateName = alias("privateName"),
+  StaticBlock = exports.StaticBlock = alias("staticBlock"),
+  ImportAttribute = exports.ImportAttribute = alias("importAttribute"),
+  AnyTypeAnnotation = exports.AnyTypeAnnotation = alias("anyTypeAnnotation"),
+  ArrayTypeAnnotation = exports.ArrayTypeAnnotation = alias("arrayTypeAnnotation"),
+  BooleanTypeAnnotation = exports.BooleanTypeAnnotation = alias("booleanTypeAnnotation"),
+  BooleanLiteralTypeAnnotation = exports.BooleanLiteralTypeAnnotation = alias("booleanLiteralTypeAnnotation"),
+  NullLiteralTypeAnnotation = exports.NullLiteralTypeAnnotation = alias("nullLiteralTypeAnnotation"),
+  ClassImplements = exports.ClassImplements = alias("classImplements"),
+  DeclareClass = exports.DeclareClass = alias("declareClass"),
+  DeclareFunction = exports.DeclareFunction = alias("declareFunction"),
+  DeclareInterface = exports.DeclareInterface = alias("declareInterface"),
+  DeclareModule = exports.DeclareModule = alias("declareModule"),
+  DeclareModuleExports = exports.DeclareModuleExports = alias("declareModuleExports"),
+  DeclareTypeAlias = exports.DeclareTypeAlias = alias("declareTypeAlias"),
+  DeclareOpaqueType = exports.DeclareOpaqueType = alias("declareOpaqueType"),
+  DeclareVariable = exports.DeclareVariable = alias("declareVariable"),
+  DeclareExportDeclaration = exports.DeclareExportDeclaration = alias("declareExportDeclaration"),
+  DeclareExportAllDeclaration = exports.DeclareExportAllDeclaration = alias("declareExportAllDeclaration"),
+  DeclaredPredicate = exports.DeclaredPredicate = alias("declaredPredicate"),
+  ExistsTypeAnnotation = exports.ExistsTypeAnnotation = alias("existsTypeAnnotation"),
+  FunctionTypeAnnotation = exports.FunctionTypeAnnotation = alias("functionTypeAnnotation"),
+  FunctionTypeParam = exports.FunctionTypeParam = alias("functionTypeParam"),
+  GenericTypeAnnotation = exports.GenericTypeAnnotation = alias("genericTypeAnnotation"),
+  InferredPredicate = exports.InferredPredicate = alias("inferredPredicate"),
+  InterfaceExtends = exports.InterfaceExtends = alias("interfaceExtends"),
+  InterfaceDeclaration = exports.InterfaceDeclaration = alias("interfaceDeclaration"),
+  InterfaceTypeAnnotation = exports.InterfaceTypeAnnotation = alias("interfaceTypeAnnotation"),
+  IntersectionTypeAnnotation = exports.IntersectionTypeAnnotation = alias("intersectionTypeAnnotation"),
+  MixedTypeAnnotation = exports.MixedTypeAnnotation = alias("mixedTypeAnnotation"),
+  EmptyTypeAnnotation = exports.EmptyTypeAnnotation = alias("emptyTypeAnnotation"),
+  NullableTypeAnnotation = exports.NullableTypeAnnotation = alias("nullableTypeAnnotation"),
+  NumberLiteralTypeAnnotation = exports.NumberLiteralTypeAnnotation = alias("numberLiteralTypeAnnotation"),
+  NumberTypeAnnotation = exports.NumberTypeAnnotation = alias("numberTypeAnnotation"),
+  ObjectTypeAnnotation = exports.ObjectTypeAnnotation = alias("objectTypeAnnotation"),
+  ObjectTypeInternalSlot = exports.ObjectTypeInternalSlot = alias("objectTypeInternalSlot"),
+  ObjectTypeCallProperty = exports.ObjectTypeCallProperty = alias("objectTypeCallProperty"),
+  ObjectTypeIndexer = exports.ObjectTypeIndexer = alias("objectTypeIndexer"),
+  ObjectTypeProperty = exports.ObjectTypeProperty = alias("objectTypeProperty"),
+  ObjectTypeSpreadProperty = exports.ObjectTypeSpreadProperty = alias("objectTypeSpreadProperty"),
+  OpaqueType = exports.OpaqueType = alias("opaqueType"),
+  QualifiedTypeIdentifier = exports.QualifiedTypeIdentifier = alias("qualifiedTypeIdentifier"),
+  StringLiteralTypeAnnotation = exports.StringLiteralTypeAnnotation = alias("stringLiteralTypeAnnotation"),
+  StringTypeAnnotation = exports.StringTypeAnnotation = alias("stringTypeAnnotation"),
+  SymbolTypeAnnotation = exports.SymbolTypeAnnotation = alias("symbolTypeAnnotation"),
+  ThisTypeAnnotation = exports.ThisTypeAnnotation = alias("thisTypeAnnotation"),
+  TupleTypeAnnotation = exports.TupleTypeAnnotation = alias("tupleTypeAnnotation"),
+  TypeofTypeAnnotation = exports.TypeofTypeAnnotation = alias("typeofTypeAnnotation"),
+  TypeAlias = exports.TypeAlias = alias("typeAlias"),
+  TypeAnnotation = exports.TypeAnnotation = alias("typeAnnotation"),
+  TypeCastExpression = exports.TypeCastExpression = alias("typeCastExpression"),
+  TypeParameter = exports.TypeParameter = alias("typeParameter"),
+  TypeParameterDeclaration = exports.TypeParameterDeclaration = alias("typeParameterDeclaration"),
+  TypeParameterInstantiation = exports.TypeParameterInstantiation = alias("typeParameterInstantiation"),
+  UnionTypeAnnotation = exports.UnionTypeAnnotation = alias("unionTypeAnnotation"),
+  Variance = exports.Variance = alias("variance"),
+  VoidTypeAnnotation = exports.VoidTypeAnnotation = alias("voidTypeAnnotation"),
+  EnumDeclaration = exports.EnumDeclaration = alias("enumDeclaration"),
+  EnumBooleanBody = exports.EnumBooleanBody = alias("enumBooleanBody"),
+  EnumNumberBody = exports.EnumNumberBody = alias("enumNumberBody"),
+  EnumStringBody = exports.EnumStringBody = alias("enumStringBody"),
+  EnumSymbolBody = exports.EnumSymbolBody = alias("enumSymbolBody"),
+  EnumBooleanMember = exports.EnumBooleanMember = alias("enumBooleanMember"),
+  EnumNumberMember = exports.EnumNumberMember = alias("enumNumberMember"),
+  EnumStringMember = exports.EnumStringMember = alias("enumStringMember"),
+  EnumDefaultedMember = exports.EnumDefaultedMember = alias("enumDefaultedMember"),
+  IndexedAccessType = exports.IndexedAccessType = alias("indexedAccessType"),
+  OptionalIndexedAccessType = exports.OptionalIndexedAccessType = alias("optionalIndexedAccessType"),
+  JSXAttribute = exports.JSXAttribute = alias("jsxAttribute"),
+  JSXClosingElement = exports.JSXClosingElement = alias("jsxClosingElement"),
+  JSXElement = exports.JSXElement = alias("jsxElement"),
+  JSXEmptyExpression = exports.JSXEmptyExpression = alias("jsxEmptyExpression"),
+  JSXExpressionContainer = exports.JSXExpressionContainer = alias("jsxExpressionContainer"),
+  JSXSpreadChild = exports.JSXSpreadChild = alias("jsxSpreadChild"),
+  JSXIdentifier = exports.JSXIdentifier = alias("jsxIdentifier"),
+  JSXMemberExpression = exports.JSXMemberExpression = alias("jsxMemberExpression"),
+  JSXNamespacedName = exports.JSXNamespacedName = alias("jsxNamespacedName"),
+  JSXOpeningElement = exports.JSXOpeningElement = alias("jsxOpeningElement"),
+  JSXSpreadAttribute = exports.JSXSpreadAttribute = alias("jsxSpreadAttribute"),
+  JSXText = exports.JSXText = alias("jsxText"),
+  JSXFragment = exports.JSXFragment = alias("jsxFragment"),
+  JSXOpeningFragment = exports.JSXOpeningFragment = alias("jsxOpeningFragment"),
+  JSXClosingFragment = exports.JSXClosingFragment = alias("jsxClosingFragment"),
+  Noop = exports.Noop = alias("noop"),
+  Placeholder = exports.Placeholder = alias("placeholder"),
+  V8IntrinsicIdentifier = exports.V8IntrinsicIdentifier = alias("v8IntrinsicIdentifier"),
+  ArgumentPlaceholder = exports.ArgumentPlaceholder = alias("argumentPlaceholder"),
+  BindExpression = exports.BindExpression = alias("bindExpression"),
+  Decorator = exports.Decorator = alias("decorator"),
+  DoExpression = exports.DoExpression = alias("doExpression"),
+  ExportDefaultSpecifier = exports.ExportDefaultSpecifier = alias("exportDefaultSpecifier"),
+  RecordExpression = exports.RecordExpression = alias("recordExpression"),
+  TupleExpression = exports.TupleExpression = alias("tupleExpression"),
+  DecimalLiteral = exports.DecimalLiteral = alias("decimalLiteral"),
+  ModuleExpression = exports.ModuleExpression = alias("moduleExpression"),
+  TopicReference = exports.TopicReference = alias("topicReference"),
+  PipelineTopicExpression = exports.PipelineTopicExpression = alias("pipelineTopicExpression"),
+  PipelineBareFunction = exports.PipelineBareFunction = alias("pipelineBareFunction"),
+  PipelinePrimaryTopicReference = exports.PipelinePrimaryTopicReference = alias("pipelinePrimaryTopicReference"),
+  VoidPattern = exports.VoidPattern = alias("voidPattern"),
+  TSParameterProperty = exports.TSParameterProperty = alias("tsParameterProperty"),
+  TSDeclareFunction = exports.TSDeclareFunction = alias("tsDeclareFunction"),
+  TSDeclareMethod = exports.TSDeclareMethod = alias("tsDeclareMethod"),
+  TSQualifiedName = exports.TSQualifiedName = alias("tsQualifiedName"),
+  TSCallSignatureDeclaration = exports.TSCallSignatureDeclaration = alias("tsCallSignatureDeclaration"),
+  TSConstructSignatureDeclaration = exports.TSConstructSignatureDeclaration = alias("tsConstructSignatureDeclaration"),
+  TSPropertySignature = exports.TSPropertySignature = alias("tsPropertySignature"),
+  TSMethodSignature = exports.TSMethodSignature = alias("tsMethodSignature"),
+  TSIndexSignature = exports.TSIndexSignature = alias("tsIndexSignature"),
+  TSAnyKeyword = exports.TSAnyKeyword = alias("tsAnyKeyword"),
+  TSBooleanKeyword = exports.TSBooleanKeyword = alias("tsBooleanKeyword"),
+  TSBigIntKeyword = exports.TSBigIntKeyword = alias("tsBigIntKeyword"),
+  TSIntrinsicKeyword = exports.TSIntrinsicKeyword = alias("tsIntrinsicKeyword"),
+  TSNeverKeyword = exports.TSNeverKeyword = alias("tsNeverKeyword"),
+  TSNullKeyword = exports.TSNullKeyword = alias("tsNullKeyword"),
+  TSNumberKeyword = exports.TSNumberKeyword = alias("tsNumberKeyword"),
+  TSObjectKeyword = exports.TSObjectKeyword = alias("tsObjectKeyword"),
+  TSStringKeyword = exports.TSStringKeyword = alias("tsStringKeyword"),
+  TSSymbolKeyword = exports.TSSymbolKeyword = alias("tsSymbolKeyword"),
+  TSUndefinedKeyword = exports.TSUndefinedKeyword = alias("tsUndefinedKeyword"),
+  TSUnknownKeyword = exports.TSUnknownKeyword = alias("tsUnknownKeyword"),
+  TSVoidKeyword = exports.TSVoidKeyword = alias("tsVoidKeyword"),
+  TSThisType = exports.TSThisType = alias("tsThisType"),
+  TSFunctionType = exports.TSFunctionType = alias("tsFunctionType"),
+  TSConstructorType = exports.TSConstructorType = alias("tsConstructorType"),
+  TSTypeReference = exports.TSTypeReference = alias("tsTypeReference"),
+  TSTypePredicate = exports.TSTypePredicate = alias("tsTypePredicate"),
+  TSTypeQuery = exports.TSTypeQuery = alias("tsTypeQuery"),
+  TSTypeLiteral = exports.TSTypeLiteral = alias("tsTypeLiteral"),
+  TSArrayType = exports.TSArrayType = alias("tsArrayType"),
+  TSTupleType = exports.TSTupleType = alias("tsTupleType"),
+  TSOptionalType = exports.TSOptionalType = alias("tsOptionalType"),
+  TSRestType = exports.TSRestType = alias("tsRestType"),
+  TSNamedTupleMember = exports.TSNamedTupleMember = alias("tsNamedTupleMember"),
+  TSUnionType = exports.TSUnionType = alias("tsUnionType"),
+  TSIntersectionType = exports.TSIntersectionType = alias("tsIntersectionType"),
+  TSConditionalType = exports.TSConditionalType = alias("tsConditionalType"),
+  TSInferType = exports.TSInferType = alias("tsInferType"),
+  TSParenthesizedType = exports.TSParenthesizedType = alias("tsParenthesizedType"),
+  TSTypeOperator = exports.TSTypeOperator = alias("tsTypeOperator"),
+  TSIndexedAccessType = exports.TSIndexedAccessType = alias("tsIndexedAccessType"),
+  TSMappedType = exports.TSMappedType = alias("tsMappedType"),
+  TSTemplateLiteralType = exports.TSTemplateLiteralType = alias("tsTemplateLiteralType"),
+  TSLiteralType = exports.TSLiteralType = alias("tsLiteralType"),
+  TSExpressionWithTypeArguments = exports.TSExpressionWithTypeArguments = alias("tsExpressionWithTypeArguments"),
+  TSInterfaceDeclaration = exports.TSInterfaceDeclaration = alias("tsInterfaceDeclaration"),
+  TSInterfaceBody = exports.TSInterfaceBody = alias("tsInterfaceBody"),
+  TSTypeAliasDeclaration = exports.TSTypeAliasDeclaration = alias("tsTypeAliasDeclaration"),
+  TSInstantiationExpression = exports.TSInstantiationExpression = alias("tsInstantiationExpression"),
+  TSAsExpression = exports.TSAsExpression = alias("tsAsExpression"),
+  TSSatisfiesExpression = exports.TSSatisfiesExpression = alias("tsSatisfiesExpression"),
+  TSTypeAssertion = exports.TSTypeAssertion = alias("tsTypeAssertion"),
+  TSEnumBody = exports.TSEnumBody = alias("tsEnumBody"),
+  TSEnumDeclaration = exports.TSEnumDeclaration = alias("tsEnumDeclaration"),
+  TSEnumMember = exports.TSEnumMember = alias("tsEnumMember"),
+  TSModuleDeclaration = exports.TSModuleDeclaration = alias("tsModuleDeclaration"),
+  TSModuleBlock = exports.TSModuleBlock = alias("tsModuleBlock"),
+  TSImportType = exports.TSImportType = alias("tsImportType"),
+  TSImportEqualsDeclaration = exports.TSImportEqualsDeclaration = alias("tsImportEqualsDeclaration"),
+  TSExternalModuleReference = exports.TSExternalModuleReference = alias("tsExternalModuleReference"),
+  TSNonNullExpression = exports.TSNonNullExpression = alias("tsNonNullExpression"),
+  TSExportAssignment = exports.TSExportAssignment = alias("tsExportAssignment"),
+  TSNamespaceExportDeclaration = exports.TSNamespaceExportDeclaration = alias("tsNamespaceExportDeclaration"),
+  TSTypeAnnotation = exports.TSTypeAnnotation = alias("tsTypeAnnotation"),
+  TSTypeParameterInstantiation = exports.TSTypeParameterInstantiation = alias("tsTypeParameterInstantiation"),
+  TSTypeParameterDeclaration = exports.TSTypeParameterDeclaration = alias("tsTypeParameterDeclaration"),
+  TSTypeParameter = exports.TSTypeParameter = alias("tsTypeParameter");
+const NumberLiteral = exports.NumberLiteral = b.numberLiteral,
+  RegexLiteral = exports.RegexLiteral = b.regexLiteral,
+  RestProperty = exports.RestProperty = b.restProperty,
+  SpreadProperty = exports.SpreadProperty = b.spreadProperty;
+
+//# sourceMappingURL=uppercase.js.map
--- a/frontend/node_modules/@babel/types/lib/builders/generated/uppercase.js.map
+++ b/frontend/node_modules/@babel/types/lib/builders/generated/uppercase.js.map
--- a/frontend/node_modules/@babel/types/lib/builders/productions.js
+++ b/frontend/node_modules/@babel/types/lib/builders/productions.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildUndefinedNode = buildUndefinedNode;
+var _index = require("./generated/index.js");
+function buildUndefinedNode() {
+  return (0, _index.unaryExpression)("void", (0, _index.numericLiteral)(0), true);
+}
+
+//# sourceMappingURL=productions.js.map
--- a/frontend/node_modules/@babel/types/lib/builders/productions.js.map
+++ b/frontend/node_modules/@babel/types/lib/builders/productions.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_index","require","buildUndefinedNode","unaryExpression","numericLiteral"],"sources":["../../src/builders/productions.ts"],"sourcesContent":["import { numericLiteral, unaryExpression } from \"./generated/index.ts\";\n\nexport function buildUndefinedNode() {\n  return unaryExpression(\"void\", numericLiteral(0), true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEO,SAASC,kBAAkBA,CAAA,EAAG;EACnC,OAAO,IAAAC,sBAAe,EAAC,MAAM,EAAE,IAAAC,qBAAc,EAAC,CAAC,CAAC,EAAE,IAAI,CAAC;AACzD","ignoreList":[]}
--- a/frontend/node_modules/@babel/types/lib/builders/react/buildChildren.js
+++ b/frontend/node_modules/@babel/types/lib/builders/react/buildChildren.js
@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildChildren;
+var _index = require("../../validators/generated/index.js");
+var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild.js");
+function buildChildren(node) {
+  const elements = [];
+  for (let i = 0; i < node.children.length; i++) {
+    let child = node.children[i];
+    if ((0, _index.isJSXText)(child)) {
+      (0, _cleanJSXElementLiteralChild.default)(child, elements);
+      continue;
+    }
+    if ((0, _index.isJSXExpressionContainer)(child)) child = child.expression;
+    if ((0, _index.isJSXEmptyExpression)(child)) continue;
+    elements.push(child);
+  }
+  return elements;
+}
+
+//# sourceMappingURL=buildChildren.js.map
--- a/Show More
+++ b/Show More
				`@ -0,0 +1 @@`
				`# This file ensures the static directory is tracked by git`
				`@ -0,0 +1 @@`
				{"version":3,"names":["_identifier","require","_keyword"],"sources":["../src/index.ts"],"sourcesContent":["export {\n isIdentifierName,\n isIdentifierChar,\n isIdentifierStart,\n} from \"./identifier.ts\";\nexport {\n isReservedWord,\n isStrictBindOnlyReservedWord,\n isStrictBindReservedWord,\n isStrictReservedWord,\n isKeyword,\n} from \"./keyword.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAKA,IAAAC,QAAA,GAAAD,OAAA","ignoreList":[]}
				`@ -0,0 +1 @@`
				{"version":3,"names":["reservedWords","keyword","strict","strictBind","keywords","Set","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword"],"sources":["../src/keyword.ts"],"sourcesContent":["const reservedWords = {\n keyword: [\n \"break\",\n \"case\",\n \"catch\",\n \"continue\",\n \"debugger\",\n \"default\",\n \"do\",\n \"else\",\n \"finally\",\n \"for\",\n \"function\",\n \"if\",\n \"return\",\n \"switch\",\n \"throw\",\n \"try\",\n \"var\",\n \"const\",\n \"while\",\n \"with\",\n \"new\",\n \"this\",\n \"super\",\n \"class\",\n \"extends\",\n \"export\",\n \"import\",\n \"null\",\n \"true\",\n \"false\",\n \"in\",\n \"instanceof\",\n \"typeof\",\n \"void\",\n \"delete\",\n ],\n strict: [\n \"implements\",\n \"interface\",\n \"let\",\n \"package\",\n \"private\",\n \"protected\",\n \"public\",\n \"static\",\n \"yield\",\n ],\n strictBind: [\"eval\", \"arguments\"],\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\n/*\n Checks if word is a reserved word in non-strict mode\n /\nexport function isReservedWord(word: string, inModule: boolean): boolean {\n return (inModule && word === \"await\") \|\| word === \"enum\";\n}\n\n/\n Checks if word is a reserved word in non-binding strict mode\n \n Includes non-strict reserved words\n /\nexport function isStrictReservedWord(word: string, inModule: boolean): boolean {\n return isReservedWord(word, inModule) \|\| reservedWordsStrictSet.has(word);\n}\n\n/\n Checks if word is a reserved word in binding strict mode, but it is allowed as\n * a normal identifier.\n /\nexport function isStrictBindOnlyReservedWord(word: string): boolean {\n return reservedWordsStrictBindSet.has(word);\n}\n\n/\n Checks if word is a reserved word in binding strict mode\n \n Includes non-strict reserved words and non-binding strict reserved words\n */\nexport function isStrictBindReservedWord(\n word: string,\n inModule: boolean,\n): boolean {\n return (\n isStrictReservedWord(word, inModule) \|\| isStrictBindOnlyReservedWord(word)\n );\n}\n\nexport function isKeyword(word: string): boolean {\n return keywords.has(word);\n}\n"],"mappings":";;;;;;;;;;AAAA,MAAMA,aAAa,GAAG;EACpBC,OAAO,EAAE,CACP,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,KAAK,EACL,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,CACT;EACDC,MAAM,EAAE,CACN,YAAY,EACZ,WAAW,EACX,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,CACR;EACDC,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW;AAClC,CAAC;AACD,MAAMC,QAAQ,GAAG,IAAIC,GAAG,CAACL,aAAa,CAACC,OAAO,CAAC;AAC/C,MAAMK,sBAAsB,GAAG,IAAID,GAAG,CAACL,aAAa,CAACE,MAAM,CAAC;AAC5D,MAAMK,0BAA0B,GAAG,IAAIF,GAAG,CAACL,aAAa,CAACG,UAAU,CAAC;AAK7D,SAASK,cAAcA,CAACC,IAAY,EAAEC,QAAiB,EAAW;EACvE,OAAQA,QAAQ,IAAID,IAAI,KAAK,OAAO,IAAKA,IAAI,KAAK,MAAM;AAC1D;AAOO,SAASE,oBAAoBA,CAACF,IAAY,EAAEC,QAAiB,EAAW;EAC7E,OAAOF,cAAc,CAACC,IAAI,EAAEC,QAAQ,CAAC,IAAIJ,sBAAsB,CAACM,GAAG,CAACH,IAAI,CAAC;AAC3E;AAMO,SAASI,4BAA4BA,CAACJ,IAAY,EAAW;EAClE,OAAOF,0BAA0B,CAACK,GAAG,CAACH,IAAI,CAAC;AAC7C;AAOO,SAASK,wBAAwBA,CACtCL,IAAY,EACZC,QAAiB,EACR;EACT,OACEC,oBAAoB,CAACF,IAAI,EAAEC,QAAQ,CAAC,IAAIG,4BAA4B,CAACJ,IAAI,CAAC;AAE9E;AAEO,SAASM,SAASA,CAACN,IAAY,EAAW;EAC/C,OAAOL,QAAQ,CAACQ,GAAG,CAACH,IAAI,CAAC;AAC3B","ignoreList":[]}
				`@ -0,0 +1 @@`
				{"version":3,"names":["_isNode","require","assertNode","node","isNode","_node$type","type","JSON","stringify","TypeError"],"sources":["../../src/asserts/assertNode.ts"],"sourcesContent":["import isNode from \"../validators/isNode.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function assertNode(node?: any): asserts node is t.Node {\n if (!isNode(node)) {\n const type = node?.type ?? JSON.stringify(node);\n throw new TypeError(`Not a valid node of type \"${type}\"`);\n }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAGe,SAASC,UAAUA,CAACC,IAAU,EAA0B;EACrE,IAAI,CAAC,IAAAC,eAAM,EAACD,IAAI,CAAC,EAAE;IAAA,IAAAE,UAAA;IACjB,MAAMC,IAAI,IAAAD,UAAA,GAAGF,IAAI,oBAAJA,IAAI,CAAEG,IAAI,YAAAD,UAAA,GAAIE,IAAI,CAACC,SAAS,CAACL,IAAI,CAAC;IAC/C,MAAM,IAAIM,SAAS,CAAC,6BAA6BH,IAAI,GAAG,CAAC;EAC3D;AACF","ignoreList":[]}
				`@ -0,0 +1 @@`
				{"version":3,"names":["_index","require","_removeTypeDuplicates","createFlowUnionType","types","flattened","removeTypeDuplicates","length","unionTypeAnnotation"],"sources":["../../../src/builders/flow/createFlowUnionType.ts"],"sourcesContent":["import { unionTypeAnnotation } from \"../generated/index.ts\";\nimport removeTypeDuplicates from \"../../modifications/flow/removeTypeDuplicates.ts\";\nimport type * as t from \"../../index.ts\";\n\n/*\n Takes an array of `types` and flattens them, removing duplicates and\n * returns a `UnionTypeAnnotation` node containing them.\n */\nexport default function createFlowUnionType<T extends t.FlowType>(\n types: [T] \| Array<T>,\n): T \| t.UnionTypeAnnotation {\n const flattened = removeTypeDuplicates(types);\n\n if (flattened.length === 1) {\n return flattened[0] as T;\n } else {\n return unionTypeAnnotation(flattened);\n }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AAOe,SAASE,mBAAmBA,CACzCC,KAAqB,EACM;EAC3B,MAAMC,SAAS,GAAG,IAAAC,6BAAoB,EAACF,KAAK,CAAC;EAE7C,IAAIC,SAAS,CAACE,MAAM,KAAK,CAAC,EAAE;IAC1B,OAAOF,SAAS,CAAC,CAAC,CAAC;EACrB,CAAC,MAAM;IACL,OAAO,IAAAG,0BAAmB,EAACH,SAAS,CAAC;EACvC;AACF","ignoreList":[]}