11

2025-07-28 01:04:18 +08:00 · 2025-07-28 01:04:18 +08:00 · 58da3a5bf2
commit 58da3a5bf2
1366 changed files with 684767 additions and 0 deletions
--- a/DEPLOYMENT.md
+++ b/DEPLOYMENT.md
@ -0,0 +1,263 @@
+# 🚀 WorkTime 服务器部署指南
+
+## 📋 概述
+
+WorkTime应用现在支持服务器存储，让您可以在多台设备上同步数据。本指南将帮助您部署后端服务器。
+
+## 🛠️ 服务器要求
+
+- **Node.js**: 版本 14.0.0 或更高
+- **内存**: 至少 512MB RAM
+- **存储**: 至少 100MB 可用空间
+- **网络**: 支持 HTTP/HTTPS 访问
+
+## 📦 安装步骤
+
+### 1. 安装依赖
+
+```bash
+# 安装服务器依赖
+npm install express cors
+
+# 或者使用提供的package.json
+cp package-server.json package.json
+npm install
+```
+
+### 2. 启动服务器
+
+```bash
+# 开发模式（自动重启）
+npm run dev
+
+# 生产模式
+npm start
+```
+
+### 3. 验证安装
+
+访问 `http://localhost:3001/api/health` 应该返回：
+```json
+{
+  "status": "ok",
+  "timestamp": "2024-01-01T00:00:00.000Z"
+}
+```
+
+## 🌐 生产环境部署
+
+### 使用 PM2（推荐）
+
+```bash
+# 安装PM2
+npm install -g pm2
+
+# 启动应用
+pm2 start server.js --name worktime-server
+
+# 设置开机自启
+pm2 startup
+pm2 save
+
+# 查看状态
+pm2 status
+pm2 logs worktime-server
+```
+
+### 使用 Docker
+
+```dockerfile
+FROM node:18-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm install --production
+COPY server.js ./
+EXPOSE 3001
+CMD ["node", "server.js"]
+```
+
+```bash
+# 构建镜像
+docker build -t worktime-server .
+
+# 运行容器
+docker run -d -p 3001:3001 --name worktime-server worktime-server
+```
+
+### 使用 Nginx 反向代理
+
+```nginx
+server {
+    listen 80;
+    server_name your-domain.com;
+
+    location /api/ {
+        proxy_pass http://localhost:3001;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+    }
+}
+```
+
+## 🔧 配置选项
+
+### 环境变量
+
+```bash
+# 端口配置
+PORT=3001
+
+# 数据文件路径
+DATA_FILE=/path/to/user-data.json
+
+# CORS配置
+CORS_ORIGIN=http://localhost:3000
+```
+
+### 数据文件位置
+
+默认情况下，数据文件保存在 `user-data.json`。您可以修改 `DATA_FILE` 环境变量来更改位置。
+
+## 🔒 安全考虑
+
+### 1. 身份验证（可选）
+
+如果需要多用户支持，可以添加简单的API密钥验证：
+
+```javascript
+// 在server.js中添加
+const API_KEY = process.env.API_KEY || 'your-secret-key';
+
+app.use('/api', (req, res, next) => {
+  const key = req.headers['x-api-key'];
+  if (key !== API_KEY) {
+    return res.status(401).json({ error: '未授权访问' });
+  }
+  next();
+});
+```
+
+### 2. HTTPS
+
+在生产环境中，建议使用HTTPS：
+
+```bash
+# 使用Let's Encrypt
+sudo certbot --nginx -d your-domain.com
+```
+
+### 3. 数据备份
+
+定期备份 `user-data.json` 文件：
+
+```bash
+# 创建备份脚本
+#!/bin/bash
+cp user-data.json backup/user-data-$(date +%Y%m%d-%H%M%S).json
+```
+
+## 📊 监控和维护
+
+### 日志监控
+
+```bash
+# 查看应用日志
+pm2 logs worktime-server
+
+# 查看错误日志
+pm2 logs worktime-server --err
+```
+
+### 性能监控
+
+```bash
+# 查看资源使用情况
+pm2 monit
+
+# 查看详细统计
+pm2 show worktime-server
+```
+
+### 数据备份
+
+```bash
+# 自动备份脚本
+#!/bin/bash
+BACKUP_DIR="/backup/worktime"
+DATE=$(date +%Y%m%d-%H%M%S)
+mkdir -p $BACKUP_DIR
+cp user-data.json $BACKUP_DIR/user-data-$DATE.json
+
+# 保留最近30天的备份
+find $BACKUP_DIR -name "user-data-*.json" -mtime +30 -delete
+```
+
+## 🔄 更新和维护
+
+### 更新应用
+
+```bash
+# 停止应用
+pm2 stop worktime-server
+
+# 更新代码
+git pull origin main
+
+# 安装新依赖
+npm install
+
+# 重启应用
+pm2 restart worktime-server
+```
+
+### 数据迁移
+
+如果需要迁移到新服务器：
+
+1. 停止旧服务器
+2. 复制 `user-data.json` 到新服务器
+3. 启动新服务器
+4. 更新前端配置中的服务器地址
+
+## 🆘 故障排除
+
+### 常见问题
+
+1. **端口被占用**
+   ```bash
+   # 查看端口使用情况
+   lsof -i :3001
+   
+   # 杀死占用进程
+   kill -9 <PID>
+   ```
+
+2. **权限问题**
+   ```bash
+   # 确保有写入权限
+   chmod 755 /path/to/data/directory
+   ```
+
+3. **内存不足**
+   ```bash
+   # 增加Node.js内存限制
+   pm2 start server.js --name worktime-server --node-args="--max-old-space-size=1024"
+   ```
+
+### 联系支持
+
+如果遇到问题，请检查：
+- 服务器日志
+- 网络连接
+- 文件权限
+- 磁盘空间
+
+## 📝 许可证
+
+本项目采用 MIT 许可证。 
--- a/30
+++ b/30
@ -0,0 +1,30 @@
+# 使用官方Node.js运行时作为基础镜像
+FROM node:18-alpine
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制package文件
+COPY package*.json ./
+
+# 安装依赖
+RUN npm ci --only=production
+
+# 复制源代码
+COPY . .
+
+# 构建前端应用
+RUN npm run build
+
+# 创建数据目录
+RUN mkdir -p /app/data
+
+# 暴露端口
+EXPOSE 3001
+
+# 设置环境变量
+ENV NODE_ENV=production
+ENV PORT=3001
+
+# 启动应用
+CMD ["node", "server.js"] 
--- a/PRODUCTION_DEPLOYMENT.md
+++ b/PRODUCTION_DEPLOYMENT.md
@ -0,0 +1,282 @@
+# 🚀 WorkTime 生产环境部署指南
+
+## 📋 系统要求
+
+- **Node.js**: 版本 14.0.0 或更高
+- **npm**: 版本 6.0.0 或更高
+- **内存**: 至少 512MB 可用内存
+- **存储**: 至少 100MB 可用空间
+
+## 🛠️ 快速部署
+
+### 方法1: 使用部署脚本（推荐）
+
+```bash
+# 克隆项目
+git clone <your-repository-url>
+cd WorkTime
+
+# 运行部署脚本
+./deploy.sh
+```
+
+### 方法2: 手动部署
+
+```bash
+# 1. 安装依赖
+npm install
+
+# 2. 构建前端应用
+npm run build
+
+# 3. 启动服务器
+node server.js
+```
+
+## 🌐 生产环境配置
+
+### 环境变量
+
+```bash
+# 设置端口（可选，默认为3001）
+export PORT=3001
+
+# 设置数据文件路径（可选）
+export DATA_FILE=/path/to/user-data.json
+```
+
+### 使用 PM2 管理进程（推荐）
+
+```bash
+# 安装 PM2
+npm install -g pm2
+
+# 启动应用
+pm2 start server.js --name "worktime"
+
+# 查看状态
+pm2 status
+
+# 查看日志
+pm2 logs worktime
+
+# 重启应用
+pm2 restart worktime
+
+# 停止应用
+pm2 stop worktime
+```
+
+### 使用 Docker 部署
+
+```dockerfile
+FROM node:18-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci --only=production
+
+COPY . .
+RUN npm run build
+
+EXPOSE 3001
+
+CMD ["node", "server.js"]
+```
+
+```bash
+# 构建镜像
+docker build -t worktime-app .
+
+# 运行容器
+docker run -d -p 3001:3001 --name worktime worktime-app
+```
+
+## 🔧 服务器配置
+
+### Nginx 反向代理配置
+
+```nginx
+server {
+    listen 80;
+    server_name your-domain.com;
+
+    location / {
+        proxy_pass http://localhost:3001;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+    }
+}
+```
+
+### Apache 反向代理配置
+
+```apache
+<VirtualHost *:80>
+    ServerName your-domain.com
+    
+    ProxyPreserveHost On
+    ProxyPass / http://localhost:3001/
+    ProxyPassReverse / http://localhost:3001/
+    
+    ErrorLog ${APACHE_LOG_DIR}/worktime_error.log
+    CustomLog ${APACHE_LOG_DIR}/worktime_access.log combined
+</VirtualHost>
+```
+
+## 📊 监控和维护
+
+### 健康检查
+
+```bash
+# 检查应用状态
+curl http://localhost:3001/api/health
+
+# 预期响应
+{"status":"ok","timestamp":"2025-07-27T16:59:36.507Z"}
+```
+
+### 日志管理
+
+```bash
+# 查看应用日志
+tail -f /var/log/worktime.log
+
+# 查看错误日志
+tail -f /var/log/worktime-error.log
+```
+
+### 数据备份
+
+```bash
+# 备份用户数据
+cp user-data.json backup/user-data-$(date +%Y%m%d-%H%M%S).json
+
+# 自动备份脚本
+#!/bin/bash
+BACKUP_DIR="/backup/worktime"
+mkdir -p $BACKUP_DIR
+cp user-data.json $BACKUP_DIR/user-data-$(date +%Y%m%d-%H%M%S).json
+find $BACKUP_DIR -name "*.json" -mtime +7 -delete
+```
+
+## 🔒 安全配置
+
+### 防火墙设置
+
+```bash
+# 只允许必要端口
+sudo ufw allow 22    # SSH
+sudo ufw allow 80    # HTTP
+sudo ufw allow 443   # HTTPS
+sudo ufw enable
+```
+
+### SSL 证书配置
+
+```bash
+# 使用 Let's Encrypt
+sudo certbot --nginx -d your-domain.com
+
+# 或使用自签名证书
+openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
+    -keyout private.key -out certificate.crt
+```
+
+## 📈 性能优化
+
+### 启用 Gzip 压缩
+
+在 Nginx 配置中添加：
+
+```nginx
+gzip on;
+gzip_vary on;
+gzip_min_length 1024;
+gzip_types text/plain text/css text/xml text/javascript application/javascript application/xml+rss application/json;
+```
+
+### 缓存配置
+
+```nginx
+# 静态资源缓存
+location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg)$ {
+    expires 1y;
+    add_header Cache-Control "public, immutable";
+}
+```
+
+## 🚨 故障排除
+
+### 常见问题
+
+1. **端口被占用**
+   ```bash
+   # 检查端口占用
+   netstat -tlnp | grep 3001
+   
+   # 杀死占用进程
+   sudo kill -9 <PID>
+   ```
+
+2. **权限问题**
+   ```bash
+   # 确保数据文件可写
+   chmod 644 user-data.json
+   chown www-data:www-data user-data.json
+   ```
+
+3. **内存不足**
+   ```bash
+   # 增加 Node.js 内存限制
+   node --max-old-space-size=1024 server.js
+   ```
+
+### 日志分析
+
+```bash
+# 查看错误日志
+grep "ERROR" /var/log/worktime.log
+
+# 查看访问统计
+awk '{print $1}' /var/log/worktime.log | sort | uniq -c | sort -nr
+```
+
+## 📞 技术支持
+
+如果遇到问题，请检查：
+
+1. 应用日志文件
+2. 系统资源使用情况
+3. 网络连接状态
+4. 数据库文件权限
+
+## 🔄 更新部署
+
+```bash
+# 1. 停止应用
+pm2 stop worktime
+
+# 2. 拉取最新代码
+git pull origin main
+
+# 3. 安装依赖
+npm install
+
+# 4. 重新构建
+npm run build
+
+# 5. 重启应用
+pm2 restart worktime
+```
+
+---
+
+**注意**: 请根据您的具体环境和需求调整配置参数。 
--- a/README.md
+++ b/README.md
@ -0,0 +1,197 @@
+# 滴答清单 - Vue3 任务管理应用
+
+一个基于 Vue3 的现代化任务管理应用，提供直观的用户界面和完整的功能。
+
+## ✨ 功能特性
+
+- 📝 **任务管理**: 添加、编辑、删除任务
+- ✅ **任务完成**: 一键标记任务完成状态
+- 📁 **项目管理**: 创建和管理多个项目，每个任务归属于特定项目
+- 🏷️ **任务类型**: 支持需求分析、文档编写、开发代码、测试、运维等类型
+- 🎯 **优先级设置**: 支持高、中、低三个优先级
+- ⏰ **时间管理**: 设置任务的开始时间和结束时间，自动计算工作时长
+- ⏱️ **计时器功能**: 为没有设置时间的任务提供计时器，自动统计工作时长
+- 📊 **工作分析**: 实时分析每日工作分布，包括项目分布、类型分布和时间统计
+- 🔍 **任务过滤**: 按项目、状态和类型筛选任务
+- 📈 **统计信息**: 实时显示任务完成情况和今日工作统计
+- 💾 **数据管理**: 支持JSON格式的数据导出、导入和清空功能
+- 🗂️ **菜单系统**: 清晰的功能分区，包括任务管理、工作分析和数据管理
+- ⛶ **全屏模式**: 支持浏览器宽度全屏显示，充分利用屏幕空间
+- ☁️ **服务器同步**: 支持多设备数据同步，数据安全存储在服务器
+- 🔄 **本地存储**: 数据自动保存到浏览器本地存储，支持数据备份和恢复
+- 📱 **响应式设计**: 完美适配桌面和移动设备
+- 🎨 **现代化UI**: 美观的渐变背景和卡片式设计
+
+## 🚀 快速开始
+
+### 安装依赖
+
+```bash
+npm install
+```
+
+### 启动开发服务器
+
+```bash
+npm run dev
+```
+
+应用将在 `http://localhost:3000` 启动
+
+### 构建生产版本
+
+```bash
+npm run build
+```
+
+### 预览生产版本
+
+```bash
+npm run preview
+```
+
+## 🛠️ 技术栈
+
+- **Vue 3**: 使用 Composition API
+- **Vite**: 快速的构建工具
+- **VueUse**: 实用的 Vue 组合式函数
+- **CSS3**: 现代化的样式设计
+- **Node.js**: 后端服务器
+- **Express**: Web 框架
+- **Docker**: 容器化部署
+
+## 🚀 快速部署
+
+### 本地开发
+```bash
+# 安装依赖
+npm install
+
+# 启动开发服务器
+npm run dev
+```
+
+### 生产部署
+```bash
+# 使用部署脚本（推荐）
+./deploy.sh
+
+# 或手动部署
+npm install
+npm run build
+node server.js
+```
+
+### Docker 部署
+```bash
+# 使用 Docker Compose
+docker-compose up -d
+
+# 或使用 Docker
+docker build -t worktime-app .
+docker run -d -p 3001:3001 worktime-app
+```
+
+详细部署说明请参考 [PRODUCTION_DEPLOYMENT.md](./PRODUCTION_DEPLOYMENT.md)
+
+## 📁 项目结构
+
+```
+WorkTime/
+├── src/
+│   ├── App.vue          # 主应用组件
+│   ├── main.js          # 应用入口
+│   └── style.css        # 全局样式
+├── dist/                # 构建输出目录
+├── index.html           # HTML 模板
+├── package.json         # 项目配置
+├── vite.config.js       # Vite 配置
+├── server.js            # 后端服务器
+├── Dockerfile           # Docker 配置
+├── docker-compose.yml   # Docker Compose 配置
+├── deploy.sh            # 部署脚本
+├── test-deployment.sh   # 部署测试脚本
+├── example-data.json    # 示例数据文件
+├── user-data.json       # 用户数据文件
+├── PRODUCTION_DEPLOYMENT.md  # 生产部署指南
+└── README.md           # 项目说明
+```
+
+## 🎯 使用说明
+
+1. **功能导航**: 使用顶部菜单在"任务管理"、"工作分析"、"数据管理"之间切换
+2. **创建项目**: 在任务管理页面点击"新建项目"按钮创建新项目
+3. **选择项目**: 点击项目列表中的项目进行切换
+4. **添加任务**: 在输入框中输入任务内容，选择项目、任务类型、优先级和时间，点击"添加"按钮
+5. **使用计时器**: 对于没有设置时间的任务，点击▶️按钮开始计时，点击⏹️按钮停止计时
+6. **完成任务**: 点击任务前的圆形复选框标记完成
+7. **编辑任务**: 点击任务右侧的编辑按钮进行修改
+8. **删除任务**: 点击任务右侧的删除按钮移除任务
+9. **过滤任务**: 使用过滤器按钮查看不同项目、状态和类型的任务
+10. **查看分析**: 切换到"工作分析"页面查看工作统计和分析
+11. **数据管理**: 切换到"数据管理"页面导出、导入或清空数据
+
+## 💡 特色功能
+
+- **智能日期显示**: 自动显示"今天"、"昨天"、"X天前"等相对时间
+- **时间管理**: 支持设置任务的开始和结束时间，自动计算工作时长
+- **计时器功能**: 为没有设置时间的任务提供实时计时器，支持开始/停止/累计计时
+- **工作分析**: 实时分析每日工作分布，包括项目分布、类型分布和时间统计
+- **项目管理**: 支持多项目管理，每个项目独立显示任务数量
+- **任务类型标识**: 不同颜色的标签区分任务类型
+- **项目标签**: 每个任务显示所属项目名称
+- **悬停效果**: 鼠标悬停时显示操作按钮
+- **键盘快捷键**: 支持回车键添加任务，ESC键取消编辑
+- **空状态提示**: 根据不同情况显示相应的鼓励信息
+
+- **数据备份**: 支持JSON格式的数据导出和导入，便于数据备份和迁移
+- **菜单导航**: 清晰的功能分区，提供更好的用户体验和功能组织
+- **全屏体验**: 支持一键切换浏览器宽度全屏，充分利用屏幕空间
+- **云端同步**: 支持服务器存储和多设备同步，确保数据安全
+
+## 🔧 自定义配置
+
+可以通过修改 `src/style.css` 文件来自定义应用的外观，包括：
+- 颜色主题
+- 字体样式
+- 布局尺寸
+- 动画效果
+
+## 📁 数据格式
+
+应用使用JSON格式存储数据，包含以下结构：
+
+```json
+{
+  "tasks": [
+    {
+      "id": 1703123456789,
+      "text": "任务内容",
+      "projectId": "project-1",
+      "type": "development",
+      "completed": false,
+      "priority": "high",
+      "startTime": "2023-12-20T09:00",
+      "endTime": "2023-12-20T11:00",
+      "timerRunning": false,
+      "timerStartTime": null,
+      "timerDuration": null,
+      "createdAt": "2023-12-20T09:00:00.000Z",
+      "editing": false
+    }
+  ],
+  "projects": [
+    {
+      "id": "project-1",
+      "name": "项目名称",
+      "createdAt": "2023-12-18T10:00:00.000Z"
+    }
+  ],
+  "exportDate": "2023-12-20T16:30:00.000Z",
+  "version": "1.0.0"
+}
+```
+
+## <20><> 许可证
+
+MIT License 
--- a/deploy.sh
+++ b/deploy.sh
@ -0,0 +1,30 @@
+#!/bin/bash
+
+echo "🚀 开始部署 WorkTime 应用..."
+
+# 检查Node.js是否安装
+if ! command -v node &> /dev/null; then
+    echo "❌ Node.js 未安装，请先安装 Node.js"
+    exit 1
+fi
+
+# 检查npm是否安装
+if ! command -v npm &> /dev/null; then
+    echo "❌ npm 未安装，请先安装 npm"
+    exit 1
+fi
+
+echo "📦 安装依赖..."
+npm install
+
+echo "🔨 构建前端应用..."
+npm run build
+
+echo "🚀 启动服务器..."
+echo "📱 应用地址: http://localhost:3001"
+echo "🔧 API健康检查: http://localhost:3001/api/health"
+echo ""
+echo "按 Ctrl+C 停止服务器"
+
+# 启动服务器
+node server.js 
--- a/dist/assets/index-2e6a5b77.js
+++ b/dist/assets/index-2e6a5b77.js
--- a/dist/assets/index-d9a96dc9.css
+++ b/dist/assets/index-d9a96dc9.css
--- a/dist/index.html
+++ b/dist/index.html
@ -0,0 +1,15 @@
+<!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>
+    <script type="module" crossorigin src="/assets/index-2e6a5b77.js"></script>
+    <link rel="stylesheet" href="/assets/index-d9a96dc9.css">
+  </head>
+  <body>
+    <div id="app"></div>
+    
+  </body>
+</html> 
--- a/docker-compose.yml
+++ b/docker-compose.yml
@ -0,0 +1,20 @@
+version: '3.8'
+
+services:
+  worktime:
+    build: .
+    ports:
+      - "3001:3001"
+    volumes:
+      - ./data:/app/data
+      - ./user-data.json:/app/user-data.json
+    environment:
+      - NODE_ENV=production
+      - PORT=3001
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3001/api/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s 
--- a/example-data.json
+++ b/example-data.json
@ -0,0 +1,88 @@
+{
+  "tasks": [
+    {
+      "id": 1703123456789,
+      "text": "分析用户需求文档",
+      "projectId": "project-1",
+      "type": "requirement",
+      "completed": false,
+      "priority": "high",
+      "startTime": "2023-12-20T09:00",
+      "endTime": "2023-12-20T11:00",
+      "timerRunning": false,
+      "timerStartTime": null,
+      "timerDuration": null,
+      "createdAt": "2023-12-20T09:00:00.000Z",
+      "editing": false
+    },
+    {
+      "id": 1703123456790,
+      "text": "编写API接口文档",
+      "projectId": "project-1",
+      "type": "documentation",
+      "completed": true,
+      "priority": "medium",
+      "startTime": "2023-12-20T14:00",
+      "endTime": "2023-12-20T17:00",
+      "timerRunning": false,
+      "timerStartTime": null,
+      "timerDuration": null,
+      "createdAt": "2023-12-20T14:00:00.000Z",
+      "editing": false
+    },
+    {
+      "id": 1703123456791,
+      "text": "实现用户登录功能",
+      "projectId": "project-1",
+      "type": "development",
+      "completed": false,
+      "priority": "high",
+      "startTime": null,
+      "endTime": null,
+      "timerRunning": false,
+      "timerStartTime": null,
+      "timerDuration": 3600,
+      "createdAt": "2023-12-20T10:00:00.000Z",
+      "editing": false
+    },
+    {
+      "id": 1703123456792,
+      "text": "进行单元测试",
+      "projectId": "project-2",
+      "type": "testing",
+      "completed": true,
+      "priority": "medium",
+      "startTime": null,
+      "endTime": null,
+      "timerRunning": false,
+      "timerStartTime": null,
+      "timerDuration": 1800,
+      "createdAt": "2023-12-20T15:00:00.000Z",
+      "editing": false
+    },
+    {
+      "id": 1703123456793,
+      "text": "部署到生产环境",
+      "projectId": "project-2",
+      "type": "operation",
+      "completed": false,
+      "priority": "low",
+      "startTime": null,
+      "endTime": null,
+      "timerRunning": false,
+      "timerStartTime": null,
+      "timerDuration": null,
+      "createdAt": "2023-12-20T16:00:00.000Z",
+      "editing": false
+    }
+  ],
+  "projects": [
+    {
+      "id": "SPMS",
+      "name": "SPMS项目",
+      "createdAt": "2023-12-18T10:00:00.000Z"
+    }
+  ],
+  "exportDate": "2023-12-20T16:30:00.000Z",
+  "version": "1.0.0"
+} 
--- a/index.html
+++ b/index.html
@ -0,0 +1,13 @@
+<!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>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html> 
--- a/node_modules/.bin/esbuild
+++ b/node_modules/.bin/esbuild
@ -0,0 +1 @@
+../esbuild/bin/esbuild
--- a/node_modules/.bin/mime
+++ b/node_modules/.bin/mime
@ -0,0 +1 @@
+../mime/cli.js
--- a/node_modules/.bin/nanoid
+++ b/node_modules/.bin/nanoid
@ -0,0 +1 @@
+../nanoid/bin/nanoid.cjs
--- a/node_modules/.bin/parser
+++ b/node_modules/.bin/parser
@ -0,0 +1 @@
+../@babel/parser/bin/babel-parser.js
--- a/node_modules/.bin/rollup
+++ b/node_modules/.bin/rollup
@ -0,0 +1 @@
+../rollup/dist/bin/rollup
--- a/node_modules/.bin/vite
+++ b/node_modules/.bin/vite
@ -0,0 +1 @@
+../vite/bin/vite.js
--- a/node_modules/.package-lock.json
+++ b/node_modules/.package-lock.json
--- a/node_modules/.vite/deps/@vueuse_core.js
+++ b/node_modules/.vite/deps/@vueuse_core.js
--- a/node_modules/.vite/deps/@vueuse_core.js.map
+++ b/node_modules/.vite/deps/@vueuse_core.js.map
--- a/node_modules/.vite/deps/_metadata.json
+++ b/node_modules/.vite/deps/_metadata.json
@ -0,0 +1,23 @@
+{
+  "hash": "82e16c66",
+  "browserHash": "24587afd",
+  "optimized": {
+    "@vueuse/core": {
+      "src": "../../@vueuse/core/index.mjs",
+      "file": "@vueuse_core.js",
+      "fileHash": "b99e778b",
+      "needsInterop": false
+    },
+    "vue": {
+      "src": "../../vue/dist/vue.runtime.esm-bundler.js",
+      "file": "vue.js",
+      "fileHash": "1ca6187c",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "chunk-AJ6RA5K3": {
+      "file": "chunk-AJ6RA5K3.js"
+    }
+  }
+}
--- a/node_modules/.vite/deps/chunk-AJ6RA5K3.js
+++ b/node_modules/.vite/deps/chunk-AJ6RA5K3.js
--- a/node_modules/.vite/deps/chunk-AJ6RA5K3.js.map
+++ b/node_modules/.vite/deps/chunk-AJ6RA5K3.js.map
--- a/node_modules/.vite/deps/package.json
+++ b/node_modules/.vite/deps/package.json
@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
--- a/node_modules/.vite/deps/vue.js
+++ b/node_modules/.vite/deps/vue.js
@ -0,0 +1,343 @@
+import {
+  BaseTransition,
+  BaseTransitionPropsValidators,
+  Comment,
+  DeprecationTypes,
+  EffectScope,
+  ErrorCodes,
+  ErrorTypeStrings,
+  Fragment,
+  KeepAlive,
+  ReactiveEffect,
+  Static,
+  Suspense,
+  Teleport,
+  Text,
+  TrackOpTypes,
+  Transition,
+  TransitionGroup,
+  TriggerOpTypes,
+  VueElement,
+  assertNumber,
+  callWithAsyncErrorHandling,
+  callWithErrorHandling,
+  camelize,
+  capitalize,
+  cloneVNode,
+  compatUtils,
+  compile,
+  computed,
+  createApp,
+  createBaseVNode,
+  createBlock,
+  createCommentVNode,
+  createElementBlock,
+  createHydrationRenderer,
+  createPropsRestProxy,
+  createRenderer,
+  createSSRApp,
+  createSlots,
+  createStaticVNode,
+  createTextVNode,
+  createVNode,
+  customRef,
+  defineAsyncComponent,
+  defineComponent,
+  defineCustomElement,
+  defineEmits,
+  defineExpose,
+  defineModel,
+  defineOptions,
+  defineProps,
+  defineSSRCustomElement,
+  defineSlots,
+  devtools,
+  effect,
+  effectScope,
+  getCurrentInstance,
+  getCurrentScope,
+  getCurrentWatcher,
+  getTransitionRawChildren,
+  guardReactiveProps,
+  h,
+  handleError,
+  hasInjectionContext,
+  hydrate,
+  hydrateOnIdle,
+  hydrateOnInteraction,
+  hydrateOnMediaQuery,
+  hydrateOnVisible,
+  initCustomFormatter,
+  initDirectivesForSSR,
+  inject,
+  isMemoSame,
+  isProxy,
+  isReactive,
+  isReadonly,
+  isRef,
+  isRuntimeOnly,
+  isShallow,
+  isVNode,
+  markRaw,
+  mergeDefaults,
+  mergeModels,
+  mergeProps,
+  nextTick,
+  normalizeClass,
+  normalizeProps,
+  normalizeStyle,
+  onActivated,
+  onBeforeMount,
+  onBeforeUnmount,
+  onBeforeUpdate,
+  onDeactivated,
+  onErrorCaptured,
+  onMounted,
+  onRenderTracked,
+  onRenderTriggered,
+  onScopeDispose,
+  onServerPrefetch,
+  onUnmounted,
+  onUpdated,
+  onWatcherCleanup,
+  openBlock,
+  popScopeId,
+  provide,
+  proxyRefs,
+  pushScopeId,
+  queuePostFlushCb,
+  reactive,
+  readonly,
+  ref,
+  registerRuntimeCompiler,
+  render,
+  renderList,
+  renderSlot,
+  resolveComponent,
+  resolveDirective,
+  resolveDynamicComponent,
+  resolveFilter,
+  resolveTransitionHooks,
+  setBlockTracking,
+  setDevtoolsHook,
+  setTransitionHooks,
+  shallowReactive,
+  shallowReadonly,
+  shallowRef,
+  ssrContextKey,
+  ssrUtils,
+  stop,
+  toDisplayString,
+  toHandlerKey,
+  toHandlers,
+  toRaw,
+  toRef,
+  toRefs,
+  toValue,
+  transformVNodeArgs,
+  triggerRef,
+  unref,
+  useAttrs,
+  useCssModule,
+  useCssVars,
+  useHost,
+  useId,
+  useModel,
+  useSSRContext,
+  useShadowRoot,
+  useSlots,
+  useTemplateRef,
+  useTransitionState,
+  vModelCheckbox,
+  vModelDynamic,
+  vModelRadio,
+  vModelSelect,
+  vModelText,
+  vShow,
+  version,
+  warn,
+  watch,
+  watchEffect,
+  watchPostEffect,
+  watchSyncEffect,
+  withAsyncContext,
+  withCtx,
+  withDefaults,
+  withDirectives,
+  withKeys,
+  withMemo,
+  withModifiers,
+  withScopeId
+} from "./chunk-AJ6RA5K3.js";
+export {
+  BaseTransition,
+  BaseTransitionPropsValidators,
+  Comment,
+  DeprecationTypes,
+  EffectScope,
+  ErrorCodes,
+  ErrorTypeStrings,
+  Fragment,
+  KeepAlive,
+  ReactiveEffect,
+  Static,
+  Suspense,
+  Teleport,
+  Text,
+  TrackOpTypes,
+  Transition,
+  TransitionGroup,
+  TriggerOpTypes,
+  VueElement,
+  assertNumber,
+  callWithAsyncErrorHandling,
+  callWithErrorHandling,
+  camelize,
+  capitalize,
+  cloneVNode,
+  compatUtils,
+  compile,
+  computed,
+  createApp,
+  createBlock,
+  createCommentVNode,
+  createElementBlock,
+  createBaseVNode as createElementVNode,
+  createHydrationRenderer,
+  createPropsRestProxy,
+  createRenderer,
+  createSSRApp,
+  createSlots,
+  createStaticVNode,
+  createTextVNode,
+  createVNode,
+  customRef,
+  defineAsyncComponent,
+  defineComponent,
+  defineCustomElement,
+  defineEmits,
+  defineExpose,
+  defineModel,
+  defineOptions,
+  defineProps,
+  defineSSRCustomElement,
+  defineSlots,
+  devtools,
+  effect,
+  effectScope,
+  getCurrentInstance,
+  getCurrentScope,
+  getCurrentWatcher,
+  getTransitionRawChildren,
+  guardReactiveProps,
+  h,
+  handleError,
+  hasInjectionContext,
+  hydrate,
+  hydrateOnIdle,
+  hydrateOnInteraction,
+  hydrateOnMediaQuery,
+  hydrateOnVisible,
+  initCustomFormatter,
+  initDirectivesForSSR,
+  inject,
+  isMemoSame,
+  isProxy,
+  isReactive,
+  isReadonly,
+  isRef,
+  isRuntimeOnly,
+  isShallow,
+  isVNode,
+  markRaw,
+  mergeDefaults,
+  mergeModels,
+  mergeProps,
+  nextTick,
+  normalizeClass,
+  normalizeProps,
+  normalizeStyle,
+  onActivated,
+  onBeforeMount,
+  onBeforeUnmount,
+  onBeforeUpdate,
+  onDeactivated,
+  onErrorCaptured,
+  onMounted,
+  onRenderTracked,
+  onRenderTriggered,
+  onScopeDispose,
+  onServerPrefetch,
+  onUnmounted,
+  onUpdated,
+  onWatcherCleanup,
+  openBlock,
+  popScopeId,
+  provide,
+  proxyRefs,
+  pushScopeId,
+  queuePostFlushCb,
+  reactive,
+  readonly,
+  ref,
+  registerRuntimeCompiler,
+  render,
+  renderList,
+  renderSlot,
+  resolveComponent,
+  resolveDirective,
+  resolveDynamicComponent,
+  resolveFilter,
+  resolveTransitionHooks,
+  setBlockTracking,
+  setDevtoolsHook,
+  setTransitionHooks,
+  shallowReactive,
+  shallowReadonly,
+  shallowRef,
+  ssrContextKey,
+  ssrUtils,
+  stop,
+  toDisplayString,
+  toHandlerKey,
+  toHandlers,
+  toRaw,
+  toRef,
+  toRefs,
+  toValue,
+  transformVNodeArgs,
+  triggerRef,
+  unref,
+  useAttrs,
+  useCssModule,
+  useCssVars,
+  useHost,
+  useId,
+  useModel,
+  useSSRContext,
+  useShadowRoot,
+  useSlots,
+  useTemplateRef,
+  useTransitionState,
+  vModelCheckbox,
+  vModelDynamic,
+  vModelRadio,
+  vModelSelect,
+  vModelText,
+  vShow,
+  version,
+  warn,
+  watch,
+  watchEffect,
+  watchPostEffect,
+  watchSyncEffect,
+  withAsyncContext,
+  withCtx,
+  withDefaults,
+  withDirectives,
+  withKeys,
+  withMemo,
+  withModifiers,
+  withScopeId
+};
+//# sourceMappingURL=vue.js.map
--- a/node_modules/.vite/deps/vue.js.map
+++ b/node_modules/.vite/deps/vue.js.map
@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}
--- a/node_modules/.vue-global-types/vue_3.5_0.d.ts
+++ b/node_modules/.vue-global-types/vue_3.5_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 = {},
+		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/node_modules/@babel/helper-string-parser/LICENSE
+++ b/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/node_modules/@babel/helper-string-parser/README.md
+++ b/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/node_modules/@babel/helper-string-parser/lib/index.js
+++ b/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/node_modules/@babel/helper-string-parser/lib/index.js.map
+++ b/node_modules/@babel/helper-string-parser/lib/index.js.map
--- a/node_modules/@babel/helper-string-parser/package.json
+++ b/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/node_modules/@babel/helper-validator-identifier/LICENSE
+++ b/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/node_modules/@babel/helper-validator-identifier/README.md
+++ b/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/node_modules/@babel/helper-validator-identifier/lib/identifier.js
+++ b/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/node_modules/@babel/helper-validator-identifier/lib/identifier.js.map
+++ b/node_modules/@babel/helper-validator-identifier/lib/identifier.js.map
--- a/node_modules/@babel/helper-validator-identifier/lib/index.js
+++ b/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/node_modules/@babel/helper-validator-identifier/lib/index.js.map
+++ b/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/node_modules/@babel/helper-validator-identifier/lib/keyword.js
+++ b/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/node_modules/@babel/helper-validator-identifier/lib/keyword.js.map
+++ b/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/node_modules/@babel/helper-validator-identifier/package.json
+++ b/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/node_modules/@babel/parser/CHANGELOG.md
+++ b/node_modules/@babel/parser/CHANGELOG.md
--- a/node_modules/@babel/parser/LICENSE
+++ b/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/node_modules/@babel/parser/README.md
+++ b/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/node_modules/@babel/parser/bin/babel-parser.js
+++ b/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/node_modules/@babel/parser/lib/index.js
+++ b/node_modules/@babel/parser/lib/index.js
--- a/node_modules/@babel/parser/lib/index.js.map
+++ b/node_modules/@babel/parser/lib/index.js.map
--- a/node_modules/@babel/parser/package.json
+++ b/node_modules/@babel/parser/package.json
@ -0,0 +1,50 @@
+{
+  "name": "@babel/parser",
+  "version": "7.28.0",
+  "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.0"
+  },
+  "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/node_modules/@babel/parser/typings/babel-parser.d.ts
+++ b/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/node_modules/@babel/types/LICENSE
+++ b/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/node_modules/@babel/types/README.md
+++ b/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/node_modules/@babel/types/lib/asserts/assertNode.js
+++ b/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/node_modules/@babel/types/lib/asserts/assertNode.js.map
+++ b/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/node_modules/@babel/types/lib/asserts/generated/index.js
+++ b/node_modules/@babel/types/lib/asserts/generated/index.js
--- a/node_modules/@babel/types/lib/asserts/generated/index.js.map
+++ b/node_modules/@babel/types/lib/asserts/generated/index.js.map
--- a/node_modules/@babel/types/lib/ast-types/generated/index.js
+++ b/node_modules/@babel/types/lib/ast-types/generated/index.js
@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=index.js.map
--- a/node_modules/@babel/types/lib/ast-types/generated/index.js.map
+++ b/node_modules/@babel/types/lib/ast-types/generated/index.js.map
--- a/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
+++ b/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/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js.map
+++ b/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/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
+++ b/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/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js.map
+++ b/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/node_modules/@babel/types/lib/builders/generated/index.js
+++ b/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/node_modules/@babel/types/lib/builders/generated/index.js.map
+++ b/node_modules/@babel/types/lib/builders/generated/index.js.map
--- a/node_modules/@babel/types/lib/builders/generated/lowercase.js
+++ b/node_modules/@babel/types/lib/builders/generated/lowercase.js
--- a/node_modules/@babel/types/lib/builders/generated/lowercase.js.map
+++ b/node_modules/@babel/types/lib/builders/generated/lowercase.js.map
--- a/node_modules/@babel/types/lib/builders/generated/uppercase.js
+++ b/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/node_modules/@babel/types/lib/builders/generated/uppercase.js.map
+++ b/node_modules/@babel/types/lib/builders/generated/uppercase.js.map
--- a/node_modules/@babel/types/lib/builders/productions.js
+++ b/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/node_modules/@babel/types/lib/builders/productions.js.map
+++ b/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/node_modules/@babel/types/lib/builders/react/buildChildren.js
+++ b/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/node_modules/@babel/types/lib/builders/react/buildChildren.js.map
+++ b/node_modules/@babel/types/lib/builders/react/buildChildren.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_cleanJSXElementLiteralChild","buildChildren","node","elements","i","children","length","child","isJSXText","cleanJSXElementLiteralChild","isJSXExpressionContainer","expression","isJSXEmptyExpression","push"],"sources":["../../../src/builders/react/buildChildren.ts"],"sourcesContent":["import {\n  isJSXText,\n  isJSXExpressionContainer,\n  isJSXEmptyExpression,\n} from \"../../validators/generated/index.ts\";\nimport cleanJSXElementLiteralChild from \"../../utils/react/cleanJSXElementLiteralChild.ts\";\nimport type * as t from \"../../index.ts\";\n\ntype ReturnedChild =\n  | t.JSXSpreadChild\n  | t.JSXElement\n  | t.JSXFragment\n  | t.Expression;\n\nexport default function buildChildren(\n  node: t.JSXElement | t.JSXFragment,\n): ReturnedChild[] {\n  const elements = [];\n\n  for (let i = 0; i < node.children.length; i++) {\n    let child: any = node.children[i];\n\n    if (isJSXText(child)) {\n      cleanJSXElementLiteralChild(child, elements);\n      continue;\n    }\n\n    if (isJSXExpressionContainer(child)) child = child.expression;\n    if (isJSXEmptyExpression(child)) continue;\n\n    elements.push(child);\n  }\n\n  return elements;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAKA,IAAAC,4BAAA,GAAAD,OAAA;AASe,SAASE,aAAaA,CACnCC,IAAkC,EACjB;EACjB,MAAMC,QAAQ,GAAG,EAAE;EAEnB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,IAAI,CAACG,QAAQ,CAACC,MAAM,EAAEF,CAAC,EAAE,EAAE;IAC7C,IAAIG,KAAU,GAAGL,IAAI,CAACG,QAAQ,CAACD,CAAC,CAAC;IAEjC,IAAI,IAAAI,gBAAS,EAACD,KAAK,CAAC,EAAE;MACpB,IAAAE,oCAA2B,EAACF,KAAK,EAAEJ,QAAQ,CAAC;MAC5C;IACF;IAEA,IAAI,IAAAO,+BAAwB,EAACH,KAAK,CAAC,EAAEA,KAAK,GAAGA,KAAK,CAACI,UAAU;IAC7D,IAAI,IAAAC,2BAAoB,EAACL,KAAK,CAAC,EAAE;IAEjCJ,QAAQ,CAACU,IAAI,CAACN,KAAK,CAAC;EACtB;EAEA,OAAOJ,QAAQ;AACjB","ignoreList":[]}
--- a/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
+++ b/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createTSUnionType;
+var _index = require("../generated/index.js");
+var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates.js");
+var _index2 = require("../../validators/generated/index.js");
+function createTSUnionType(typeAnnotations) {
+  const types = typeAnnotations.map(type => {
+    return (0, _index2.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;
+  });
+  const flattened = (0, _removeTypeDuplicates.default)(types);
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return (0, _index.tsUnionType)(flattened);
+  }
+}
+
+//# sourceMappingURL=createTSUnionType.js.map
--- a/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js.map
+++ b/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_removeTypeDuplicates","_index2","createTSUnionType","typeAnnotations","types","map","type","isTSTypeAnnotation","typeAnnotation","flattened","removeTypeDuplicates","length","tsUnionType"],"sources":["../../../src/builders/typescript/createTSUnionType.ts"],"sourcesContent":["import { tsUnionType } from \"../generated/index.ts\";\nimport removeTypeDuplicates from \"../../modifications/typescript/removeTypeDuplicates.ts\";\nimport { isTSTypeAnnotation } from \"../../validators/generated/index.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 createTSUnionType(\n  typeAnnotations: Array<t.TSTypeAnnotation | t.TSType>,\n): t.TSType {\n  const types = typeAnnotations.map(type => {\n    return isTSTypeAnnotation(type) ? type.typeAnnotation : type;\n  });\n  const flattened = removeTypeDuplicates(types);\n\n  if (flattened.length === 1) {\n    return flattened[0];\n  } else {\n    return tsUnionType(flattened);\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAOe,SAASG,iBAAiBA,CACvCC,eAAqD,EAC3C;EACV,MAAMC,KAAK,GAAGD,eAAe,CAACE,GAAG,CAACC,IAAI,IAAI;IACxC,OAAO,IAAAC,0BAAkB,EAACD,IAAI,CAAC,GAAGA,IAAI,CAACE,cAAc,GAAGF,IAAI;EAC9D,CAAC,CAAC;EACF,MAAMG,SAAS,GAAG,IAAAC,6BAAoB,EAACN,KAAK,CAAC;EAE7C,IAAIK,SAAS,CAACE,MAAM,KAAK,CAAC,EAAE;IAC1B,OAAOF,SAAS,CAAC,CAAC,CAAC;EACrB,CAAC,MAAM;IACL,OAAO,IAAAG,kBAAW,EAACH,SAAS,CAAC;EAC/B;AACF","ignoreList":[]}
--- a/node_modules/@babel/types/lib/builders/validateNode.js
+++ b/node_modules/@babel/types/lib/builders/validateNode.js
@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validateNode;
+var _validate = require("../validators/validate.js");
+var _index = require("../index.js");
+function validateNode(node) {
+  if (node == null || typeof node !== "object") return;
+  const fields = _index.NODE_FIELDS[node.type];
+  if (!fields) return;
+  const keys = _index.BUILDER_KEYS[node.type];
+  for (const key of keys) {
+    const field = fields[key];
+    if (field != null) (0, _validate.validateInternal)(field, node, key, node[key]);
+  }
+  return node;
+}
+
+//# sourceMappingURL=validateNode.js.map
--- a/node_modules/@babel/types/lib/builders/validateNode.js.map
+++ b/node_modules/@babel/types/lib/builders/validateNode.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_validate","require","_index","validateNode","node","fields","NODE_FIELDS","type","keys","BUILDER_KEYS","key","field","validateInternal"],"sources":["../../src/builders/validateNode.ts"],"sourcesContent":["import { validateInternal } from \"../validators/validate.ts\";\nimport type * as t from \"../index.ts\";\nimport { BUILDER_KEYS, NODE_FIELDS } from \"../index.ts\";\n\nexport default function validateNode<N extends t.Node>(node: N) {\n  if (node == null || typeof node !== \"object\") return;\n  const fields = NODE_FIELDS[node.type];\n  if (!fields) return;\n\n  // todo: because keys not in BUILDER_KEYS are not validated - this actually allows invalid nodes in some cases\n  const keys = BUILDER_KEYS[node.type] as (keyof N & string)[];\n  for (const key of keys) {\n    const field = fields[key];\n    if (field != null) validateInternal(field, node, key, node[key]);\n  }\n  return node;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAEe,SAASE,YAAYA,CAAmBC,IAAO,EAAE;EAC9D,IAAIA,IAAI,IAAI,IAAI,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;EAC9C,MAAMC,MAAM,GAAGC,kBAAW,CAACF,IAAI,CAACG,IAAI,CAAC;EACrC,IAAI,CAACF,MAAM,EAAE;EAGb,MAAMG,IAAI,GAAGC,mBAAY,CAACL,IAAI,CAACG,IAAI,CAAyB;EAC5D,KAAK,MAAMG,GAAG,IAAIF,IAAI,EAAE;IACtB,MAAMG,KAAK,GAAGN,MAAM,CAACK,GAAG,CAAC;IACzB,IAAIC,KAAK,IAAI,IAAI,EAAE,IAAAC,0BAAgB,EAACD,KAAK,EAAEP,IAAI,EAAEM,GAAG,EAAEN,IAAI,CAACM,GAAG,CAAC,CAAC;EAClE;EACA,OAAON,IAAI;AACb","ignoreList":[]}
--- a/node_modules/@babel/types/lib/clone/clone.js
+++ b/node_modules/@babel/types/lib/clone/clone.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = clone;
+var _cloneNode = require("./cloneNode.js");
+function clone(node) {
+  return (0, _cloneNode.default)(node, false);
+}
+
+//# sourceMappingURL=clone.js.map
--- a/node_modules/@babel/types/lib/clone/clone.js.map
+++ b/node_modules/@babel/types/lib/clone/clone.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_cloneNode","require","clone","node","cloneNode"],"sources":["../../src/clone/clone.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a shallow clone of a `node`, including only\n * properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n */\nexport default function clone<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ false);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAQe,SAASC,KAAKA,CAAmBC,IAAO,EAAK;EAC1D,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,KAAK,CAAC;AAC1C","ignoreList":[]}
--- a/node_modules/@babel/types/lib/clone/cloneDeep.js
+++ b/node_modules/@babel/types/lib/clone/cloneDeep.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneDeep;
+var _cloneNode = require("./cloneNode.js");
+function cloneDeep(node) {
+  return (0, _cloneNode.default)(node);
+}
+
+//# sourceMappingURL=cloneDeep.js.map
--- a/node_modules/@babel/types/lib/clone/cloneDeep.js.map
+++ b/node_modules/@babel/types/lib/clone/cloneDeep.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_cloneNode","require","cloneDeep","node","cloneNode"],"sources":["../../src/clone/cloneDeep.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a deep clone of a `node` and all of it's child nodes\n * including only properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n */\nexport default function cloneDeep<T extends t.Node>(node: T): T {\n  return cloneNode(node);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAQe,SAASC,SAASA,CAAmBC,IAAO,EAAK;EAC9D,OAAO,IAAAC,kBAAS,EAACD,IAAI,CAAC;AACxB","ignoreList":[]}
--- a/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js
+++ b/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneDeepWithoutLoc;
+var _cloneNode = require("./cloneNode.js");
+function cloneDeepWithoutLoc(node) {
+  return (0, _cloneNode.default)(node, true, true);
+}
+
+//# sourceMappingURL=cloneDeepWithoutLoc.js.map
--- a/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js.map
+++ b/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_cloneNode","require","cloneDeepWithoutLoc","node","cloneNode"],"sources":["../../src/clone/cloneDeepWithoutLoc.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n/**\n * Create a deep clone of a `node` and all of it's child nodes\n * including only properties belonging to the node.\n * excluding `_private` and location properties.\n */\nexport default function cloneDeepWithoutLoc<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ true, /* withoutLoc */ true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAOe,SAASC,mBAAmBA,CAAmBC,IAAO,EAAK;EACxE,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,IAAI,EAAmB,IAAI,CAAC;AAChE","ignoreList":[]}
--- a/node_modules/@babel/types/lib/clone/cloneNode.js
+++ b/node_modules/@babel/types/lib/clone/cloneNode.js
@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneNode;
+var _index = require("../definitions/index.js");
+var _index2 = require("../validators/generated/index.js");
+const {
+  hasOwn
+} = {
+  hasOwn: Function.call.bind(Object.prototype.hasOwnProperty)
+};
+function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
+  if (obj && typeof obj.type === "string") {
+    return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);
+  }
+  return obj;
+}
+function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {
+  if (Array.isArray(obj)) {
+    return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache));
+  }
+  return cloneIfNode(obj, deep, withoutLoc, commentsCache);
+}
+function cloneNode(node, deep = true, withoutLoc = false) {
+  return cloneNodeInternal(node, deep, withoutLoc, new Map());
+}
+function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) {
+  if (!node) return node;
+  const {
+    type
+  } = node;
+  const newNode = {
+    type: node.type
+  };
+  if ((0, _index2.isIdentifier)(node)) {
+    newNode.name = node.name;
+    if (hasOwn(node, "optional") && typeof node.optional === "boolean") {
+      newNode.optional = node.optional;
+    }
+    if (hasOwn(node, "typeAnnotation")) {
+      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation;
+    }
+    if (hasOwn(node, "decorators")) {
+      newNode.decorators = deep ? cloneIfNodeOrArray(node.decorators, true, withoutLoc, commentsCache) : node.decorators;
+    }
+  } else if (!hasOwn(_index.NODE_FIELDS, type)) {
+    throw new Error(`Unknown node type: "${type}"`);
+  } else {
+    for (const field of Object.keys(_index.NODE_FIELDS[type])) {
+      if (hasOwn(node, field)) {
+        if (deep) {
+          newNode[field] = (0, _index2.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);
+        } else {
+          newNode[field] = node[field];
+        }
+      }
+    }
+  }
+  if (hasOwn(node, "loc")) {
+    if (withoutLoc) {
+      newNode.loc = null;
+    } else {
+      newNode.loc = node.loc;
+    }
+  }
+  if (hasOwn(node, "leadingComments")) {
+    newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache);
+  }
+  if (hasOwn(node, "innerComments")) {
+    newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache);
+  }
+  if (hasOwn(node, "trailingComments")) {
+    newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache);
+  }
+  if (hasOwn(node, "extra")) {
+    newNode.extra = Object.assign({}, node.extra);
+  }
+  return newNode;
+}
+function maybeCloneComments(comments, deep, withoutLoc, commentsCache) {
+  if (!comments || !deep) {
+    return comments;
+  }
+  return comments.map(comment => {
+    const cache = commentsCache.get(comment);
+    if (cache) return cache;
+    const {
+      type,
+      value,
+      loc
+    } = comment;
+    const ret = {
+      type,
+      value,
+      loc
+    };
+    if (withoutLoc) {
+      ret.loc = null;
+    }
+    commentsCache.set(comment, ret);
+    return ret;
+  });
+}
+
+//# sourceMappingURL=cloneNode.js.map
--- a/node_modules/@babel/types/lib/clone/cloneNode.js.map
+++ b/node_modules/@babel/types/lib/clone/cloneNode.js.map
--- a/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
+++ b/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneWithoutLoc;
+var _cloneNode = require("./cloneNode.js");
+function cloneWithoutLoc(node) {
+  return (0, _cloneNode.default)(node, false, true);
+}
+
+//# sourceMappingURL=cloneWithoutLoc.js.map
--- a/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js.map
+++ b/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_cloneNode","require","cloneWithoutLoc","node","cloneNode"],"sources":["../../src/clone/cloneWithoutLoc.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a shallow clone of a `node` excluding `_private` and location properties.\n */\nexport default function cloneWithoutLoc<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ false, /* withoutLoc */ true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAMe,SAASC,eAAeA,CAAmBC,IAAO,EAAK;EACpE,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,KAAK,EAAmB,IAAI,CAAC;AACjE","ignoreList":[]}
--- a/node_modules/@babel/types/lib/comments/addComment.js
+++ b/node_modules/@babel/types/lib/comments/addComment.js
@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComment;
+var _addComments = require("./addComments.js");
+function addComment(node, type, content, line) {
+  return (0, _addComments.default)(node, type, [{
+    type: line ? "CommentLine" : "CommentBlock",
+    value: content
+  }]);
+}
+
+//# sourceMappingURL=addComment.js.map
--- a/node_modules/@babel/types/lib/comments/addComment.js.map
+++ b/node_modules/@babel/types/lib/comments/addComment.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_addComments","require","addComment","node","type","content","line","addComments","value"],"sources":["../../src/comments/addComment.ts"],"sourcesContent":["import addComments from \"./addComments.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Add comment of certain type to a node.\n */\nexport default function addComment<T extends t.Node>(\n  node: T,\n  type: t.CommentTypeShorthand,\n  content: string,\n  line?: boolean,\n): T {\n  return addComments(node, type, [\n    {\n      type: line ? \"CommentLine\" : \"CommentBlock\",\n      value: content,\n    } as t.Comment,\n  ]);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAMe,SAASC,UAAUA,CAChCC,IAAO,EACPC,IAA4B,EAC5BC,OAAe,EACfC,IAAc,EACX;EACH,OAAO,IAAAC,oBAAW,EAACJ,IAAI,EAAEC,IAAI,EAAE,CAC7B;IACEA,IAAI,EAAEE,IAAI,GAAG,aAAa,GAAG,cAAc;IAC3CE,KAAK,EAAEH;EACT,CAAC,CACF,CAAC;AACJ","ignoreList":[]}
--- a/node_modules/@babel/types/lib/comments/addComments.js
+++ b/node_modules/@babel/types/lib/comments/addComments.js
@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComments;
+function addComments(node, type, comments) {
+  if (!comments || !node) return node;
+  const key = `${type}Comments`;
+  if (node[key]) {
+    if (type === "leading") {
+      node[key] = comments.concat(node[key]);
+    } else {
+      node[key].push(...comments);
+    }
+  } else {
+    node[key] = comments;
+  }
+  return node;
+}
+
+//# sourceMappingURL=addComments.js.map
--- a/node_modules/@babel/types/lib/comments/addComments.js.map
+++ b/node_modules/@babel/types/lib/comments/addComments.js.map
@ -0,0 +1 @@
+{"version":3,"names":["addComments","node","type","comments","key","concat","push"],"sources":["../../src/comments/addComments.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\n/**\n * Add comments of certain type to a node.\n */\nexport default function addComments<T extends t.Node>(\n  node: T,\n  type: t.CommentTypeShorthand,\n  comments: Array<t.Comment>,\n): T {\n  if (!comments || !node) return node;\n\n  const key = `${type}Comments` as const;\n\n  if (node[key]) {\n    if (type === \"leading\") {\n      node[key] = comments.concat(node[key]);\n    } else {\n      node[key].push(...comments);\n    }\n  } else {\n    node[key] = comments;\n  }\n\n  return node;\n}\n"],"mappings":";;;;;;AAKe,SAASA,WAAWA,CACjCC,IAAO,EACPC,IAA4B,EAC5BC,QAA0B,EACvB;EACH,IAAI,CAACA,QAAQ,IAAI,CAACF,IAAI,EAAE,OAAOA,IAAI;EAEnC,MAAMG,GAAG,GAAG,GAAGF,IAAI,UAAmB;EAEtC,IAAID,IAAI,CAACG,GAAG,CAAC,EAAE;IACb,IAAIF,IAAI,KAAK,SAAS,EAAE;MACtBD,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ,CAACE,MAAM,CAACJ,IAAI,CAACG,GAAG,CAAC,CAAC;IACxC,CAAC,MAAM;MACLH,IAAI,CAACG,GAAG,CAAC,CAACE,IAAI,CAAC,GAAGH,QAAQ,CAAC;IAC7B;EACF,CAAC,MAAM;IACLF,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ;EACtB;EAEA,OAAOF,IAAI;AACb","ignoreList":[]}
--- a/node_modules/@babel/types/lib/comments/inheritInnerComments.js
+++ b/node_modules/@babel/types/lib/comments/inheritInnerComments.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritInnerComments;
+var _inherit = require("../utils/inherit.js");
+function inheritInnerComments(child, parent) {
+  (0, _inherit.default)("innerComments", child, parent);
+}
+
+//# sourceMappingURL=inheritInnerComments.js.map
--- a/node_modules/@babel/types/lib/comments/inheritInnerComments.js.map
+++ b/node_modules/@babel/types/lib/comments/inheritInnerComments.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_inherit","require","inheritInnerComments","child","parent","inherit"],"sources":["../../src/comments/inheritInnerComments.ts"],"sourcesContent":["import inherit from \"../utils/inherit.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function inheritInnerComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"innerComments\", child, parent);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAGe,SAASC,oBAAoBA,CAC1CC,KAAa,EACbC,MAAc,EACR;EACN,IAAAC,gBAAO,EAAC,eAAe,EAAEF,KAAK,EAAEC,MAAM,CAAC;AACzC","ignoreList":[]}
--- a/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
+++ b/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritLeadingComments;
+var _inherit = require("../utils/inherit.js");
+function inheritLeadingComments(child, parent) {
+  (0, _inherit.default)("leadingComments", child, parent);
+}
+
+//# sourceMappingURL=inheritLeadingComments.js.map
--- a/node_modules/@babel/types/lib/comments/inheritLeadingComments.js.map
+++ b/node_modules/@babel/types/lib/comments/inheritLeadingComments.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_inherit","require","inheritLeadingComments","child","parent","inherit"],"sources":["../../src/comments/inheritLeadingComments.ts"],"sourcesContent":["import inherit from \"../utils/inherit.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function inheritLeadingComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"leadingComments\", child, parent);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAGe,SAASC,sBAAsBA,CAC5CC,KAAa,EACbC,MAAc,EACR;EACN,IAAAC,gBAAO,EAAC,iBAAiB,EAAEF,KAAK,EAAEC,MAAM,CAAC;AAC3C","ignoreList":[]}
--- a/node_modules/@babel/types/lib/comments/inheritTrailingComments.js
+++ b/node_modules/@babel/types/lib/comments/inheritTrailingComments.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritTrailingComments;
+var _inherit = require("../utils/inherit.js");
+function inheritTrailingComments(child, parent) {
+  (0, _inherit.default)("trailingComments", child, parent);
+}
+
+//# sourceMappingURL=inheritTrailingComments.js.map
--- a/node_modules/@babel/types/lib/comments/inheritTrailingComments.js.map
+++ b/node_modules/@babel/types/lib/comments/inheritTrailingComments.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_inherit","require","inheritTrailingComments","child","parent","inherit"],"sources":["../../src/comments/inheritTrailingComments.ts"],"sourcesContent":["import inherit from \"../utils/inherit.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function inheritTrailingComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"trailingComments\", child, parent);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAGe,SAASC,uBAAuBA,CAC7CC,KAAa,EACbC,MAAc,EACR;EACN,IAAAC,gBAAO,EAAC,kBAAkB,EAAEF,KAAK,EAAEC,MAAM,CAAC;AAC5C","ignoreList":[]}
--- a/node_modules/@babel/types/lib/comments/inheritsComments.js
+++ b/node_modules/@babel/types/lib/comments/inheritsComments.js
@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritsComments;
+var _inheritTrailingComments = require("./inheritTrailingComments.js");
+var _inheritLeadingComments = require("./inheritLeadingComments.js");
+var _inheritInnerComments = require("./inheritInnerComments.js");
+function inheritsComments(child, parent) {
+  (0, _inheritTrailingComments.default)(child, parent);
+  (0, _inheritLeadingComments.default)(child, parent);
+  (0, _inheritInnerComments.default)(child, parent);
+  return child;
+}
+
+//# sourceMappingURL=inheritsComments.js.map
--- a/node_modules/@babel/types/lib/comments/inheritsComments.js.map
+++ b/node_modules/@babel/types/lib/comments/inheritsComments.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_inheritTrailingComments","require","_inheritLeadingComments","_inheritInnerComments","inheritsComments","child","parent","inheritTrailingComments","inheritLeadingComments","inheritInnerComments"],"sources":["../../src/comments/inheritsComments.ts"],"sourcesContent":["import inheritTrailingComments from \"./inheritTrailingComments.ts\";\nimport inheritLeadingComments from \"./inheritLeadingComments.ts\";\nimport inheritInnerComments from \"./inheritInnerComments.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Inherit all unique comments from `parent` node to `child` node.\n */\nexport default function inheritsComments<T extends t.Node>(\n  child: T,\n  parent: t.Node,\n): T {\n  inheritTrailingComments(child, parent);\n  inheritLeadingComments(child, parent);\n  inheritInnerComments(child, parent);\n\n  return child;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,uBAAA,GAAAD,OAAA;AACA,IAAAE,qBAAA,GAAAF,OAAA;AAMe,SAASG,gBAAgBA,CACtCC,KAAQ,EACRC,MAAc,EACX;EACH,IAAAC,gCAAuB,EAACF,KAAK,EAAEC,MAAM,CAAC;EACtC,IAAAE,+BAAsB,EAACH,KAAK,EAAEC,MAAM,CAAC;EACrC,IAAAG,6BAAoB,EAACJ,KAAK,EAAEC,MAAM,CAAC;EAEnC,OAAOD,KAAK;AACd","ignoreList":[]}
--- a/node_modules/@babel/types/lib/comments/removeComments.js
+++ b/node_modules/@babel/types/lib/comments/removeComments.js
@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeComments;
+var _index = require("../constants/index.js");
+function removeComments(node) {
+  _index.COMMENT_KEYS.forEach(key => {
+    node[key] = null;
+  });
+  return node;
+}
+
+//# sourceMappingURL=removeComments.js.map
--- a/node_modules/@babel/types/lib/comments/removeComments.js.map
+++ b/node_modules/@babel/types/lib/comments/removeComments.js.map
@ -0,0 +1 @@
+{"version":3,"names":["_index","require","removeComments","node","COMMENT_KEYS","forEach","key"],"sources":["../../src/comments/removeComments.ts"],"sourcesContent":["import { COMMENT_KEYS } from \"../constants/index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Remove comment properties from a node.\n */\nexport default function removeComments<T extends t.Node>(node: T): T {\n  COMMENT_KEYS.forEach(key => {\n    node[key] = null;\n  });\n\n  return node;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMe,SAASC,cAAcA,CAAmBC,IAAO,EAAK;EACnEC,mBAAY,CAACC,OAAO,CAACC,GAAG,IAAI;IAC1BH,IAAI,CAACG,GAAG,CAAC,GAAG,IAAI;EAClB,CAAC,CAAC;EAEF,OAAOH,IAAI;AACb","ignoreList":[]}
--- a/node_modules/@babel/types/lib/constants/generated/index.js
+++ b/node_modules/@babel/types/lib/constants/generated/index.js
@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FUNCTIONPARAMETER_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0;
+var _index = require("../../definitions/index.js");
+const STANDARDIZED_TYPES = exports.STANDARDIZED_TYPES = _index.FLIPPED_ALIAS_KEYS["Standardized"];
+const EXPRESSION_TYPES = exports.EXPRESSION_TYPES = _index.FLIPPED_ALIAS_KEYS["Expression"];
+const BINARY_TYPES = exports.BINARY_TYPES = _index.FLIPPED_ALIAS_KEYS["Binary"];
+const SCOPABLE_TYPES = exports.SCOPABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["Scopable"];
+const BLOCKPARENT_TYPES = exports.BLOCKPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS["BlockParent"];
+const BLOCK_TYPES = exports.BLOCK_TYPES = _index.FLIPPED_ALIAS_KEYS["Block"];
+const STATEMENT_TYPES = exports.STATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["Statement"];
+const TERMINATORLESS_TYPES = exports.TERMINATORLESS_TYPES = _index.FLIPPED_ALIAS_KEYS["Terminatorless"];
+const COMPLETIONSTATEMENT_TYPES = exports.COMPLETIONSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["CompletionStatement"];
+const CONDITIONAL_TYPES = exports.CONDITIONAL_TYPES = _index.FLIPPED_ALIAS_KEYS["Conditional"];
+const LOOP_TYPES = exports.LOOP_TYPES = _index.FLIPPED_ALIAS_KEYS["Loop"];
+const WHILE_TYPES = exports.WHILE_TYPES = _index.FLIPPED_ALIAS_KEYS["While"];
+const EXPRESSIONWRAPPER_TYPES = exports.EXPRESSIONWRAPPER_TYPES = _index.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
+const FOR_TYPES = exports.FOR_TYPES = _index.FLIPPED_ALIAS_KEYS["For"];
+const FORXSTATEMENT_TYPES = exports.FORXSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["ForXStatement"];
+const FUNCTION_TYPES = exports.FUNCTION_TYPES = _index.FLIPPED_ALIAS_KEYS["Function"];
+const FUNCTIONPARENT_TYPES = exports.FUNCTIONPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS["FunctionParent"];
+const PUREISH_TYPES = exports.PUREISH_TYPES = _index.FLIPPED_ALIAS_KEYS["Pureish"];
+const DECLARATION_TYPES = exports.DECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["Declaration"];
+const FUNCTIONPARAMETER_TYPES = exports.FUNCTIONPARAMETER_TYPES = _index.FLIPPED_ALIAS_KEYS["FunctionParameter"];
+const PATTERNLIKE_TYPES = exports.PATTERNLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS["PatternLike"];
+const LVAL_TYPES = exports.LVAL_TYPES = _index.FLIPPED_ALIAS_KEYS["LVal"];
+const TSENTITYNAME_TYPES = exports.TSENTITYNAME_TYPES = _index.FLIPPED_ALIAS_KEYS["TSEntityName"];
+const LITERAL_TYPES = exports.LITERAL_TYPES = _index.FLIPPED_ALIAS_KEYS["Literal"];
+const IMMUTABLE_TYPES = exports.IMMUTABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["Immutable"];
+const USERWHITESPACABLE_TYPES = exports.USERWHITESPACABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
+const METHOD_TYPES = exports.METHOD_TYPES = _index.FLIPPED_ALIAS_KEYS["Method"];
+const OBJECTMEMBER_TYPES = exports.OBJECTMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS["ObjectMember"];
+const PROPERTY_TYPES = exports.PROPERTY_TYPES = _index.FLIPPED_ALIAS_KEYS["Property"];
+const UNARYLIKE_TYPES = exports.UNARYLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS["UnaryLike"];
+const PATTERN_TYPES = exports.PATTERN_TYPES = _index.FLIPPED_ALIAS_KEYS["Pattern"];
+const CLASS_TYPES = exports.CLASS_TYPES = _index.FLIPPED_ALIAS_KEYS["Class"];
+const IMPORTOREXPORTDECLARATION_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["ImportOrExportDeclaration"];
+const EXPORTDECLARATION_TYPES = exports.EXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
+const MODULESPECIFIER_TYPES = exports.MODULESPECIFIER_TYPES = _index.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
+const ACCESSOR_TYPES = exports.ACCESSOR_TYPES = _index.FLIPPED_ALIAS_KEYS["Accessor"];
+const PRIVATE_TYPES = exports.PRIVATE_TYPES = _index.FLIPPED_ALIAS_KEYS["Private"];
+const FLOW_TYPES = exports.FLOW_TYPES = _index.FLIPPED_ALIAS_KEYS["Flow"];
+const FLOWTYPE_TYPES = exports.FLOWTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowType"];
+const FLOWBASEANNOTATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
+const FLOWDECLARATION_TYPES = exports.FLOWDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
+const FLOWPREDICATE_TYPES = exports.FLOWPREDICATE_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowPredicate"];
+const ENUMBODY_TYPES = exports.ENUMBODY_TYPES = _index.FLIPPED_ALIAS_KEYS["EnumBody"];
+const ENUMMEMBER_TYPES = exports.ENUMMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS["EnumMember"];
+const JSX_TYPES = exports.JSX_TYPES = _index.FLIPPED_ALIAS_KEYS["JSX"];
+const MISCELLANEOUS_TYPES = exports.MISCELLANEOUS_TYPES = _index.FLIPPED_ALIAS_KEYS["Miscellaneous"];
+const TYPESCRIPT_TYPES = exports.TYPESCRIPT_TYPES = _index.FLIPPED_ALIAS_KEYS["TypeScript"];
+const TSTYPEELEMENT_TYPES = exports.TSTYPEELEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["TSTypeElement"];
+const TSTYPE_TYPES = exports.TSTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["TSType"];
+const TSBASETYPE_TYPES = exports.TSBASETYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["TSBaseType"];
+const MODULEDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
+
+//# sourceMappingURL=index.js.map
--- a/Show More
+++ b/Show More
				`@ -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":[]}
				`@ -0,0 +1 @@`
				{"version":3,"names":["_validate","require","_index","validateNode","node","fields","NODE_FIELDS","type","keys","BUILDER_KEYS","key","field","validateInternal"],"sources":["../../src/builders/validateNode.ts"],"sourcesContent":["import { validateInternal } from \"../validators/validate.ts\";\nimport type * as t from \"../index.ts\";\nimport { BUILDER_KEYS, NODE_FIELDS } from \"../index.ts\";\n\nexport default function validateNode<N extends t.Node>(node: N) {\n if (node == null \|\| typeof node !== \"object\") return;\n const fields = NODE_FIELDS[node.type];\n if (!fields) return;\n\n // todo: because keys not in BUILDER_KEYS are not validated - this actually allows invalid nodes in some cases\n const keys = BUILDER_KEYS[node.type] as (keyof N & string)[];\n for (const key of keys) {\n const field = fields[key];\n if (field != null) validateInternal(field, node, key, node[key]);\n }\n return node;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAEe,SAASE,YAAYA,CAAmBC,IAAO,EAAE;EAC9D,IAAIA,IAAI,IAAI,IAAI,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;EAC9C,MAAMC,MAAM,GAAGC,kBAAW,CAACF,IAAI,CAACG,IAAI,CAAC;EACrC,IAAI,CAACF,MAAM,EAAE;EAGb,MAAMG,IAAI,GAAGC,mBAAY,CAACL,IAAI,CAACG,IAAI,CAAyB;EAC5D,KAAK,MAAMG,GAAG,IAAIF,IAAI,EAAE;IACtB,MAAMG,KAAK,GAAGN,MAAM,CAACK,GAAG,CAAC;IACzB,IAAIC,KAAK,IAAI,IAAI,EAAE,IAAAC,0BAAgB,EAACD,KAAK,EAAEP,IAAI,EAAEM,GAAG,EAAEN,IAAI,CAACM,GAAG,CAAC,CAAC;EAClE;EACA,OAAON,IAAI;AACb","ignoreList":[]}
				`@ -0,0 +1 @@`
				{"version":3,"names":["_cloneNode","require","clone","node","cloneNode"],"sources":["../../src/clone/clone.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/*\n Create a shallow clone of a `node`, including only\n * properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n /\nexport default function clone<T extends t.Node>(node: T): T {\n return cloneNode(node, / deep */ false);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAQe,SAASC,KAAKA,CAAmBC,IAAO,EAAK;EAC1D,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,KAAK,CAAC;AAC1C","ignoreList":[]}
				`@ -0,0 +1 @@`
				{"version":3,"names":["_addComments","require","addComment","node","type","content","line","addComments","value"],"sources":["../../src/comments/addComment.ts"],"sourcesContent":["import addComments from \"./addComments.ts\";\nimport type * as t from \"../index.ts\";\n\n/*\n Add comment of certain type to a node.\n */\nexport default function addComment<T extends t.Node>(\n node: T,\n type: t.CommentTypeShorthand,\n content: string,\n line?: boolean,\n): T {\n return addComments(node, type, [\n {\n type: line ? \"CommentLine\" : \"CommentBlock\",\n value: content,\n } as t.Comment,\n ]);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAMe,SAASC,UAAUA,CAChCC,IAAO,EACPC,IAA4B,EAC5BC,OAAe,EACfC,IAAc,EACX;EACH,OAAO,IAAAC,oBAAW,EAACJ,IAAI,EAAEC,IAAI,EAAE,CAC7B;IACEA,IAAI,EAAEE,IAAI,GAAG,aAAa,GAAG,cAAc;IAC3CE,KAAK,EAAEH;EACT,CAAC,CACF,CAAC;AACJ","ignoreList":[]}
				`@ -0,0 +1 @@`
				{"version":3,"names":["addComments","node","type","comments","key","concat","push"],"sources":["../../src/comments/addComments.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\n/*\n Add comments of certain type to a node.\n */\nexport default function addComments<T extends t.Node>(\n node: T,\n type: t.CommentTypeShorthand,\n comments: Array<t.Comment>,\n): T {\n if (!comments \|\| !node) return node;\n\n const key = `${type}Comments` as const;\n\n if (node[key]) {\n if (type === \"leading\") {\n node[key] = comments.concat(node[key]);\n } else {\n node[key].push(...comments);\n }\n } else {\n node[key] = comments;\n }\n\n return node;\n}\n"],"mappings":";;;;;;AAKe,SAASA,WAAWA,CACjCC,IAAO,EACPC,IAA4B,EAC5BC,QAA0B,EACvB;EACH,IAAI,CAACA,QAAQ,IAAI,CAACF,IAAI,EAAE,OAAOA,IAAI;EAEnC,MAAMG,GAAG,GAAG,GAAGF,IAAI,UAAmB;EAEtC,IAAID,IAAI,CAACG,GAAG,CAAC,EAAE;IACb,IAAIF,IAAI,KAAK,SAAS,EAAE;MACtBD,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ,CAACE,MAAM,CAACJ,IAAI,CAACG,GAAG,CAAC,CAAC;IACxC,CAAC,MAAM;MACLH,IAAI,CAACG,GAAG,CAAC,CAACE,IAAI,CAAC,GAAGH,QAAQ,CAAC;IAC7B;EACF,CAAC,MAAM;IACLF,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ;EACtB;EAEA,OAAOF,IAAI;AACb","ignoreList":[]}
				`@ -0,0 +1 @@`
				{"version":3,"names":["_inherit","require","inheritInnerComments","child","parent","inherit"],"sources":["../../src/comments/inheritInnerComments.ts"],"sourcesContent":["import inherit from \"../utils/inherit.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function inheritInnerComments(\n child: t.Node,\n parent: t.Node,\n): void {\n inherit(\"innerComments\", child, parent);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAGe,SAASC,oBAAoBA,CAC1CC,KAAa,EACbC,MAAc,EACR;EACN,IAAAC,gBAAO,EAAC,eAAe,EAAEF,KAAK,EAAEC,MAAM,CAAC;AACzC","ignoreList":[]}
				`@ -0,0 +1 @@`
				{"version":3,"names":["_inheritTrailingComments","require","_inheritLeadingComments","_inheritInnerComments","inheritsComments","child","parent","inheritTrailingComments","inheritLeadingComments","inheritInnerComments"],"sources":["../../src/comments/inheritsComments.ts"],"sourcesContent":["import inheritTrailingComments from \"./inheritTrailingComments.ts\";\nimport inheritLeadingComments from \"./inheritLeadingComments.ts\";\nimport inheritInnerComments from \"./inheritInnerComments.ts\";\nimport type * as t from \"../index.ts\";\n\n/*\n Inherit all unique comments from `parent` node to `child` node.\n */\nexport default function inheritsComments<T extends t.Node>(\n child: T,\n parent: t.Node,\n): T {\n inheritTrailingComments(child, parent);\n inheritLeadingComments(child, parent);\n inheritInnerComments(child, parent);\n\n return child;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,uBAAA,GAAAD,OAAA;AACA,IAAAE,qBAAA,GAAAF,OAAA;AAMe,SAASG,gBAAgBA,CACtCC,KAAQ,EACRC,MAAc,EACX;EACH,IAAAC,gCAAuB,EAACF,KAAK,EAAEC,MAAM,CAAC;EACtC,IAAAE,+BAAsB,EAACH,KAAK,EAAEC,MAAM,CAAC;EACrC,IAAAG,6BAAoB,EAACJ,KAAK,EAAEC,MAAM,CAAC;EAEnC,OAAOD,KAAK;AACd","ignoreList":[]}