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,3 @@`
							`"use strict";`

							`//# sourceMappingURL=index.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":[]}
		`@ -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":[]}