fix: 自动暂存改为按钮旁显示保存中标记，去掉弹窗提示

docs/superpowers/plans/2026-05-21-channel-admin-frontend.md

@@ -0,0 +1,167 @@
+# 管理端渠道列表页改造 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** 在管理端渠道列表页新增「渠道码」列、「二维码」列，以及「生成二维码」操作按钮。
+
+**Architecture:** 仅修改 `src/views/modules/supplier/channel.vue` 一个文件。在现有 `el-table` 中插入两列，操作列新增按钮，用 `loadingIds` 数组实现 per-row loading，用 `el-image` 的 `preview-src-list` 实现图片放大预览。
+
+**Tech Stack:** Vue 2.6、Element UI、axios（通过 `this.$http`）
+
+---
+
+## 文件变更清单
+
+| 操作 | 文件 |
+|------|------|
+| Modify | `src/views/modules/supplier/channel.vue` |
+
+---
+
+### Task 1: 新增「渠道码」列
+
+**Files:**
+- Modify: `src/views/modules/supplier/channel.vue`
+
+- [ ] **Step 1: 在「渠道方名称」列后插入「渠道码」列**
+
+在 `channel.vue` 的 `<el-table>` 中，找到：
+```html
+<el-table-column prop="channelName" label="渠道方名称"></el-table-column>
+```
+在其后插入：
+```html
+<el-table-column prop="code" label="渠道码" width="120"></el-table-column>
+```
+
+- [ ] **Step 2: 手动验证**
+
+启动开发服务器（`npm run serve`），打开渠道方列表页，确认表格出现「渠道码」列，展示后端返回的 `code` 字段值（8位字母数字）。若后端暂未部署，可在 `getDataList` 的 mock 数据中临时加 `code: 'ab3x9k2m'` 验证。
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/views/modules/supplier/channel.vue
+git commit -m "feat: 渠道列表新增渠道码列"
+```
+
+---
+
+### Task 2: 新增「二维码」列
+
+**Files:**
+- Modify: `src/views/modules/supplier/channel.vue`
+
+- [ ] **Step 1: 在「渠道码」列后插入「二维码」列**
+
+在 Task 1 新增的 `code` 列后插入：
+```html
+<el-table-column label="二维码" width="100" align="center">
+  <template slot-scope="scope">
+    <el-image
+      v-if="scope.row.qrUrl"
+      :src="scope.row.qrUrl"
+      :preview-src-list="[scope.row.qrUrl]"
+      style="width: 60px; height: 60px;"
+      fit="contain"
+    ></el-image>
+    <span v-else style="color: #999; font-size: 12px;">未生成</span>
+  </template>
+</el-table-column>
+```
+
+- [ ] **Step 2: 手动验证**
+
+在列表页确认：
+- 有 `qrUrl` 的行显示 60×60 缩略图，点击可放大
+- `qrUrl` 为 null 的行显示灰色「未生成」文字
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/views/modules/supplier/channel.vue
+git commit -m "feat: 渠道列表新增二维码列，支持缩略图预览"
+```
+
+---
+
+### Task 3: 操作列新增「生成二维码」按钮
+
+**Files:**
+- Modify: `src/views/modules/supplier/channel.vue`
+
+- [ ] **Step 1: 在 data() 中新增 loadingIds 数组**
+
+找到 `data()` 的 `return` 对象，在 `buttonLoading: false` 后新增：
+```js
+loadingIds: []
+```
+
+- [ ] **Step 2: 在操作列新增「生成二维码」按钮**
+
+找到操作列的 template：
+```html
+<template slot-scope="scope">
+    <el-button type="text" @click="handleEdit(scope.row)">编辑</el-button>
+    <el-button type="text" @click="handleDelete(scope.row)">删除</el-button>
+</template>
+```
+替换为：
+```html
+<template slot-scope="scope">
+    <el-button type="text" @click="handleEdit(scope.row)">编辑</el-button>
+    <el-button type="text" @click="handleDelete(scope.row)">删除</el-button>
+    <el-button
+      type="text"
+      :loading="loadingIds.includes(scope.row.id)"
+      @click="handleGenerateQr(scope.row)"
+    >生成二维码</el-button>
+</template>
+```
+
+- [ ] **Step 3: 新增 handleGenerateQr 方法**
+
+在 `methods` 中，在 `cancel()` 方法后新增：
+```js
+handleGenerateQr (row) {
+  this.loadingIds.push(row.id)
+  this.$http.post(`/core/channel/generateQr/${row.id}`).then(res => {
+    if (res.data.code !== 0) {
+      this.$message.error(res.data.msg)
+    } else {
+      row.qrUrl = res.data.data
+      this.$message.success('二维码生成成功')
+    }
+  }).catch(() => {
+    this.$message.error('操作失败，请重试')
+  }).finally(() => {
+    this.loadingIds = this.loadingIds.filter(id => id !== row.id)
+  })
+}
+```
+
+- [ ] **Step 4: 手动验证**
+
+在列表页点击某行「生成二维码」：
+- 按钮进入 loading 状态
+- 请求成功后，该行二维码列从「未生成」变为缩略图
+- 其他行按钮不受影响
+- 网络失败时弹出错误提示
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/views/modules/supplier/channel.vue
+git commit -m "feat: 渠道列表操作列新增生成二维码按钮"
+```
+
+---
+
+## 自检清单
+
+- [x] 规格书 §3.1「列表新增渠道码列」→ Task 1
+- [x] 规格书 §3.1「列表新增二维码列，有图/无图两种状态」→ Task 2
+- [x] 规格书 §3.1「操作列新增生成二维码按钮，loading 等待，成功刷新行数据」→ Task 3
+- [x] 规格书 §3.2「新增表单无需改动」→ 未涉及，正确
+- [x] 错误处理：失败弹 `$message.error`，网络异常 catch → Task 3 Step 3
+- [x] per-row loading 避免多行互相干扰 → `loadingIds` 数组

docs/superpowers/plans/2026-05-22-family-member-channel-display.md

@@ -0,0 +1,211 @@
+# 家庭成员渠道展示 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** 在管理端「家庭成员」列表中新增「所属渠道」列，展示每个成员绑定的渠道名称。
+
+**Architecture:** 后端在 `FamilyMemberDTO` 新增 `channelNames` 字段，`FamilyMemberServiceImpl` 重写 `page()` 方法，在基类查询结果后批量查渠道名并填充（一次查询，无 N+1）。前端 `familyMember.vue` 新增一列展示该字段。
+
+**Tech Stack:** Java 17、MyBatis-Plus、Spring Boot（后端）；Vue 2.6、Element UI（前端）
+
+---
+
+## 文件变更清单
+
+| 操作 | 文件 |
+|------|------|
+| Modify | `happytree-sys/src/main/java/com/ringzle/modules/core/dto/FamilyMemberDTO.java` |
+| Modify | `happytree-sys/src/main/java/com/ringzle/modules/core/service/impl/FamilyMemberServiceImpl.java` |
+| Modify | `SxsnPC/src/views/modules/member/components/familyMember.vue` |
+
+---
+
+### Task 1: FamilyMemberDTO 新增 channelNames 字段
+
+**Files:**
+- Modify: `happytree-sys/src/main/java/com/ringzle/modules/core/dto/FamilyMemberDTO.java`
+
+- [ ] **Step 1: 在 FamilyMemberDTO 末尾新增字段**
+
+找到文件末尾的最后一个字段（`updateDate`），在其后、类的 `}` 之前插入：
+
+```java
+@ApiModelProperty(value = "渠道名称，逗号分隔")
+private String channelNames;
+```
+
+完整的 DTO 末尾应如下：
+
+```java
+	@ApiModelProperty(value = "更新时间")
+	private Date updateDate;
+
+	@ApiModelProperty(value = "渠道名称，逗号分隔")
+	private String channelNames;
+
+}
+```
+
+- [ ] **Step 2: 编译验证**
+
+```bash
+cd /workspace/sxsn/happytree
+mvn compile -pl happytree-sys -am -q 2>&1 | tail -5
+```
+
+期望输出：无 ERROR，最后一行为 `BUILD SUCCESS`。
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add happytree-sys/src/main/java/com/ringzle/modules/core/dto/FamilyMemberDTO.java
+git commit -m "feat: FamilyMemberDTO 新增 channelNames 字段"
+```
+
+---
+
+### Task 2: FamilyMemberServiceImpl 重写 page() 填充 channelNames
+
+**Files:**
+- Modify: `happytree-sys/src/main/java/com/ringzle/modules/core/service/impl/FamilyMemberServiceImpl.java`
+
+背景：`FamilyMemberEntity.channelIds` 是逗号分隔的渠道 ID 字符串（如 `"1,2,3"`），可能为 null 或空。`ChannelEntity` 有 `channelName` 字段，`channelDao` 已在 Service 中注入。
+
+- [ ] **Step 1: 在 FamilyMemberServiceImpl 中重写 page() 方法**
+
+在 `getWrapper()` 方法之前插入以下方法：
+
+```java
+@Override
+public PageData<FamilyMemberDTO> page(Map<String, Object> params) {
+    // 1. 调用基类查询
+    PageData<FamilyMemberDTO> pageData = super.page(params);
+    List<FamilyMemberDTO> list = pageData.getList();
+    if (CollectionUtil.isEmpty(list)) {
+        return pageData;
+    }
+
+    // 2. 收集所有非空 channelIds，解析出所有渠道 ID
+    List<Long> allChannelIds = list.stream()
+        .map(dto -> {
+            // 从 Entity 中取 channelIds（DTO 没有该字段，需重新查）
+            return dto.getId();
+        })
+        .collect(Collectors.toList());
+
+    // 批量查 Entity 以获取 channelIds 字段
+    List<FamilyMemberEntity> entities = baseDao.selectBatchIds(
+        list.stream().map(FamilyMemberDTO::getId).collect(Collectors.toList())
+    );
+
+    // 3. 建立 memberId -> channelIds 的 Map
+    Map<Long, String> memberChannelIdsMap = entities.stream()
+        .filter(e -> StringUtils.isNotBlank(e.getChannelIds()))
+        .collect(Collectors.toMap(FamilyMemberEntity::getId, FamilyMemberEntity::getChannelIds));
+
+    // 4. 收集所有渠道 ID，去重，一次性查渠道名
+    Set<Long> channelIdSet = memberChannelIdsMap.values().stream()
+        .flatMap(ids -> Arrays.stream(ids.split(",")))
+        .map(String::trim)
+        .filter(StringUtils::isNotBlank)
+        .map(Long::parseLong)
+        .collect(Collectors.toSet());
+
+    Map<Long, String> channelNameMap = new HashMap<>();
+    if (!channelIdSet.isEmpty()) {
+        Collection<com.ringzle.modules.core.entity.ChannelEntity> channels =
+            channelDao.selectBatchIds(channelIdSet);
+        channels.forEach(c -> channelNameMap.put(c.getId(), c.getChannelName()));
+    }
+
+    // 5. 逐行填充 channelNames
+    list.forEach(dto -> {
+        String channelIds = memberChannelIdsMap.get(dto.getId());
+        if (StringUtils.isBlank(channelIds)) {
+            dto.setChannelNames("");
+            return;
+        }
+        String names = Arrays.stream(channelIds.split(","))
+            .map(String::trim)
+            .filter(StringUtils::isNotBlank)
+            .map(id -> channelNameMap.getOrDefault(Long.parseLong(id), ""))
+            .filter(StringUtils::isNotBlank)
+            .collect(Collectors.joining("、"));
+        dto.setChannelNames(names);
+    });
+
+    return pageData;
+}
+```
+
+- [ ] **Step 2: 确认 import 完整**
+
+文件顶部 import 区域需包含以下（若已有则跳过）：
+
+```java
+import com.ringzle.common.page.PageData;
+import java.util.*;
+import java.util.stream.Collectors;
+```
+
+`Arrays`、`HashMap`、`Set`、`Collection` 均在 `java.util.*` 中，`StringUtils` 已有 `org.apache.commons.lang3.StringUtils`，`CollectionUtil` 已有 `cn.hutool.core.collection.CollectionUtil`。
+
+- [ ] **Step 3: 编译验证**
+
+```bash
+cd /workspace/sxsn/happytree
+mvn compile -pl happytree-sys -am -q 2>&1 | tail -5
+```
+
+期望：`BUILD SUCCESS`，无 ERROR。
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add happytree-sys/src/main/java/com/ringzle/modules/core/service/impl/FamilyMemberServiceImpl.java
+git commit -m "feat: 家庭成员列表分页接口填充渠道名称"
+```
+
+---
+
+### Task 3: 前端 familyMember.vue 新增「所属渠道」列
+
+**Files:**
+- Modify: `SxsnPC/src/views/modules/member/components/familyMember.vue`
+
+- [ ] **Step 1: 在「就读学校」列后插入「所属渠道」列**
+
+找到：
+```html
+<el-table-column prop="currentSchool" label="就读学校"></el-table-column>
+```
+
+在其后插入：
+```html
+<el-table-column label="所属渠道">
+  <template slot-scope="scope">{{ scope.row.channelNames || '-' }}</template>
+</el-table-column>
+```
+
+- [ ] **Step 2: 手动验证**
+
+打开管理端会员详情页，切换到「家庭成员」tab：
+- 有渠道的成员显示渠道名（如「渠道A、渠道B」）
+- 无渠道的成员显示「-」
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add SxsnPC/src/views/modules/member/components/familyMember.vue
+git commit -m "feat: 家庭成员列表新增所属渠道列"
+```
+
+---
+
+## 自检清单
+
+- [x] 规格「列表展示家庭成员绑定的渠道」→ Task 1 + Task 2 + Task 3
+- [x] 无 N+1：批量查 Entity + 批量查 Channel，两次查询搞定 → Task 2 Step 1
+- [x] channelIds 为 null/空时 channelNames 为空字符串，前端显示「-」→ Task 2 Step 1 + Task 3 Step 1
+- [x] 渠道 ID 不存在于 channelNameMap 时用 `getOrDefault` 跳过，不抛异常 → Task 2 Step 1
+- [x] 无 placeholder，所有步骤含完整代码

docs/superpowers/plans/2026-05-23-assign-love-value-to-member.md

@@ -0,0 +1,525 @@
+# 管理员分配爱心值给家庭成员 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** 管理员在家庭成员列表中，可从用户总账号余额分配爱心值给指定成员，同时写两条流水记录。
+
+**Architecture:** 后端新增 `assignLoveValue` 接口，在事务中完成余额校验、双向扣增、流水写入；前端在 `familyMember.vue` 新增爱心值列、分配按钮和弹窗，通过新增 prop `userLoveValue` 从 `detail.vue` 获取总账号余额。
+
+**Tech Stack:** Java 17、Spring Boot、MyBatis-Plus（后端）；Vue 2.6、Element UI（前端）
+
+---
+
+## 文件变更清单
+
+| 操作 | 文件 |
+|------|------|
+| Modify | `happytree-sys/src/main/java/com/ringzle/modules/core/dto/FamilyMemberDTO.java` |
+| Modify | `happytree-sys/src/main/java/com/ringzle/modules/core/service/FamilyMemberService.java` |
+| Modify | `happytree-sys/src/main/java/com/ringzle/modules/core/service/impl/FamilyMemberServiceImpl.java` |
+| Modify | `happytree-admin/src/main/java/com/ringzle/modules/core/FamilyMemberController.java` |
+| Modify | `SxsnPC/src/views/modules/member/components/familyMember.vue` |
+| Modify | `SxsnPC/src/views/modules/member/detail.vue` |
+
+---
+
+### Task 1: FamilyMemberDTO 新增 loveValue 字段
+
+**Files:**
+- Modify: `happytree-sys/src/main/java/com/ringzle/modules/core/dto/FamilyMemberDTO.java`
+
+- [ ] **Step 1: 在 channelIds 字段之前插入 loveValue 字段**
+
+找到文件中 `channelIds` 字段：
+```java
+	@ApiModelProperty(value = "可用渠道ID，逗号分隔")
+	private String channelIds;
+```
+
+在其前面插入：
+```java
+	@ApiModelProperty(value = "爱心值")
+	private BigDecimal loveValue;
+```
+
+同时确认文件顶部已有 `import java.math.BigDecimal;`（已有则跳过）。
+
+- [ ] **Step 2: Commit**
+
+```bash
+cd /workspace/sxsn/happytree
+git add happytree-sys/src/main/java/com/ringzle/modules/core/dto/FamilyMemberDTO.java
+git commit -m "feat: FamilyMemberDTO 新增 loveValue 字段"
+```
+
+---
+
+### Task 2: FamilyMemberService 新增 assignLoveValue 接口声明
+
+**Files:**
+- Modify: `happytree-sys/src/main/java/com/ringzle/modules/core/service/FamilyMemberService.java`
+
+- [ ] **Step 1: 在接口末尾新增方法声明**
+
+找到文件末尾 `getMemberChannels` 方法声明后，在 `}` 之前插入：
+
+```java
+    /**
+     * 管理员从总账号分配爱心值给家庭成员
+     * @param memberId 家庭成员 ID
+     * @param userId   总账号用户 ID
+     * @param amount   分配数量，必须 > 0 且 <= 总账号余额
+     */
+    void assignLoveValue(Long memberId, Long userId, BigDecimal amount);
+```
+
+同时在文件顶部 import 区域添加（若缺少）：
+```java
+import java.math.BigDecimal;
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+cd /workspace/sxsn/happytree
+git add happytree-sys/src/main/java/com/ringzle/modules/core/service/FamilyMemberService.java
+git commit -m "feat: FamilyMemberService 新增 assignLoveValue 接口"
+```
+
+---
+
+### Task 3: FamilyMemberServiceImpl — page() 填充 loveValue + 实现 assignLoveValue
+
+**Files:**
+- Modify: `happytree-sys/src/main/java/com/ringzle/modules/core/service/impl/FamilyMemberServiceImpl.java`
+
+背景：
+- `FamilyMemberServiceImpl` 已注入 `appUserService`（`AppUserService`）
+- `FamilyMemberServiceImpl` 已有 `page()` 重写方法，其中已通过 `baseDao.selectBatchIds` 批量查出 Entity 列表（用于填充 channelNames）
+- `LoveValueRecordEntity` 使用 Builder 模式，字段：`userId`, `capitalFlow`, `transactionType`, `memberId`, `loveQuantity`
+- `transactionType=3` 为本次新增类型（管理员分配）
+- `capitalFlow=1` 收入，`capitalFlow=2` 支出
+
+#### Step 1: 在 page() 方法中复用 entities，填充 loveValue
+
+找到 `page()` 方法中已有的 entities 批量查询和 channelNames 填充逻辑，在 `list.forEach` 填充 channelNames 的同时，追加填充 loveValue。
+
+当前 `page()` 方法中有：
+```java
+    List<FamilyMemberEntity> entities = baseDao.selectBatchIds(
+        list.stream().map(FamilyMemberDTO::getId).collect(Collectors.toList())
+    );
+```
+
+在该查询之后，建立 `memberId -> loveValue` 的 Map：
+```java
+    Map<Long, BigDecimal> memberLoveValueMap = entities.stream()
+        .collect(Collectors.toMap(FamilyMemberEntity::getId, e ->
+            e.getLoveValue() != null ? e.getLoveValue() : BigDecimal.ZERO));
+```
+
+然后在 `list.forEach` 中，在 `dto.setChannelNames(names)` 之后追加：
+```java
+        dto.setLoveValue(memberLoveValueMap.getOrDefault(dto.getId(), BigDecimal.ZERO));
+```
+
+- [ ] **Step 1: 修改 page() 方法，填充 loveValue**
+
+读取当前 `page()` 方法完整内容，按上述说明修改。完整修改后的 `page()` 方法应如下：
+
+```java
+@Override
+public PageData<FamilyMemberDTO> page(Map<String, Object> params) {
+    PageData<FamilyMemberDTO> pageData = super.page(params);
+    List<FamilyMemberDTO> list = pageData.getList();
+    if (CollectionUtil.isEmpty(list)) {
+        return pageData;
+    }
+
+    List<FamilyMemberEntity> entities = baseDao.selectBatchIds(
+        list.stream().map(FamilyMemberDTO::getId).collect(Collectors.toList())
+    );
+
+    Map<Long, String> memberChannelIdsMap = list.stream()
+        .filter(dto -> StringUtils.isNotBlank(dto.getChannelIds()))
+        .collect(Collectors.toMap(FamilyMemberDTO::getId, FamilyMemberDTO::getChannelIds));
+
+    Set<Long> channelIdSet = memberChannelIdsMap.values().stream()
+        .flatMap(ids -> Arrays.stream(ids.split(",")))
+        .map(String::trim)
+        .filter(StringUtils::isNotBlank)
+        .flatMap(id -> {
+            try { return java.util.stream.Stream.of(Long.parseLong(id)); }
+            catch (NumberFormatException e) { return java.util.stream.Stream.empty(); }
+        })
+        .collect(Collectors.toSet());
+
+    Map<Long, String> channelNameMap = new HashMap<>();
+    if (!channelIdSet.isEmpty()) {
+        Collection<ChannelEntity> channels = channelDao.selectBatchIds(channelIdSet);
+        channels.forEach(c -> channelNameMap.put(c.getId(), c.getChannelName()));
+    }
+
+    Map<Long, BigDecimal> memberLoveValueMap = entities.stream()
+        .collect(Collectors.toMap(FamilyMemberEntity::getId, e ->
+            e.getLoveValue() != null ? e.getLoveValue() : BigDecimal.ZERO));
+
+    list.forEach(dto -> {
+        String channelIds = memberChannelIdsMap.get(dto.getId());
+        if (StringUtils.isBlank(channelIds)) {
+            dto.setChannelNames("");
+        } else {
+            String names = Arrays.stream(channelIds.split(","))
+                .map(String::trim)
+                .filter(StringUtils::isNotBlank)
+                .map(id -> {
+                    try { return channelNameMap.getOrDefault(Long.parseLong(id), ""); }
+                    catch (NumberFormatException e) { return ""; }
+                })
+                .filter(StringUtils::isNotBlank)
+                .collect(Collectors.joining("、"));
+            dto.setChannelNames(names);
+        }
+        dto.setLoveValue(memberLoveValueMap.getOrDefault(dto.getId(), BigDecimal.ZERO));
+    });
+
+    return pageData;
+}
+```
+
+- [ ] **Step 2: 新增 assignLoveValue() 方法**
+
+在 `getMemberChannels()` 方法之后，类的 `}` 之前插入：
+
+```java
+@Override
+@Transactional(rollbackFor = Exception.class)
+public void assignLoveValue(Long memberId, Long userId, BigDecimal amount) {
+    if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) {
+        throw new RenException("分配数量必须大于0");
+    }
+
+    // 校验总账号余额
+    AppUserEntity user = appUserService.getEntityById(userId);
+    if (user == null) {
+        throw new RenException("用户不存在");
+    }
+    if (user.getLoveValue() == null || user.getLoveValue().compareTo(amount) < 0) {
+        throw new RenException("总账号余额不足");
+    }
+
+    // 校验成员属于该用户
+    FamilyMemberEntity member = baseDao.selectById(memberId);
+    if (member == null || !member.getUserId().equals(userId)) {
+        throw new RenException("家庭成员不存在");
+    }
+
+    // 扣减总账号余额
+    user.setLoveValue(user.getLoveValue().subtract(amount));
+    appUserService.updateById(user);
+
+    // 增加成员余额
+    BigDecimal memberLove = member.getLoveValue() != null ? member.getLoveValue() : BigDecimal.ZERO;
+    member.setLoveValue(memberLove.add(amount));
+    baseDao.updateById(member);
+
+    // 写流水：总账号支出
+    loveValueRecordDao.insert(LoveValueRecordEntity.builder()
+        .userId(userId)
+        .capitalFlow(2)
+        .transactionType(3)
+        .memberId(memberId)
+        .loveQuantity(amount.negate())
+        .build());
+
+    // 写流水：成员收入
+    loveValueRecordDao.insert(LoveValueRecordEntity.builder()
+        .userId(userId)
+        .capitalFlow(1)
+        .transactionType(3)
+        .memberId(memberId)
+        .loveQuantity(amount)
+        .build());
+}
+```
+
+- [ ] **Step 3: 注入 LoveValueRecordDao 和相关 import**
+
+在 `FamilyMemberServiceImpl` 的 `@Autowired` 注入区域新增：
+
+```java
+@Autowired
+private com.ringzle.modules.core.dao.LoveValueRecordDao loveValueRecordDao;
+```
+
+在文件顶部 import 区域新增（若缺少）：
+```java
+import com.ringzle.modules.core.dao.LoveValueRecordDao;
+import com.ringzle.modules.core.entity.LoveValueRecordEntity;
+```
+
+- [ ] **Step 4: 确认 appUserService.getEntityById() 方法存在**
+
+检查 `AppUserService` 接口是否有 `getEntityById(Long id)` 方法：
+
+```bash
+grep -n "getEntityById\|getById\|selectById" /workspace/sxsn/happytree/happytree-sys/src/main/java/com/ringzle/modules/core/service/AppUserService.java | head -10
+```
+
+若没有 `getEntityById`，改用 `appUserService` 的父类方法。检查 `AppUserServiceImpl` 中是否有直接查 Entity 的方法：
+
+```bash
+grep -n "getEntityById\|selectById\|AppUserEntity" /workspace/sxsn/happytree/happytree-sys/src/main/java/com/ringzle/modules/core/service/impl/AppUserServiceImpl.java | head -20
+```
+
+若无，则直接注入 `AppUserDao` 来查询 Entity：
+
+```java
+@Autowired
+private com.ringzle.modules.core.dao.AppUserDao appUserDao;
+```
+
+并将 `assignLoveValue` 中的 `appUserService.getEntityById(userId)` 替换为：
+```java
+AppUserEntity user = appUserDao.selectById(userId);
+```
+
+将 `appUserService.updateById(user)` 替换为：
+```java
+appUserDao.updateById(user);
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd /workspace/sxsn/happytree
+git add happytree-sys/src/main/java/com/ringzle/modules/core/service/impl/FamilyMemberServiceImpl.java
+git commit -m "feat: page() 填充 loveValue，新增 assignLoveValue 实现"
+```
+
+---
+
+### Task 4: FamilyMemberController 新增接口
+
+**Files:**
+- Modify: `happytree-admin/src/main/java/com/ringzle/modules/core/FamilyMemberController.java`
+
+- [ ] **Step 1: 新增 assignLoveValue 接口**
+
+在 `export` 方法之后，类的 `}` 之前插入：
+
+```java
+@PostMapping("assignLoveValue")
+@ApiOperation("分配爱心值给家庭成员")
+@LogOperation("分配爱心值")
+public Result assignLoveValue(@RequestParam Long memberId,
+                               @RequestParam Long userId,
+                               @RequestParam java.math.BigDecimal amount) {
+    familyMemberService.assignLoveValue(memberId, userId, amount);
+    return new Result();
+}
+```
+
+- [ ] **Step 2: 确认 import**
+
+文件顶部已有 `import com.ringzle.common.utils.Result;` 和 `import com.ringzle.common.annotation.LogOperation;`，无需新增。
+
+- [ ] **Step 3: Commit**
+
+```bash
+cd /workspace/sxsn/happytree
+git add happytree-admin/src/main/java/com/ringzle/modules/core/FamilyMemberController.java
+git commit -m "feat: 新增 POST /core/family/member/assignLoveValue 接口"
+```
+
+---
+
+### Task 5: 前端 familyMember.vue — 爱心值列 + 分配按钮 + 弹窗
+
+**Files:**
+- Modify: `SxsnPC/src/views/modules/member/components/familyMember.vue`
+
+- [ ] **Step 1: 新增 userLoveValue prop**
+
+找到：
+```js
+props: ['userId'],
+```
+替换为：
+```js
+props: ['userId', 'userLoveValue'],
+```
+
+- [ ] **Step 2: 在「所属渠道」列后新增「爱心值」列**
+
+找到：
+```html
+      <el-table-column label="所属渠道">
+        <template slot-scope="scope">{{ scope.row.channelNames || '-' }}</template>
+      </el-table-column>
+```
+
+在其后插入：
+```html
+      <el-table-column label="爱心值" width="100">
+        <template slot-scope="scope">{{ scope.row.loveValue || 0 }}</template>
+      </el-table-column>
+```
+
+- [ ] **Step 3: 新增操作列（分配按钮）**
+
+在「参与活动次数」列之后、`</el-table>` 之前插入：
+
+```html
+      <el-table-column label="操作" width="80">
+        <template slot-scope="scope">
+          <el-button type="text" @click="handleAssign(scope.row)">分配</el-button>
+        </template>
+      </el-table-column>
+```
+
+- [ ] **Step 4: 新增分配弹窗**
+
+在 `</div>` 最外层结束标签之前（`<style>` 之前）插入弹窗：
+
+```html
+    <el-dialog width="400px" :visible.sync="assignShow" title="分配爱心值" @close="cancelAssign">
+      <el-form label-width="120px" style="width: 90%; margin: 0 auto;">
+        <el-form-item label="成员姓名">
+          <span>{{ assignForm.memberName }}</span>
+        </el-form-item>
+        <el-form-item label="总账号余额">
+          <span>{{ userLoveValue || 0 }}</span>
+        </el-form-item>
+        <el-form-item label="分配数量">
+          <el-input-number
+            v-model="assignForm.amount"
+            :min="1"
+            :max="userLoveValue || 0"
+            :precision="0"
+            style="width: 100%;"
+          ></el-input-number>
+        </el-form-item>
+      </el-form>
+      <div style="display: flex; justify-content: flex-end; margin-top: 20px; padding-right: 5%;">
+        <el-button :loading="assignLoading" type="primary" @click="submitAssign">确 认</el-button>
+        <el-button @click="cancelAssign">取 消</el-button>
+      </div>
+    </el-dialog>
+```
+
+- [ ] **Step 5: 在 data() 中新增弹窗相关状态**
+
+找到 `data()` 的 `return` 对象，在 `loading: false` 后新增：
+
+```js
+      assignShow: false,
+      assignLoading: false,
+      assignForm: {
+        memberId: null,
+        memberName: '',
+        amount: 1
+      },
+```
+
+- [ ] **Step 6: 在 methods 中新增 handleAssign、submitAssign、cancelAssign**
+
+在 `pageCurrentChangeHandle` 方法之后新增：
+
+```js
+    handleAssign (row) {
+      this.assignForm.memberId = row.id
+      this.assignForm.memberName = row.name
+      this.assignForm.amount = 1
+      this.assignShow = true
+    },
+    submitAssign () {
+      if (!this.assignForm.amount || this.assignForm.amount <= 0) {
+        return this.$message.error('分配数量必须大于0')
+      }
+      this.assignLoading = true
+      this.$http.post('/core/family/member/assignLoveValue', null, {
+        params: {
+          memberId: this.assignForm.memberId,
+          userId: this.userId,
+          amount: this.assignForm.amount
+        }
+      }).then(res => {
+        if (res.data.code !== 0) {
+          this.$message.error(res.data.msg)
+        } else {
+          this.$message.success('分配成功')
+          this.cancelAssign()
+          this.getList()
+        }
+      }).catch(() => {
+        this.$message.error('操作失败，请重试')
+      }).finally(() => {
+        this.assignLoading = false
+      })
+    },
+    cancelAssign () {
+      this.assignShow = false
+      this.assignForm = { memberId: null, memberName: '', amount: 1 }
+    }
+```
+
+- [ ] **Step 7: Commit**
+
+```bash
+cd /workspace/sxsn/SxsnPC
+git add src/views/modules/member/components/familyMember.vue
+git commit -m "feat: 家庭成员列表新增爱心值列和分配功能"
+```
+
+---
+
+### Task 6: detail.vue 传入 userLoveValue prop
+
+**Files:**
+- Modify: `SxsnPC/src/views/modules/member/detail.vue`
+
+- [ ] **Step 1: 找到 family-member 组件调用处**
+
+找到（约第 100 行）：
+```html
+<family-member v-else-if="tabIndex===3" :userId="userId"></family-member>
+```
+
+替换为：
+```html
+<family-member v-else-if="tabIndex===3" :userId="userId" :userLoveValue="assetInfo ? assetInfo.loveValue : 0"></family-member>
+```
+
+- [ ] **Step 2: 手动验证**
+
+打开管理端会员详情页，切换到「家庭成员」tab：
+- 列表出现「爱心值」列，展示各成员余额
+- 每行有「分配」按钮
+- 点击「分配」弹窗显示成员姓名、总账号余额、分配数量输入框
+- 输入数量后点击确认，列表刷新，成员爱心值增加，总账号余额减少
+
+- [ ] **Step 3: Commit**
+
+```bash
+cd /workspace/sxsn/SxsnPC
+git add src/views/modules/member/detail.vue
+git commit -m "feat: detail.vue 向家庭成员组件传入总账号爱心值余额"
+```
+
+---
+
+## 自检清单
+
+- [x] 规格「分配数量 > 0」→ Task 3 Step 2 中 `amount.compareTo(BigDecimal.ZERO) <= 0` 校验
+- [x] 规格「分配数量 ≤ 总账号余额」→ Task 3 Step 2 中 `user.getLoveValue().compareTo(amount) < 0` 校验
+- [x] 规格「总账号 loveValue 扣减」→ Task 3 Step 2 `subtract`
+- [x] 规格「成员 loveValue 增加」→ Task 3 Step 2 `add`
+- [x] 规格「写两条流水，transactionType=3」→ Task 3 Step 2 两次 `loveValueRecordDao.insert`
+- [x] 规格「总账号支出：capitalFlow=2，loveQuantity 为负」→ Task 3 Step 2 `amount.negate()`
+- [x] 规格「成员收入：capitalFlow=1，loveQuantity 为正」→ Task 3 Step 2
+- [x] 规格「前端展示爱心值列」→ Task 5 Step 2
+- [x] 规格「前端分配按钮 + 弹窗」→ Task 5 Step 3-6
+- [x] 规格「弹窗展示总账号余额」→ Task 5 Step 4 + Task 6
+- [x] 规格「成功后刷新列表」→ Task 5 Step 6 `getList()`
+- [x] Task 3 Step 4 处理了 `appUserService.getEntityById` 可能不存在的情况

docs/superpowers/specs/2026-05-21-channel-admin-frontend-design.md

@@ -0,0 +1,71 @@
+# 管理端渠道列表页改造设计文档
+
+**日期：** 2026-05-21  
+**版本：** 1.0  
+**文件：** `src/views/modules/supplier/channel.vue`
+
+---
+
+## 1. 背景
+
+后端新增渠道二维码生成功能（`POST /core/channel/generateQr/{id}`），渠道分页接口响应新增 `code`、`qrUrl`、`qrCreateTime` 字段。管理端需配合展示新字段并提供生成二维码操作。
+
+---
+
+## 2. 改动范围
+
+仅修改 `src/views/modules/supplier/channel.vue`，不新增文件。
+
+---
+
+## 3. 表格列变更
+
+| 列 | 改动 | 说明 |
+|----|------|------|
+| 渠道方名称 | 不变 | — |
+| 渠道码 | **新增** | 展示 `code` 字段，纯文本 |
+| 二维码 | **新增** | 见下方逻辑 |
+| 联系人 | 不变 | — |
+| 联系方式 | 不变 | — |
+| 操作 | 新增按钮 | 新增「生成二维码」按钮 |
+
+**二维码列逻辑：**
+- `qrUrl` 有值：使用 `el-image` 展示 60×60 缩略图，`preview-src-list` 支持点击放大
+- `qrUrl` 为 null：展示灰色文字「未生成」
+
+---
+
+## 4. 生成二维码交互
+
+```
+点击「生成二维码」
+  → 该行按钮进入 loading（loadingIds 数组记录行 id）
+  → POST /core/channel/generateQr/{id}
+  → 成功：就地更新 dataList 中该行的 qrUrl，按钮恢复正常
+  → 失败：$message.error(res.data.msg)，按钮恢复正常
+```
+
+per-row loading 用 `loadingIds: []` 数组实现，避免多行同时操作互相干扰。
+
+---
+
+## 5. 数据层
+
+`getDataList()` 调用 `GET /core/channel/page`，后端响应已包含新字段，前端无需修改接口调用，直接使用 `code`、`qrUrl` 字段即可。
+
+---
+
+## 6. 错误处理
+
+| 场景 | 处理 |
+|------|------|
+| 生成二维码失败 | `$message.error(res.data.msg)` |
+| 网络异常 | catch 中 `$message.error('操作失败，请重试')` |
+
+---
+
+## 7. 不在本次范围内
+
+- 小程序端改造（登录/注册渠道参数、我的渠道页、家庭成员渠道设置）
+- H5 扫码落地页
+- 新增渠道表单（无需改动，code 由后端自动生成）

node_modules/.bin/baseline-browser-mapping

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../baseline-browser-mapping/dist/cli.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../baseline-browser-mapping/dist/cli.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/baseline-browser-mapping

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

node_modules/.bin/browserslist

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../browserslist/cli.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../browserslist/cli.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/browserslist

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

node_modules/.bin/eslint

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../eslint/bin/eslint.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../eslint/bin/eslint.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/eslint

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

node_modules/.bin/js-yaml

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../js-yaml/bin/js-yaml.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../js-yaml/bin/js-yaml.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/js-yaml

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

node_modules/.bin/multicast-dns

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../multicast-dns/cli.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../multicast-dns/cli.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/multicast-dns

@@ -0,0 +1 @@
+../multicast-dns/cli.js

node_modules/.bin/nanoid

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
-  ret=$?
-else 
-  node  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/nanoid

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

node_modules/.bin/node-sass

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../node-sass/bin/node-sass" "$@"
-  ret=$?
-else 
-  node  "$basedir/../node-sass/bin/node-sass" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/node-sass

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

node_modules/.bin/parser

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/parser

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

node_modules/.bin/update-browserslist-db

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../update-browserslist-db/cli.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../update-browserslist-db/cli.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/update-browserslist-db

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

node_modules/@babel/helper-compilation-targets/node_modules/.bin/browserslist

@@ -1,15 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -x "$basedir/node" ]; then
-  "$basedir/node"  "$basedir/../browserslist/cli.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../browserslist/cli.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/LICENSE

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright 2014 Andrey Sitnik <andrey@sitnik.ru> 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.

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/README.md

@@ -1,65 +0,0 @@
-# Browserslist
-
-<img width="120" height="120" alt="Browserslist logo by Anton Popov"
-     src="https://browsersl.ist/logo.svg" align="right">
-
-The config to share target browsers and Node.js versions between different
-front-end tools. It is used in:
-
-* [Autoprefixer]
-* [Babel]
-* [postcss-preset-env]
-* [eslint-plugin-compat]
-* [stylelint-no-unsupported-browser-features]
-* [postcss-normalize]
-* [obsolete-webpack-plugin]
-
-All tools will find target browsers automatically,
-when you add the following to `package.json`:
-
-```json
-  "browserslist": [
-    "defaults and fully supports es6-module",
-    "maintained node versions"
-  ]
-```
-
-Or in `.browserslistrc` config:
-
-```yaml
-# Browsers that we support
-
-defaults and fully supports es6-module
-maintained node versions
-```
-
-Developers set their version lists using queries like `last 2 versions`
-to be free from updating versions manually.
-Browserslist will use [`caniuse-lite`] with [Can I Use] data for this queries.
-
-You can check how config works at our playground: [`browsersl.ist`](https://browsersl.ist/)
-
-<a href="https://browsersl.ist/">
-  <img src="/img/screenshot.webp" alt="browsersl.ist website">
-</a>
-
-<br>
-<br>
-<div align="center">
-  <a href="https://evilmartians.com/?utm_source=browserslist"><img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>  <a href="https://cube.dev/?ref=eco-browserslist-github"><img src="https://user-images.githubusercontent.com/986756/154330861-d79ab8ec-aacb-4af8-9e17-1b28f1eccb01.svg" alt="Supported by Cube" width="227" height="46"></a>
-</div>
-
-[stylelint-no-unsupported-browser-features]: https://github.com/ismay/stylelint-no-unsupported-browser-features
-[obsolete-webpack-plugin]:                   https://github.com/ElemeFE/obsolete-webpack-plugin
-[eslint-plugin-compat]:                      https://github.com/amilajack/eslint-plugin-compat
-[Browserslist Example]:                      https://github.com/browserslist/browserslist-example
-[postcss-preset-env]:                        https://github.com/csstools/postcss-plugins/tree/main/plugin-packs/postcss-preset-env
-[postcss-normalize]:                         https://github.com/csstools/postcss-normalize
-[`browsersl.ist`]:                           https://browsersl.ist/
-[`caniuse-lite`]:                            https://github.com/ben-eb/caniuse-lite
-[Autoprefixer]:                              https://github.com/postcss/autoprefixer
-[Can I Use]:                                 https://caniuse.com/
-[Babel]:                                     https://github.com/babel/babel/tree/master/packages/babel-preset-env
-
-## Docs
-Read full docs **[here](https://github.com/browserslist/browserslist#readme)**.

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/browser.js

@@ -1,54 +0,0 @@
-var BrowserslistError = require('./error')
-
-function noop() {}
-
-module.exports = {
-  loadQueries: function loadQueries() {
-    throw new BrowserslistError(
-      'Sharable configs are not supported in client-side build of Browserslist'
-    )
-  },
-
-  getStat: function getStat(opts) {
-    return opts.stats
-  },
-
-  loadConfig: function loadConfig(opts) {
-    if (opts.config) {
-      throw new BrowserslistError(
-        'Browserslist config are not supported in client-side build'
-      )
-    }
-  },
-
-  loadCountry: function loadCountry() {
-    throw new BrowserslistError(
-      'Country statistics are not supported ' +
-        'in client-side build of Browserslist'
-    )
-  },
-
-  loadFeature: function loadFeature() {
-    throw new BrowserslistError(
-      'Supports queries are not available in client-side build of Browserslist'
-    )
-  },
-
-  currentNode: function currentNode(resolve, context) {
-    return resolve(['maintained node versions'], context)[0]
-  },
-
-  parseConfig: noop,
-
-  readConfig: noop,
-
-  findConfig: noop,
-
-  findConfigFile: noop,
-
-  clearCaches: noop,
-
-  oldDataWarning: noop,
-
-  env: {}
-}

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/cli.js

@@ -1,156 +0,0 @@
-#!/usr/bin/env node
-
-var fs = require('fs')
-var updateDb = require('update-browserslist-db')
-
-var browserslist = require('./')
-var pkg = require('./package.json')
-
-var args = process.argv.slice(2)
-
-var USAGE =
-  'Usage:\n' +
-  '  npx browserslist\n' +
-  '  npx browserslist "QUERIES"\n' +
-  '  npx browserslist --json "QUERIES"\n' +
-  '  npx browserslist --config="path/to/browserlist/file"\n' +
-  '  npx browserslist --coverage "QUERIES"\n' +
-  '  npx browserslist --coverage=US "QUERIES"\n' +
-  '  npx browserslist --coverage=US,RU,global "QUERIES"\n' +
-  '  npx browserslist --env="environment name defined in config"\n' +
-  '  npx browserslist --stats="path/to/browserlist/stats/file"\n' +
-  '  npx browserslist --mobile-to-desktop\n' +
-  '  npx browserslist --ignore-unknown-versions\n'
-
-function isArg(arg) {
-  return args.some(function (str) {
-    return str === arg || str.indexOf(arg + '=') === 0
-  })
-}
-
-function error(msg) {
-  process.stderr.write('browserslist: ' + msg + '\n')
-  process.exit(1)
-}
-
-if (isArg('--help') || isArg('-h')) {
-  process.stdout.write(pkg.description + '.\n\n' + USAGE + '\n')
-} else if (isArg('--version') || isArg('-v')) {
-  process.stdout.write('browserslist ' + pkg.version + '\n')
-} else if (isArg('--update-db')) {
-  /* c8 ignore next 8 */
-  process.stdout.write(
-    'The --update-db command is deprecated.\n' +
-      'Please use npx update-browserslist-db@latest instead.\n'
-  )
-  process.stdout.write('Browserslist DB update will still be made.\n')
-  updateDb(function (str) {
-    process.stdout.write(str)
-  })
-} else {
-  var mode = 'browsers'
-  var opts = {}
-  var queries
-  var areas
-
-  for (var i = 0; i < args.length; i++) {
-    if (args[i][0] !== '-') {
-      queries = args[i].replace(/^["']|["']$/g, '')
-      continue
-    }
-
-    var arg = args[i].split('=')
-    var name = arg[0]
-    var value = arg[1]
-
-    if (value) value = value.replace(/^["']|["']$/g, '')
-
-    if (name === '--config' || name === '-b') {
-      opts.config = value
-    } else if (name === '--env' || name === '-e') {
-      opts.env = value
-    } else if (name === '--stats' || name === '-s') {
-      opts.stats = value
-    } else if (name === '--coverage' || name === '-c') {
-      if (mode !== 'json') mode = 'coverage'
-      if (value) {
-        areas = value.split(',')
-      } else {
-        areas = ['global']
-      }
-    } else if (name === '--json') {
-      mode = 'json'
-    } else if (name === '--mobile-to-desktop') {
-      /* c8 ignore next */
-      opts.mobileToDesktop = true
-    } else if (name === '--ignore-unknown-versions') {
-      /* c8 ignore next */
-      opts.ignoreUnknownVersions = true
-    } else {
-      error('Unknown arguments ' + args[i] + '.\n\n' + USAGE)
-    }
-  }
-
-  var browsers
-  try {
-    browsers = browserslist(queries, opts)
-  } catch (e) {
-    if (e.name === 'BrowserslistError') {
-      error(e.message)
-    } /* c8 ignore start */ else {
-      throw e
-    } /* c8 ignore end */
-  }
-
-  var coverage
-  if (mode === 'browsers') {
-    browsers.forEach(function (browser) {
-      process.stdout.write(browser + '\n')
-    })
-  } else if (areas) {
-    coverage = areas.map(function (area) {
-      var stats
-      if (area !== 'global') {
-        stats = area
-      } else if (opts.stats) {
-        stats = JSON.parse(fs.readFileSync(opts.stats))
-      }
-      var result = browserslist.coverage(browsers, stats)
-      var round = Math.round(result * 100) / 100.0
-
-      return [area, round]
-    })
-
-    if (mode === 'coverage') {
-      var prefix = 'These browsers account for '
-      process.stdout.write(prefix)
-      coverage.forEach(function (data, index) {
-        var area = data[0]
-        var round = data[1]
-        var end = 'globally'
-        if (area && area !== 'global') {
-          end = 'in the ' + area.toUpperCase()
-        } else if (opts.stats) {
-          end = 'in custom statistics'
-        }
-
-        if (index !== 0) {
-          process.stdout.write(prefix.replace(/./g, ' '))
-        }
-
-        process.stdout.write(round + '% of all users ' + end + '\n')
-      })
-    }
-  }
-
-  if (mode === 'json') {
-    var data = { browsers: browsers }
-    if (coverage) {
-      data.coverage = coverage.reduce(function (object, j) {
-        object[j[0]] = j[1]
-        return object
-      }, {})
-    }
-    process.stdout.write(JSON.stringify(data, null, '  ') + '\n')
-  }
-}

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/error.d.ts

@@ -1,7 +0,0 @@
-declare class BrowserslistError extends Error {
-  constructor(message: any)
-  name: 'BrowserslistError'
-  browserslist: true
-}
-
-export = BrowserslistError

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/error.js

@@ -1,12 +0,0 @@
-function BrowserslistError(message) {
-  this.name = 'BrowserslistError'
-  this.message = message
-  this.browserslist = true
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, BrowserslistError)
-  }
-}
-
-BrowserslistError.prototype = Error.prototype
-
-module.exports = BrowserslistError

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/index.d.ts

@@ -1,224 +0,0 @@
-/**
- * Return array of browsers by selection queries.
- *
- * ```js
- * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
- * ```
- *
- * @param queries Browser queries.
- * @param opts Options.
- * @returns Array with browser names in Can I Use.
- */
-declare function browserslist(
-  queries?: string | readonly string[] | null,
-  opts?: browserslist.Options
-): string[]
-
-declare namespace browserslist {
-  interface Query {
-    compose: 'or' | 'and'
-    type: string
-    query: string
-    not?: true
-  }
-
-  interface Options {
-    /**
-     * Path to processed file. It will be used to find config files.
-     */
-    path?: string | false
-    /**
-     * Processing environment. It will be used to take right queries
-     * from config file.
-     */
-    env?: string
-    /**
-     * Custom browser usage statistics for "> 1% in my stats" query.
-     */
-    stats?: Stats | string
-    /**
-     * Path to config file with queries.
-     */
-    config?: string
-    /**
-     * Do not throw on unknown version in direct query.
-     */
-    ignoreUnknownVersions?: boolean
-    /**
-     * Throw an error if env is not found.
-     */
-    throwOnMissing?: boolean
-    /**
-     * Disable security checks for extend query.
-     */
-    dangerousExtend?: boolean
-    /**
-     * Alias mobile browsers to the desktop version when Can I Use
-     * doesn’t have data about the specified version.
-     */
-    mobileToDesktop?: boolean
-  }
-
-  type Config = {
-    defaults: string[]
-    [section: string]: string[] | undefined
-  }
-
-  interface Stats {
-    [browser: string]: {
-      [version: string]: number
-    }
-  }
-
-  /**
-   * Browser names aliases.
-   */
-  let aliases: {
-    [alias: string]: string | undefined
-  }
-
-  /**
-   * Aliases to work with joined versions like `ios_saf 7.0-7.1`.
-   */
-  let versionAliases: {
-    [browser: string]:
-      | {
-          [version: string]: string | undefined
-        }
-      | undefined
-  }
-
-  /**
-   * Can I Use only provides a few versions for some browsers (e.g. `and_chr`).
-   *
-   * Fallback to a similar browser for unknown versions.
-   */
-  let desktopNames: {
-    [browser: string]: string | undefined
-  }
-
-  let data: {
-    [browser: string]:
-      | {
-          name: string
-          versions: string[]
-          released: string[]
-          releaseDate: {
-            [version: string]: number | undefined | null
-          }
-        }
-      | undefined
-  }
-
-  let nodeVersions: string[]
-
-  interface Usage {
-    [version: string]: number
-  }
-
-  let usage: {
-    global?: Usage
-    custom?: Usage | null
-    [country: string]: Usage | undefined | null
-  }
-
-  let cache: {
-    [feature: string]: {
-      [name: string]: {
-        [version: string]: string
-      }
-    }
-  }
-
-  /**
-   * Default browsers query
-   */
-  let defaults: readonly string[]
-
-  /**
-   * Which statistics should be used. Country code or custom statistics.
-   * Pass `"my stats"` to load statistics from `Browserslist` files.
-   */
-  type StatsOptions = string | 'my stats' | Stats | { dataByBrowser: Stats }
-
-  /**
-   * Return browsers market coverage.
-   *
-   * ```js
-   * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
-   * ```
-   *
-   * @param browsers Browsers names in Can I Use.
-   * @param stats Which statistics should be used.
-   * @returns Total market coverage for all selected browsers.
-   */
-  function coverage(browsers: readonly string[], stats?: StatsOptions): number
-
-  /**
-   * Get queries AST to analyze the config content.
-   *
-   * @param queries Browser queries.
-   * @param opts Options.
-   * @returns An array of the data of each query in the config.
-   */
-  function parse(
-    queries?: string | readonly string[] | null,
-    opts?: browserslist.Options
-  ): Query[]
-
-  /**
-   * Return queries for specific file inside the project.
-   *
-   * ```js
-   * browserslist.loadConfig({
-   *   file: process.cwd()
-   * }) ?? browserslist.defaults
-   * ```
-   */
-  function loadConfig(options: LoadConfigOptions): string[] | undefined
-
-  function clearCaches(): void
-
-  function parseConfig(string: string): Config
-
-  function readConfig(file: string): Config
-
-  function findConfig(...pathSegments: string[]): Config | undefined
-
-  function findConfigFile(...pathSegments: string[]): string | undefined
-
-  interface LoadConfigOptions {
-    /**
-     * Path to config file
-     * */
-    config?: string
-
-    /**
-     * Path to file inside the project to find Browserslist config
-     * in closest folder
-     */
-    path?: string
-
-    /**
-     * Environment to choose part of config.
-     */
-    env?: string
-  }
-}
-
-declare global {
-  namespace NodeJS {
-    interface ProcessEnv {
-      BROWSERSLIST?: string
-      BROWSERSLIST_CONFIG?: string
-      BROWSERSLIST_DANGEROUS_EXTEND?: string
-      BROWSERSLIST_DISABLE_CACHE?: string
-      BROWSERSLIST_ENV?: string
-      BROWSERSLIST_IGNORE_OLD_DATA?: string
-      BROWSERSLIST_STATS?: string
-      BROWSERSLIST_ROOT_PATH?: string
-    }
-  }
-}
-
-export = browserslist

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/node.js

@@ -1,497 +0,0 @@
-var feature = require('caniuse-lite/dist/unpacker/feature').default
-var region = require('caniuse-lite/dist/unpacker/region').default
-var fs = require('fs')
-var path = require('path')
-
-var BrowserslistError = require('./error')
-
-var IS_SECTION = /^\s*\[(.+)]\s*$/
-var CONFIG_PATTERN = /^browserslist-config-/
-var SCOPED_CONFIG__PATTERN = /@[^/]+(?:\/[^/]+)?\/browserslist-config(?:-|$|\/)/
-var FORMAT =
-  'Browserslist config should be a string or an array ' +
-  'of strings with browser queries'
-var PATHTYPE_UNKNOWN = 'unknown'
-var PATHTYPE_DIR = 'directory'
-var PATHTYPE_FILE = 'file'
-
-var dataTimeChecked = false
-var statCache = {}
-var configPathCache = {}
-var parseConfigCache = {}
-
-function checkExtend(name) {
-  var use = ' Use `dangerousExtend` option to disable.'
-  if (!CONFIG_PATTERN.test(name) && !SCOPED_CONFIG__PATTERN.test(name)) {
-    throw new BrowserslistError(
-      'Browserslist config needs `browserslist-config-` prefix. ' + use
-    )
-  }
-  if (name.replace(/^@[^/]+\//, '').indexOf('.') !== -1) {
-    throw new BrowserslistError(
-      '`.` not allowed in Browserslist config name. ' + use
-    )
-  }
-  if (name.indexOf('node_modules') !== -1) {
-    throw new BrowserslistError(
-      '`node_modules` not allowed in Browserslist config.' + use
-    )
-  }
-}
-
-function getPathType(filepath) {
-  var stats
-  try {
-    stats = fs.existsSync(filepath) && fs.statSync(filepath)
-  } catch (err) {
-    /* c8 ignore start */
-    if (
-      err.code !== 'ENOENT' &&
-      err.code !== 'EACCES' &&
-      err.code !== 'ERR_ACCESS_DENIED'
-    ) {
-      throw err
-    }
-    /* c8 ignore end */
-  }
-
-  if (stats && stats.isDirectory()) return PATHTYPE_DIR
-  if (stats && stats.isFile()) return PATHTYPE_FILE
-
-  return PATHTYPE_UNKNOWN
-}
-
-function isFile(file) {
-  return getPathType(file) === PATHTYPE_FILE
-}
-
-function isDirectory(dir) {
-  return getPathType(dir) === PATHTYPE_DIR
-}
-
-function eachParent(file, callback, cache) {
-  var loc = path.resolve(file)
-  var pathsForCacheResult = []
-  var result
-  do {
-    if (!pathInRoot(loc)) {
-      break
-    }
-    if (cache && loc in cache) {
-      result = cache[loc]
-      break
-    }
-    pathsForCacheResult.push(loc)
-
-    if (!isDirectory(loc)) {
-      continue
-    }
-
-    var locResult = callback(loc)
-    if (typeof locResult !== 'undefined') {
-      result = locResult
-      break
-    }
-  } while (loc !== (loc = path.dirname(loc)))
-
-  if (cache && !process.env.BROWSERSLIST_DISABLE_CACHE) {
-    pathsForCacheResult.forEach(function (cachePath) {
-      cache[cachePath] = result
-    })
-  }
-  return result
-}
-
-function pathInRoot(p) {
-  if (!process.env.BROWSERSLIST_ROOT_PATH) return true
-  var rootPath = path.resolve(process.env.BROWSERSLIST_ROOT_PATH)
-  if (path.relative(rootPath, p).substring(0, 2) === '..') {
-    return false
-  }
-  return true
-}
-
-function check(section) {
-  if (Array.isArray(section)) {
-    for (var i = 0; i < section.length; i++) {
-      if (typeof section[i] !== 'string') {
-        throw new BrowserslistError(FORMAT)
-      }
-    }
-  } else if (typeof section !== 'string') {
-    throw new BrowserslistError(FORMAT)
-  }
-}
-
-function pickEnv(config, opts) {
-  if (typeof config !== 'object') return config
-
-  var name
-  if (typeof opts.env === 'string') {
-    name = opts.env
-  } else if (process.env.BROWSERSLIST_ENV) {
-    name = process.env.BROWSERSLIST_ENV
-  } else if (process.env.NODE_ENV) {
-    name = process.env.NODE_ENV
-  } else {
-    name = 'production'
-  }
-
-  if (opts.throwOnMissing) {
-    if (name && name !== 'defaults' && !config[name]) {
-      throw new BrowserslistError(
-        'Missing config for Browserslist environment `' + name + '`'
-      )
-    }
-  }
-
-  return config[name] || config.defaults
-}
-
-function parsePackage(file) {
-  var text = fs
-    .readFileSync(file)
-    .toString()
-    .replace(/^\uFEFF/m, '')
-  var list
-  if (text.indexOf('"browserslist"') >= 0) {
-    list = JSON.parse(text).browserslist
-  } else if (text.indexOf('"browserlist"') >= 0) {
-    var config = JSON.parse(text)
-    if (config.browserlist && !config.browserslist) {
-      throw new BrowserslistError(
-        '`browserlist` key instead of `browserslist` in ' + file
-      )
-    }
-  }
-  if (Array.isArray(list) || typeof list === 'string') {
-    list = { defaults: list }
-  }
-  for (var i in list) {
-    check(list[i])
-  }
-
-  return list
-}
-
-function parsePackageOrReadConfig(file) {
-  if (file in parseConfigCache) {
-    return parseConfigCache[file]
-  }
-
-  var isPackage = path.basename(file) === 'package.json'
-  var result = isPackage ? parsePackage(file) : module.exports.readConfig(file)
-
-  if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
-    parseConfigCache[file] = result
-  }
-  return result
-}
-
-function latestReleaseTime(agents) {
-  var latest = 0
-  for (var name in agents) {
-    var dates = agents[name].releaseDate || {}
-    for (var key in dates) {
-      if (latest < dates[key]) {
-        latest = dates[key]
-      }
-    }
-  }
-  return latest * 1000
-}
-
-function getMonthsPassed(date) {
-  var now = new Date()
-  var past = new Date(date)
-
-  var years = now.getFullYear() - past.getFullYear()
-  var months = now.getMonth() - past.getMonth()
-
-  return years * 12 + months
-}
-
-function normalizeStats(data, stats) {
-  if (!data) {
-    data = {}
-  }
-  if (stats && 'dataByBrowser' in stats) {
-    stats = stats.dataByBrowser
-  }
-
-  if (typeof stats !== 'object') return undefined
-
-  var normalized = {}
-  for (var i in stats) {
-    var versions = Object.keys(stats[i])
-    if (versions.length === 1 && data[i] && data[i].versions.length === 1) {
-      var normal = data[i].versions[0]
-      normalized[i] = {}
-      normalized[i][normal] = stats[i][versions[0]]
-    } else {
-      normalized[i] = stats[i]
-    }
-  }
-
-  return normalized
-}
-
-function normalizeUsageData(usageData, data) {
-  for (var browser in usageData) {
-    var browserUsage = usageData[browser]
-    // https://github.com/browserslist/browserslist/issues/431#issuecomment-565230615
-    // caniuse-db returns { 0: "percentage" } for `and_*` regional stats
-    if ('0' in browserUsage) {
-      var versions = data[browser].versions
-      browserUsage[versions[versions.length - 1]] = browserUsage[0]
-      delete browserUsage[0]
-    }
-  }
-}
-
-module.exports = {
-  loadQueries: function loadQueries(ctx, name) {
-    if (!ctx.dangerousExtend && !process.env.BROWSERSLIST_DANGEROUS_EXTEND) {
-      checkExtend(name)
-    }
-    var queries = require(require.resolve(name, { paths: ['.', ctx.path] }))
-    if (typeof queries === 'object' && queries !== null && queries.__esModule) {
-      queries = queries.default
-    }
-    if (queries) {
-      if (Array.isArray(queries)) {
-        return queries
-      } else if (typeof queries === 'object') {
-        if (!queries.defaults) queries.defaults = []
-        return pickEnv(queries, ctx, name)
-      }
-    }
-    throw new BrowserslistError(
-      '`' +
-        name +
-        '` config exports not an array of queries' +
-        ' or an object of envs'
-    )
-  },
-
-  loadStat: function loadStat(ctx, name, data) {
-    if (!ctx.dangerousExtend && !process.env.BROWSERSLIST_DANGEROUS_EXTEND) {
-      checkExtend(name)
-    }
-    var stats = require(
-      // Use forward slashes for module paths, also on Windows.
-      require.resolve(path.posix.join(name, 'browserslist-stats.json'), {
-        paths: ['.']
-      })
-    )
-    return normalizeStats(data, stats)
-  },
-
-  getStat: function getStat(opts, data) {
-    var stats
-    if (opts.stats) {
-      stats = opts.stats
-    } else if (process.env.BROWSERSLIST_STATS) {
-      stats = process.env.BROWSERSLIST_STATS
-    } else if (opts.path && path.resolve && fs.existsSync) {
-      stats = eachParent(
-        opts.path,
-        function (dir) {
-          var file = path.join(dir, 'browserslist-stats.json')
-          return isFile(file) ? file : undefined
-        },
-        statCache
-      )
-    }
-    if (typeof stats === 'string') {
-      try {
-        stats = JSON.parse(fs.readFileSync(stats))
-      } catch (e) {
-        throw new BrowserslistError("Can't read " + stats)
-      }
-    }
-    return normalizeStats(data, stats)
-  },
-
-  loadConfig: function loadConfig(opts) {
-    if (process.env.BROWSERSLIST) {
-      return process.env.BROWSERSLIST
-    } else if (opts.config || process.env.BROWSERSLIST_CONFIG) {
-      var file = opts.config || process.env.BROWSERSLIST_CONFIG
-      return pickEnv(parsePackageOrReadConfig(file), opts)
-    } else if (opts.path) {
-      return pickEnv(module.exports.findConfig(opts.path), opts)
-    } else {
-      return undefined
-    }
-  },
-
-  loadCountry: function loadCountry(usage, country, data) {
-    var code = country.replace(/[^\w-]/g, '')
-    if (!usage[code]) {
-      var compressed
-      try {
-        compressed = require('caniuse-lite/data/regions/' + code + '.js')
-      } catch (e) {
-        throw new BrowserslistError('Unknown region name `' + code + '`.')
-      }
-      var usageData = region(compressed)
-      normalizeUsageData(usageData, data)
-      usage[country] = {}
-      for (var i in usageData) {
-        for (var j in usageData[i]) {
-          usage[country][i + ' ' + j] = usageData[i][j]
-        }
-      }
-    }
-  },
-
-  loadFeature: function loadFeature(features, name) {
-    name = name.replace(/[^\w-]/g, '')
-    if (features[name]) return
-    var compressed
-    try {
-      compressed = require('caniuse-lite/data/features/' + name + '.js')
-    } catch (e) {
-      throw new BrowserslistError('Unknown feature name `' + name + '`.')
-    }
-    var stats = feature(compressed).stats
-    features[name] = {}
-    for (var i in stats) {
-      features[name][i] = {}
-      for (var j in stats[i]) {
-        features[name][i][j] = stats[i][j]
-      }
-    }
-  },
-
-  parseConfig: function parseConfig(string) {
-    var result = { defaults: [] }
-    var sections = ['defaults']
-
-    string
-      .toString()
-      .replace(/#[^\n]*/g, '')
-      .split(/\n|,/)
-      .map(function (line) {
-        return line.trim()
-      })
-      .filter(function (line) {
-        return line !== ''
-      })
-      .forEach(function (line) {
-        if (IS_SECTION.test(line)) {
-          sections = line.match(IS_SECTION)[1].trim().split(' ')
-          sections.forEach(function (section) {
-            if (result[section]) {
-              throw new BrowserslistError(
-                'Duplicate section ' + section + ' in Browserslist config'
-              )
-            }
-            result[section] = []
-          })
-        } else {
-          sections.forEach(function (section) {
-            result[section].push(line)
-          })
-        }
-      })
-
-    return result
-  },
-
-  readConfig: function readConfig(file) {
-    if (!isFile(file)) {
-      throw new BrowserslistError("Can't read " + file + ' config')
-    }
-
-    return module.exports.parseConfig(fs.readFileSync(file))
-  },
-
-  findConfigFile: function findConfigFile(from) {
-    return eachParent(
-      from,
-      function (dir) {
-        var config = path.join(dir, 'browserslist')
-        var pkg = path.join(dir, 'package.json')
-        var rc = path.join(dir, '.browserslistrc')
-
-        var pkgBrowserslist
-        if (isFile(pkg)) {
-          try {
-            pkgBrowserslist = parsePackage(pkg)
-          } catch (e) {
-            if (e.name === 'BrowserslistError') throw e
-            console.warn(
-              '[Browserslist] Could not parse ' + pkg + '. Ignoring it.'
-            )
-          }
-        }
-
-        if (isFile(config) && pkgBrowserslist) {
-          throw new BrowserslistError(
-            dir + ' contains both browserslist and package.json with browsers'
-          )
-        } else if (isFile(rc) && pkgBrowserslist) {
-          throw new BrowserslistError(
-            dir +
-              ' contains both .browserslistrc and package.json with browsers'
-          )
-        } else if (isFile(config) && isFile(rc)) {
-          throw new BrowserslistError(
-            dir + ' contains both .browserslistrc and browserslist'
-          )
-        } else if (isFile(config)) {
-          return config
-        } else if (isFile(rc)) {
-          return rc
-        } else if (pkgBrowserslist) {
-          return pkg
-        }
-      },
-      configPathCache
-    )
-  },
-
-  findConfig: function findConfig(from) {
-    var configFile = this.findConfigFile(from)
-
-    return configFile ? parsePackageOrReadConfig(configFile) : undefined
-  },
-
-  clearCaches: function clearCaches() {
-    dataTimeChecked = false
-    statCache = {}
-    configPathCache = {}
-    parseConfigCache = {}
-
-    this.cache = {}
-  },
-
-  oldDataWarning: function oldDataWarning(agentsObj) {
-    if (dataTimeChecked) return
-    dataTimeChecked = true
-    if (process.env.BROWSERSLIST_IGNORE_OLD_DATA) return
-
-    var latest = latestReleaseTime(agentsObj)
-    var monthsPassed = getMonthsPassed(latest)
-
-    if (latest !== 0 && monthsPassed >= 6) {
-      var months = monthsPassed + ' ' + (monthsPassed > 1 ? 'months' : 'month')
-      console.warn(
-        'Browserslist: browsers data (caniuse-lite) is ' +
-          months +
-          ' old. Please run:\n' +
-          '  npx update-browserslist-db@latest\n' +
-          '  Why you should do it regularly: ' +
-          'https://github.com/browserslist/update-db#readme'
-      )
-    }
-  },
-
-  currentNode: function currentNode() {
-    return 'node ' + process.versions.node
-  },
-
-  env: process.env
-}

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/package.json

@@ -1,80 +0,0 @@
-{
-  "_from": "browserslist@^4.24.0",
-  "_id": "browserslist@4.26.3",
-  "_inBundle": false,
-  "_integrity": "sha512-lAUU+02RFBuCKQPj/P6NgjlbCnLBMp4UtgTx7vNHd3XSIJF87s9a5rA3aH2yw3GS9DqZAUbOtZdCCiZeVRqt0w==",
-  "_location": "/@babel/helper-compilation-targets/browserslist",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "browserslist@^4.24.0",
-    "name": "browserslist",
-    "escapedName": "browserslist",
-    "rawSpec": "^4.24.0",
-    "saveSpec": null,
-    "fetchSpec": "^4.24.0"
-  },
-  "_requiredBy": [
-    "/@babel/helper-compilation-targets"
-  ],
-  "_resolved": "https://registry.npmmirror.com/browserslist/-/browserslist-4.26.3.tgz",
-  "_shasum": "40fbfe2d1cd420281ce5b1caa8840049c79afb56",
-  "_spec": "browserslist@^4.24.0",
-  "_where": "D:\\HTC\\program\\善行少年\\security-enterprise-admin\\node_modules\\@babel\\helper-compilation-targets",
-  "author": {
-    "name": "Andrey Sitnik",
-    "email": "andrey@sitnik.ru"
-  },
-  "bin": {
-    "browserslist": "cli.js"
-  },
-  "browser": {
-    "./node.js": "./browser.js",
-    "path": false
-  },
-  "bugs": {
-    "url": "https://github.com/browserslist/browserslist/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "baseline-browser-mapping": "^2.8.9",
-    "caniuse-lite": "^1.0.30001746",
-    "electron-to-chromium": "^1.5.227",
-    "node-releases": "^2.0.21",
-    "update-browserslist-db": "^1.1.3"
-  },
-  "deprecated": false,
-  "description": "Share target browsers between different front-end tools, like Autoprefixer, Stylelint and babel-env-preset",
-  "engines": {
-    "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
-  },
-  "funding": [
-    {
-      "type": "opencollective",
-      "url": "https://opencollective.com/browserslist"
-    },
-    {
-      "type": "tidelift",
-      "url": "https://tidelift.com/funding/github/npm/browserslist"
-    },
-    {
-      "type": "github",
-      "url": "https://github.com/sponsors/ai"
-    }
-  ],
-  "homepage": "https://github.com/browserslist/browserslist#readme",
-  "keywords": [
-    "caniuse",
-    "browsers",
-    "target"
-  ],
-  "license": "MIT",
-  "name": "browserslist",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/browserslist/browserslist.git"
-  },
-  "types": "./index.d.ts",
-  "version": "4.26.3"
-}

node_modules/@babel/helper-compilation-targets/node_modules/browserslist/parse.js

@@ -1,78 +0,0 @@
-var AND_REGEXP = /^\s+and\s+(.*)/i
-var OR_REGEXP = /^(?:,\s*|\s+or\s+)(.*)/i
-
-function flatten(array) {
-  if (!Array.isArray(array)) return [array]
-  return array.reduce(function (a, b) {
-    return a.concat(flatten(b))
-  }, [])
-}
-
-function find(string, predicate) {
-  for (var max = string.length, n = 1; n <= max; n++) {
-    var parsed = string.substr(-n, n)
-    if (predicate(parsed, n, max)) {
-      return string.slice(0, -n)
-    }
-  }
-  return ''
-}
-
-function matchQuery(all, query) {
-  var node = { query: query }
-  if (query.indexOf('not ') === 0) {
-    node.not = true
-    query = query.slice(4)
-  }
-
-  for (var name in all) {
-    var type = all[name]
-    var match = query.match(type.regexp)
-    if (match) {
-      node.type = name
-      for (var i = 0; i < type.matches.length; i++) {
-        node[type.matches[i]] = match[i + 1]
-      }
-      return node
-    }
-  }
-
-  node.type = 'unknown'
-  return node
-}
-
-function matchBlock(all, string, qs) {
-  var node
-  return find(string, function (parsed, n, max) {
-    if (AND_REGEXP.test(parsed)) {
-      node = matchQuery(all, parsed.match(AND_REGEXP)[1])
-      node.compose = 'and'
-      qs.unshift(node)
-      return true
-    } else if (OR_REGEXP.test(parsed)) {
-      node = matchQuery(all, parsed.match(OR_REGEXP)[1])
-      node.compose = 'or'
-      qs.unshift(node)
-      return true
-    } else if (n === max) {
-      node = matchQuery(all, parsed.trim())
-      node.compose = 'or'
-      qs.unshift(node)
-      return true
-    }
-    return false
-  })
-}
-
-module.exports = function parse(all, queries) {
-  if (!Array.isArray(queries)) queries = [queries]
-  return flatten(
-    queries.map(function (block) {
-      var qs = []
-      do {
-        block = matchBlock(all, block, qs)
-      } while (block)
-      return qs
-    })
-  )
-}

node_modules/@babel/helper-module-transforms/lib/dynamic-import.js

@@ -5,12 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.buildDynamicImport = buildDynamicImport;
 var _core = require("@babel/core");
-{
-  exports.getDynamicImportSource = function getDynamicImportSource(node) {
-    const [source] = node.arguments;
-    return _core.types.isStringLiteral(source) || _core.types.isTemplateLiteral(source) ? source : _core.template.expression.ast`\`\${${source}}\``;
-  };
-}
+exports.getDynamicImportSource = function getDynamicImportSource(node) {
+  const [source] = node.arguments;
+  return _core.types.isStringLiteral(source) || _core.types.isTemplateLiteral(source) ? source : _core.template.expression.ast`\`\${${source}}\``;
+};
 function buildDynamicImport(node, deferToThen, wrapWithPromise, builder) {
   const specifier = _core.types.isCallExpression(node) ? node.arguments[0] : node.source;
   if (_core.types.isStringLiteral(specifier) || _core.types.isTemplateLiteral(specifier) && specifier.quasis.length === 0) {

node_modules/@babel/helper-module-transforms/lib/get-module-name.js

@@ -4,18 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = getModuleName;
-{
-  const originalGetModuleName = getModuleName;
-  exports.default = getModuleName = function getModuleName(rootOpts, pluginOpts) {
-    var _pluginOpts$moduleId, _pluginOpts$moduleIds, _pluginOpts$getModule, _pluginOpts$moduleRoo;
-    return originalGetModuleName(rootOpts, {
-      moduleId: (_pluginOpts$moduleId = pluginOpts.moduleId) != null ? _pluginOpts$moduleId : rootOpts.moduleId,
-      moduleIds: (_pluginOpts$moduleIds = pluginOpts.moduleIds) != null ? _pluginOpts$moduleIds : rootOpts.moduleIds,
-      getModuleId: (_pluginOpts$getModule = pluginOpts.getModuleId) != null ? _pluginOpts$getModule : rootOpts.getModuleId,
-      moduleRoot: (_pluginOpts$moduleRoo = pluginOpts.moduleRoot) != null ? _pluginOpts$moduleRoo : rootOpts.moduleRoot
-    });
-  };
-}
+const originalGetModuleName = getModuleName;
+exports.default = getModuleName = function getModuleName(rootOpts, pluginOpts) {
+  var _pluginOpts$moduleId, _pluginOpts$moduleIds, _pluginOpts$getModule, _pluginOpts$moduleRoo;
+  return originalGetModuleName(rootOpts, {
+    moduleId: (_pluginOpts$moduleId = pluginOpts.moduleId) != null ? _pluginOpts$moduleId : rootOpts.moduleId,
+    moduleIds: (_pluginOpts$moduleIds = pluginOpts.moduleIds) != null ? _pluginOpts$moduleIds : rootOpts.moduleIds,
+    getModuleId: (_pluginOpts$getModule = pluginOpts.getModuleId) != null ? _pluginOpts$getModule : rootOpts.getModuleId,
+    moduleRoot: (_pluginOpts$moduleRoo = pluginOpts.moduleRoot) != null ? _pluginOpts$moduleRoo : rootOpts.moduleRoot
+  });
+};
 function getModuleName(rootOpts, pluginOpts) {
   const {
     filename,

node_modules/@babel/helper-module-transforms/lib/index.js

@@ -52,9 +52,7 @@ var _normalizeAndLoadMetadata = require("./normalize-and-load-metadata.js");
 var Lazy = require("./lazy-modules.js");
 var _dynamicImport = require("./dynamic-import.js");
 var _getModuleName = require("./get-module-name.js");
-{
-  exports.getDynamicImportSource = require("./dynamic-import").getDynamicImportSource;
-}
+exports.getDynamicImportSource = require("./dynamic-import").getDynamicImportSource;
 function rewriteModuleStatementsAndPrepareHeader(path, {
   exportName,
   strict,

node_modules/@babel/helper-module-transforms/lib/normalize-and-load-metadata.js

@@ -328,11 +328,9 @@ function getLocalExportMetadata(programPath, initializeReexports, stringSpecifie
 }
 function nameAnonymousExports(programPath) {
   programPath.get("body").forEach(child => {
+    var _child$splitExportDec;
     if (!child.isExportDefaultDeclaration()) return;
-    {
-      var _child$splitExportDec;
-      (_child$splitExportDec = child.splitExportDeclaration) != null ? _child$splitExportDec : child.splitExportDeclaration = require("@babel/traverse").NodePath.prototype.splitExportDeclaration;
-    }
+    (_child$splitExportDec = child.splitExportDeclaration) != null ? _child$splitExportDec : child.splitExportDeclaration = require("@babel/traverse").NodePath.prototype.splitExportDeclaration;
     child.splitExportDeclaration();
   });
 }

node_modules/@babel/helper-module-transforms/node_modules/@babel/code-frame/lib/index.js

@@ -38,39 +38,39 @@ const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
 const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
 const BRACKET = /^[()[\]{}]$/;
 let tokenize;
-{
-  const JSX_TAG = /^[a-z][\w-]*$/i;
-  const getTokenType = function (token, offset, text) {
-    if (token.type === "name") {
-      if (helperValidatorIdentifier.isKeyword(token.value) || helperValidatorIdentifier.isStrictReservedWord(token.value, true) || sometimesKeywords.has(token.value)) {
-        return "keyword";
-      }
-      if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
-        return "jsxIdentifier";
-      }
-      if (token.value[0] !== token.value[0].toLowerCase()) {
-        return "capitalized";
-      }
+const JSX_TAG = /^[a-z][\w-]*$/i;
+const getTokenType = function (token, offset, text) {
+  if (token.type === "name") {
+    const tokenValue = token.value;
+    if (helperValidatorIdentifier.isKeyword(tokenValue) || helperValidatorIdentifier.isStrictReservedWord(tokenValue, true) || sometimesKeywords.has(tokenValue)) {
+      return "keyword";
     }
-    if (token.type === "punctuator" && BRACKET.test(token.value)) {
-      return "bracket";
+    if (JSX_TAG.test(tokenValue) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
+      return "jsxIdentifier";
     }
-    if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
-      return "punctuator";
+    const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));
+    if (firstChar !== firstChar.toLowerCase()) {
+      return "capitalized";
     }
-    return token.type;
-  };
-  tokenize = function* (text) {
-    let match;
-    while (match = jsTokens.default.exec(text)) {
-      const token = jsTokens.matchToToken(match);
-      yield {
-        type: getTokenType(token, match.index, text),
-        value: token.value
-      };
-    }
-  };
-}
+  }
+  if (token.type === "punctuator" && BRACKET.test(token.value)) {
+    return "bracket";
+  }
+  if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+    return "punctuator";
+  }
+  return token.type;
+};
+tokenize = function* (text) {
+  let match;
+  while (match = jsTokens.default.exec(text)) {
+    const token = jsTokens.matchToToken(match);
+    yield {
+      type: getTokenType(token, match.index, text),
+      value: token.value
+    };
+  }
+};
 function highlight(text) {
   if (text === "") return "";
   const defs = getDefs(true);
@@ -90,7 +90,7 @@ function highlight(text) {
 
 let deprecationWarningShown = false;
 const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-function getMarkerLines(loc, source, opts) {
+function getMarkerLines(loc, source, opts, startLineBaseZero) {
   const startLoc = Object.assign({
     column: 0,
     line: -1
@@ -100,9 +100,9 @@ function getMarkerLines(loc, source, opts) {
     linesAbove = 2,
     linesBelow = 3
   } = opts || {};
-  const startLine = startLoc.line;
+  const startLine = startLoc.line - startLineBaseZero;
   const startColumn = startLoc.column;
-  const endLine = endLoc.line;
+  const endLine = endLoc.line - startLineBaseZero;
   const endColumn = endLoc.column;
   let start = Math.max(startLine - (linesAbove + 1), 0);
   let end = Math.min(source.length, endLine + linesBelow);
@@ -148,19 +148,20 @@ function getMarkerLines(loc, source, opts) {
 }
 function codeFrameColumns(rawLines, loc, opts = {}) {
   const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
+  const startLineBaseZero = (opts.startLine || 1) - 1;
   const defs = getDefs(shouldHighlight);
   const lines = rawLines.split(NEWLINE);
   const {
     start,
     end,
     markerLines
-  } = getMarkerLines(loc, lines, opts);
+  } = getMarkerLines(loc, lines, opts, startLineBaseZero);
   const hasColumns = loc.start && typeof loc.start.column === "number";
-  const numberMaxWidth = String(end).length;
+  const numberMaxWidth = String(end + startLineBaseZero).length;
   const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
   let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
     const number = start + 1 + index;
-    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth);
     const gutter = ` ${paddedNumber} |`;
     const hasMarker = markerLines[number];
     const lastMarkerLine = !markerLines[number + 1];

node_modules/@babel/helper-module-transforms/node_modules/@babel/code-frame/package.json

@@ -1,63 +1,32 @@
 {
-  "_from": "@babel/code-frame@^7.27.1",
-  "_id": "@babel/code-frame@7.27.1",
-  "_inBundle": false,
-  "_integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
-  "_location": "/@babel/helper-module-transforms/@babel/code-frame",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "@babel/code-frame@^7.27.1",
-    "name": "@babel/code-frame",
-    "escapedName": "@babel%2fcode-frame",
-    "scope": "@babel",
-    "rawSpec": "^7.27.1",
-    "saveSpec": null,
-    "fetchSpec": "^7.27.1"
-  },
-  "_requiredBy": [
-    "/@babel/helper-module-transforms/@babel/template",
-    "/@babel/helper-module-transforms/@babel/traverse"
-  ],
-  "_resolved": "https://registry.npmmirror.com/@babel/code-frame/-/code-frame-7.27.1.tgz",
-  "_shasum": "200f715e66d52a23b221a9435534a91cc13ad5be",
-  "_spec": "@babel/code-frame@^7.27.1",
-  "_where": "D:\\HTC\\program\\善行少年\\security-enterprise-admin\\node_modules\\@babel\\helper-module-transforms\\node_modules\\@babel\\traverse",
-  "author": {
-    "name": "The Babel Team",
-    "url": "https://babel.dev/team"
+  "name": "@babel/code-frame",
+  "version": "7.29.0",
+  "description": "Generate errors that contain a code frame that point to source locations.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-code-frame",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
   },
-  "bugs": {
-    "url": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-code-frame"
   },
-  "bundleDependencies": false,
+  "main": "./lib/index.js",
   "dependencies": {
-    "@babel/helper-validator-identifier": "^7.27.1",
+    "@babel/helper-validator-identifier": "^7.28.5",
     "js-tokens": "^4.0.0",
     "picocolors": "^1.1.1"
   },
-  "deprecated": false,
-  "description": "Generate errors that contain a code frame that point to source locations.",
   "devDependencies": {
+    "charcodes": "^0.2.0",
     "import-meta-resolve": "^4.1.0",
     "strip-ansi": "^4.0.0"
   },
   "engines": {
     "node": ">=6.9.0"
   },
-  "homepage": "https://babel.dev/docs/en/next/babel-code-frame",
-  "license": "MIT",
-  "main": "./lib/index.js",
-  "name": "@babel/code-frame",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/babel/babel.git",
-    "directory": "packages/babel-code-frame"
-  },
-  "type": "commonjs",
-  "version": "7.27.1"
-}
+  "type": "commonjs"
+}

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/buffer.js

@@ -4,6 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+const spaceIndents = [];
+for (let i = 0; i < 32; i++) {
+  spaceIndents.push(" ".repeat(i * 2));
+}
 class Buffer {
   constructor(map, indentChar) {
     this._map = null;
@@ -11,11 +15,9 @@ class Buffer {
     this._str = "";
     this._appendCount = 0;
     this._last = 0;
-    this._queue = [];
-    this._queueCursor = 0;
     this._canMarkIdName = true;
     this._indentChar = "";
-    this._fastIndentations = [];
+    this._queuedChar = 0;
     this._position = {
       line: 1,
       column: 0
@@ -29,55 +31,32 @@ class Buffer {
     };
     this._map = map;
     this._indentChar = indentChar;
-    for (let i = 0; i < 64; i++) {
-      this._fastIndentations.push(indentChar.repeat(i));
-    }
-    this._allocQueue();
-  }
-  _allocQueue() {
-    const queue = this._queue;
-    for (let i = 0; i < 16; i++) {
-      queue.push({
-        char: 0,
-        repeat: 1,
-        line: undefined,
-        column: undefined,
-        identifierName: undefined,
-        identifierNamePos: undefined,
-        filename: ""
-      });
-    }
-  }
-  _pushQueue(char, repeat, line, column, filename) {
-    const cursor = this._queueCursor;
-    if (cursor === this._queue.length) {
-      this._allocQueue();
-    }
-    const item = this._queue[cursor];
-    item.char = char;
-    item.repeat = repeat;
-    item.line = line;
-    item.column = column;
-    item.filename = filename;
-    this._queueCursor++;
-  }
-  _popQueue() {
-    if (this._queueCursor === 0) {
-      throw new Error("Cannot pop from empty queue");
-    }
-    return this._queue[--this._queueCursor];
   }
   get() {
-    this._flush();
-    const map = this._map;
+    const {
+      _map,
+      _last
+    } = this;
+    if (this._queuedChar !== 32) {
+      this._flush();
+    }
+    const code = _last === 10 ? (this._buf + this._str).trimRight() : this._buf + this._str;
+    if (_map === null) {
+      return {
+        code: code,
+        decodedMap: undefined,
+        map: null,
+        rawMappings: undefined
+      };
+    }
     const result = {
-      code: (this._buf + this._str).trimRight(),
-      decodedMap: map == null ? void 0 : map.getDecoded(),
+      code: code,
+      decodedMap: _map.getDecoded(),
       get __mergedMap() {
         return this.map;
       },
       get map() {
-        const resultMap = map ? map.get() : null;
+        const resultMap = _map.get();
         result.map = resultMap;
         return resultMap;
       },
@@ -88,7 +67,7 @@ class Buffer {
         });
       },
       get rawMappings() {
-        const mappings = map == null ? void 0 : map.getRawMappings();
+        const mappings = _map.getRawMappings();
         result.rawMappings = mappings;
         return mappings;
       },
@@ -103,66 +82,57 @@ class Buffer {
   }
   append(str, maybeNewline) {
     this._flush();
-    this._append(str, this._sourcePosition, maybeNewline);
+    this._append(str, maybeNewline);
   }
   appendChar(char) {
     this._flush();
-    this._appendChar(char, 1, this._sourcePosition);
+    this._appendChar(char, 1, true);
   }
   queue(char) {
-    if (char === 10) {
-      while (this._queueCursor !== 0) {
-        const char = this._queue[this._queueCursor - 1].char;
-        if (char !== 32 && char !== 9) {
-          break;
-        }
-        this._queueCursor--;
-      }
-    }
-    const sourcePosition = this._sourcePosition;
-    this._pushQueue(char, 1, sourcePosition.line, sourcePosition.column, sourcePosition.filename);
-  }
-  queueIndentation(repeat) {
-    if (repeat === 0) return;
-    this._pushQueue(-1, repeat, undefined, undefined, undefined);
+    this._flush();
+    this._queuedChar = char;
   }
   _flush() {
-    const queueCursor = this._queueCursor;
-    const queue = this._queue;
-    for (let i = 0; i < queueCursor; i++) {
-      const item = queue[i];
-      this._appendChar(item.char, item.repeat, item);
+    const queuedChar = this._queuedChar;
+    if (queuedChar !== 0) {
+      this._appendChar(queuedChar, 1, true);
+      this._queuedChar = 0;
     }
-    this._queueCursor = 0;
   }
-  _appendChar(char, repeat, sourcePos) {
+  _appendChar(char, repeat, useSourcePos) {
     this._last = char;
     if (char === -1) {
-      const fastIndentation = this._fastIndentations[repeat];
-      if (fastIndentation !== undefined) {
-        this._str += fastIndentation;
-      } else {
-        this._str += repeat > 1 ? this._indentChar.repeat(repeat) : this._indentChar;
-      }
+      const indent = repeat >= 64 ? this._indentChar.repeat(repeat) : spaceIndents[repeat / 2];
+      this._str += indent;
     } else {
       this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char);
     }
+    const isSpace = char === 32;
+    const position = this._position;
     if (char !== 10) {
-      this._mark(sourcePos.line, sourcePos.column, sourcePos.identifierName, sourcePos.identifierNamePos, sourcePos.filename);
-      this._position.column += repeat;
+      if (this._map) {
+        const sourcePos = this._sourcePosition;
+        if (useSourcePos && sourcePos) {
+          this._map.mark(position, sourcePos.line, sourcePos.column, isSpace ? undefined : sourcePos.identifierName, isSpace ? undefined : sourcePos.identifierNamePos, sourcePos.filename);
+          if (!isSpace && this._canMarkIdName) {
+            sourcePos.identifierName = undefined;
+            sourcePos.identifierNamePos = undefined;
+          }
+        } else {
+          this._map.mark(position);
+        }
+      }
+      position.column += repeat;
     } else {
-      this._position.line++;
-      this._position.column = 0;
-    }
-    if (this._canMarkIdName) {
-      sourcePos.identifierName = undefined;
-      sourcePos.identifierNamePos = undefined;
+      position.line++;
+      position.column = 0;
     }
   }
-  _append(str, sourcePos, maybeNewline) {
+  _append(str, maybeNewline) {
     const len = str.length;
     const position = this._position;
-    this._last = str.charCodeAt(len - 1);
+    const sourcePos = this._sourcePosition;
+    this._last = -1;
     if (++this._appendCount > 4096) {
       +this._str;
       this._buf += this._str;
@@ -171,7 +141,8 @@ class Buffer {
     } else {
       this._str += str;
     }
-    if (!maybeNewline && !this._map) {
+    const hasMap = this._map !== null;
+    if (!maybeNewline && !hasMap) {
       position.column += len;
       return;
     }
@@ -188,67 +159,40 @@ class Buffer {
     }
     let i = str.indexOf("\n");
     let last = 0;
-    if (i !== 0) {
-      this._mark(line, column, identifierName, identifierNamePos, filename);
+    if (hasMap && i !== 0) {
+      this._map.mark(position, line, column, identifierName, identifierNamePos, filename);
     }
     while (i !== -1) {
       position.line++;
       position.column = 0;
       last = i + 1;
       if (last < len && line !== undefined) {
-        this._mark(++line, 0, null, null, filename);
+        line++;
+        if (hasMap) {
+          this._map.mark(position, line, 0, undefined, undefined, filename);
+        }
       }
       i = str.indexOf("\n", last);
     }
     position.column += len - last;
   }
-  _mark(line, column, identifierName, identifierNamePos, filename) {
-    var _this$_map;
-    (_this$_map = this._map) == null || _this$_map.mark(this._position, line, column, identifierName, identifierNamePos, filename);
-  }
-  removeTrailingNewline() {
-    const queueCursor = this._queueCursor;
-    if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 10) {
-      this._queueCursor--;
-    }
-  }
   removeLastSemicolon() {
-    const queueCursor = this._queueCursor;
-    if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 59) {
-      this._queueCursor--;
+    if (this._queuedChar === 59) {
+      this._queuedChar = 0;
     }
   }
-  getLastChar() {
-    const queueCursor = this._queueCursor;
-    return queueCursor !== 0 ? this._queue[queueCursor - 1].char : this._last;
-  }
-  getNewlineCount() {
-    const queueCursor = this._queueCursor;
-    let count = 0;
-    if (queueCursor === 0) return this._last === 10 ? 1 : 0;
-    for (let i = queueCursor - 1; i >= 0; i--) {
-      if (this._queue[i].char !== 10) {
-        break;
-      }
-      count++;
+  getLastChar(checkQueue) {
+    if (!checkQueue) {
+      return this._last;
     }
-    return count === queueCursor && this._last === 10 ? count + 1 : count;
+    const queuedChar = this._queuedChar;
+    return queuedChar !== 0 ? queuedChar : this._last;
   }
-  endsWithCharAndNewline() {
-    const queue = this._queue;
-    const queueCursor = this._queueCursor;
-    if (queueCursor !== 0) {
-      const lastCp = queue[queueCursor - 1].char;
-      if (lastCp !== 10) return;
-      if (queueCursor > 1) {
-        return queue[queueCursor - 2].char;
-      } else {
-        return this._last;
-      }
-    }
+  getNewlineCount() {
+    return this._queuedChar === 0 && this._last === 10 ? 1 : 0;
   }
   hasContent() {
-    return this._queueCursor !== 0 || !!this._last;
+    return this._last !== 0;
   }
   exactSource(loc, cb) {
     if (!this._map) {
@@ -258,12 +202,12 @@ class Buffer {
     this.source("start", loc);
     const identifierName = loc.identifierName;
     const sourcePos = this._sourcePosition;
-    if (identifierName) {
+    if (identifierName != null) {
       this._canMarkIdName = false;
       sourcePos.identifierName = identifierName;
     }
     cb();
-    if (identifierName) {
+    if (identifierName != null) {
       this._canMarkIdName = true;
       sourcePos.identifierName = undefined;
       sourcePos.identifierNamePos = undefined;
@@ -279,6 +223,7 @@ class Buffer {
     this._normalizePosition(prop, loc, columnOffset);
   }
   _normalizePosition(prop, loc, columnOffset) {
+    this._flush();
     const pos = loc[prop];
     const target = this._sourcePosition;
     if (pos) {
@@ -288,28 +233,10 @@ class Buffer {
     }
   }
   getCurrentColumn() {
-    const queue = this._queue;
-    const queueCursor = this._queueCursor;
-    let lastIndex = -1;
-    let len = 0;
-    for (let i = 0; i < queueCursor; i++) {
-      const item = queue[i];
-      if (item.char === 10) {
-        lastIndex = len;
-      }
-      len += item.repeat;
-    }
-    return lastIndex === -1 ? this._position.column + len : len - 1 - lastIndex;
+    return this._position.column + (this._queuedChar ? 1 : 0);
   }
   getCurrentLine() {
-    let count = 0;
-    const queue = this._queue;
-    for (let i = 0; i < this._queueCursor; i++) {
-      if (queue[i].char === 10) {
-        count++;
-      }
-    }
-    return this._position.line + count;
+    return this._position.line;
   }
 }
 exports.default = Buffer;

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/base.js

@@ -18,13 +18,12 @@ function File(node) {
 }
 function Program(node) {
   var _node$directives;
-  this.noIndentInnerCommentsHere();
-  this.printInnerComments();
+  this.printInnerComments(false);
   const directivesLen = (_node$directives = node.directives) == null ? void 0 : _node$directives.length;
   if (directivesLen) {
     var _node$directives$trai;
     const newline = node.body.length ? 2 : 1;
-    this.printSequence(node.directives, undefined, newline);
+    this.printSequence(node.directives, undefined, undefined, newline);
     if (!((_node$directives$trai = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai.length)) {
       this.newline(newline);
     }
@@ -34,18 +33,18 @@ function Program(node) {
 function BlockStatement(node) {
   var _node$directives2;
   this.tokenChar(123);
-  const exit = this.enterDelimited();
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
   const directivesLen = (_node$directives2 = node.directives) == null ? void 0 : _node$directives2.length;
   if (directivesLen) {
     var _node$directives$trai2;
     const newline = node.body.length ? 2 : 1;
-    this.printSequence(node.directives, true, newline);
+    this.printSequence(node.directives, true, true, newline);
     if (!((_node$directives$trai2 = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai2.length)) {
       this.newline(newline);
     }
   }
-  this.printSequence(node.body, true);
-  exit();
+  this.printSequence(node.body, true, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   this.rightBrace(node);
 }
 function Directive(node) {
@@ -73,7 +72,7 @@ function DirectiveLiteral(node) {
 }
 function InterpreterDirective(node) {
   this.token(`#!${node.value}`);
-  this.newline(1, true);
+  this._newline();
 }
 function Placeholder(node) {
   this.token("%%");

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/classes.js

@@ -13,13 +13,17 @@ exports.ClassProperty = ClassProperty;
 exports.StaticBlock = StaticBlock;
 exports._classMethodHead = _classMethodHead;
 var _t = require("@babel/types");
+var _expressions = require("./expressions.js");
+var _typescript = require("./typescript.js");
+var _flow = require("./flow.js");
+var _methods = require("./methods.js");
 const {
   isExportDefaultDeclaration,
   isExportNamedDeclaration
 } = _t;
 function ClassDeclaration(node, parent) {
   const inExport = isExportDefaultDeclaration(parent) || isExportNamedDeclaration(parent);
-  if (!inExport || !this._shouldPrintDecoratorsBeforeExport(parent)) {
+  if (!inExport || !_expressions._shouldPrintDecoratorsBeforeExport.call(this, parent)) {
     this.printJoin(node.decorators);
   }
   if (node.declare) {
@@ -57,12 +61,11 @@ function ClassBody(node) {
   if (node.body.length === 0) {
     this.tokenChar(125);
   } else {
-    this.newline();
     const separator = classBodyEmptySemicolonsPrinter(this, node);
     separator == null || separator(-1);
-    const exit = this.enterDelimited();
-    this.printJoin(node.body, true, true, separator, true);
-    exit();
+    const oldNoLineTerminatorAfterNode = this.enterDelimited();
+    this.printJoin(node.body, true, true, separator, true, true);
+    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
     if (!this.endsWith(10)) this.newline();
     this.rightBrace(node);
   }
@@ -90,7 +93,7 @@ function classBodyEmptySemicolonsPrinter(printer, node) {
     const end = nextLocIndex === node.body.length ? node.end : node.body[nextLocIndex].start;
     let tok;
     while (k < indexes.length && printer.tokenMap.matchesOriginal(tok = printer._tokens[indexes[k]], ";") && tok.start < end) {
-      printer.token(";", undefined, occurrenceCount++);
+      printer.tokenChar(59, occurrenceCount++);
       k++;
     }
   };
@@ -102,13 +105,13 @@ function ClassProperty(node) {
     const endLine = (_node$key$loc = node.key.loc) == null || (_node$key$loc = _node$key$loc.end) == null ? void 0 : _node$key$loc.line;
     if (endLine) this.catchUp(endLine);
   }
-  this.tsPrintClassMemberModifiers(node);
+  _typescript._tsPrintClassMemberModifiers.call(this, node);
   if (node.computed) {
     this.tokenChar(91);
     this.print(node.key);
     this.tokenChar(93);
   } else {
-    this._variance(node);
+    _flow._variance.call(this, node);
     this.print(node.key);
   }
   if (node.optional) {
@@ -131,7 +134,7 @@ function ClassAccessorProperty(node) {
   this.printJoin(node.decorators);
   const endLine = (_node$key$loc2 = node.key.loc) == null || (_node$key$loc2 = _node$key$loc2.end) == null ? void 0 : _node$key$loc2.line;
   if (endLine) this.catchUp(endLine);
-  this.tsPrintClassMemberModifiers(node);
+  _typescript._tsPrintClassMemberModifiers.call(this, node);
   this.word("accessor", true);
   this.space();
   if (node.computed) {
@@ -139,7 +142,7 @@ function ClassAccessorProperty(node) {
     this.print(node.key);
     this.tokenChar(93);
   } else {
-    this._variance(node);
+    _flow._variance.call(this, node);
     this.print(node.key);
   }
   if (node.optional) {
@@ -159,7 +162,7 @@ function ClassAccessorProperty(node) {
 }
 function ClassPrivateProperty(node) {
   this.printJoin(node.decorators);
-  this.tsPrintClassMemberModifiers(node);
+  _typescript._tsPrintClassMemberModifiers.call(this, node);
   this.print(node.key);
   if (node.optional) {
     this.tokenChar(63);
@@ -177,12 +180,12 @@ function ClassPrivateProperty(node) {
   this.semicolon();
 }
 function ClassMethod(node) {
-  this._classMethodHead(node);
+  _classMethodHead.call(this, node);
   this.space();
   this.print(node.body);
 }
 function ClassPrivateMethod(node) {
-  this._classMethodHead(node);
+  _classMethodHead.call(this, node);
   this.space();
   this.print(node.body);
 }
@@ -193,8 +196,8 @@ function _classMethodHead(node) {
     const endLine = (_node$key$loc3 = node.key.loc) == null || (_node$key$loc3 = _node$key$loc3.end) == null ? void 0 : _node$key$loc3.line;
     if (endLine) this.catchUp(endLine);
   }
-  this.tsPrintClassMemberModifiers(node);
-  this._methodHead(node);
+  _typescript._tsPrintClassMemberModifiers.call(this, node);
+  _methods._methodHead.call(this, node);
 }
 function StaticBlock(node) {
   this.word("static");

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/deprecated.js

@@ -3,26 +3,71 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.addDeprecatedGenerators = addDeprecatedGenerators;
-function addDeprecatedGenerators(PrinterClass) {
-  {
-    const deprecatedBabel7Generators = {
-      Noop() {},
-      TSExpressionWithTypeArguments(node) {
-        this.print(node.expression);
-        this.print(node.typeParameters);
-      },
-      DecimalLiteral(node) {
-        const raw = this.getPossibleRaw(node);
-        if (!this.format.minified && raw !== undefined) {
-          this.word(raw);
-          return;
-        }
-        this.word(node.value + "m");
+exports.DecimalLiteral = DecimalLiteral;
+exports.Noop = Noop;
+exports.RecordExpression = RecordExpression;
+exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
+exports.TupleExpression = TupleExpression;
+function Noop() {}
+function TSExpressionWithTypeArguments(node) {
+  this.print(node.expression);
+  this.print(node.typeParameters);
+}
+function DecimalLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+  if (!this.format.minified && raw !== undefined) {
+    this.word(raw);
+    return;
+  }
+  this.word(node.value + "m");
+}
+function RecordExpression(node) {
+  const props = node.properties;
+  let startToken;
+  let endToken;
+  if (this.format.recordAndTupleSyntaxType === "bar") {
+    startToken = "{|";
+    endToken = "|}";
+  } else if (this.format.recordAndTupleSyntaxType !== "hash" && this.format.recordAndTupleSyntaxType != null) {
+    throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`);
+  } else {
+    startToken = "#{";
+    endToken = "}";
+  }
+  this.token(startToken);
+  if (props.length) {
+    this.space();
+    this.printList(props, this.shouldPrintTrailingComma(endToken), true, true);
+    this.space();
+  }
+  this.token(endToken);
+}
+function TupleExpression(node) {
+  const elems = node.elements;
+  const len = elems.length;
+  let startToken;
+  let endToken;
+  if (this.format.recordAndTupleSyntaxType === "bar") {
+    startToken = "[|";
+    endToken = "|]";
+  } else if (this.format.recordAndTupleSyntaxType === "hash") {
+    startToken = "#[";
+    endToken = "]";
+  } else {
+    throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`);
+  }
+  this.token(startToken);
+  for (let i = 0; i < elems.length; i++) {
+    const elem = elems[i];
+    if (elem) {
+      if (i > 0) this.space();
+      this.print(elem);
+      if (i < len - 1 || this.shouldPrintTrailingComma(endToken)) {
+        this.token(",", false, i);
       }
-    };
-    Object.assign(PrinterClass.prototype, deprecatedBabel7Generators);
+    }
   }
+  this.token(endToken);
 }
 
 //# sourceMappingURL=deprecated.js.map

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/expressions.js

@@ -3,9 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression;
+exports.LogicalExpression = exports.AssignmentExpression = AssignmentExpression;
 exports.AssignmentPattern = AssignmentPattern;
 exports.AwaitExpression = AwaitExpression;
+exports.BinaryExpression = BinaryExpression;
 exports.BindExpression = BindExpression;
 exports.CallExpression = CallExpression;
 exports.ConditionalExpression = ConditionalExpression;
@@ -43,11 +44,12 @@ function UnaryExpression(node) {
   const {
     operator
   } = node;
-  if (operator === "void" || operator === "delete" || operator === "typeof" || operator === "throw") {
+  const firstChar = operator.charCodeAt(0);
+  if (firstChar >= 97 && firstChar <= 122) {
     this.word(operator);
     this.space();
   } else {
-    this.token(operator);
+    this.tokenChar(firstChar);
   }
   this.print(node.argument);
 }
@@ -62,18 +64,18 @@ function DoExpression(node) {
 }
 function ParenthesizedExpression(node) {
   this.tokenChar(40);
-  const exit = this.enterDelimited();
-  this.print(node.expression);
-  exit();
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  this.print(node.expression, undefined, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   this.rightParens(node);
 }
 function UpdateExpression(node) {
   if (node.prefix) {
-    this.token(node.operator);
+    this.token(node.operator, false, 0, true);
     this.print(node.argument);
   } else {
     this.print(node.argument, true);
-    this.token(node.operator);
+    this.token(node.operator, false, 0, true);
   }
 }
 function ConditionalExpression(node) {
@@ -97,19 +99,17 @@ function NewExpression(node, parent) {
     return;
   }
   this.print(node.typeArguments);
-  {
-    this.print(node.typeParameters);
-    if (node.optional) {
-      this.token("?.");
-    }
+  this.print(node.typeParameters);
+  if (node.optional) {
+    this.token("?.");
   }
   if (node.arguments.length === 0 && this.tokenMap && !this.tokenMap.endMatches(node, ")")) {
     return;
   }
   this.tokenChar(40);
-  const exit = this.enterDelimited();
-  this.printList(node.arguments, this.shouldPrintTrailingComma(")"));
-  exit();
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  this.printList(node.arguments, this.shouldPrintTrailingComma(")"), undefined, undefined, undefined, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   this.rightParens(node);
 }
 function SequenceExpression(node) {
@@ -129,7 +129,10 @@ function _shouldPrintDecoratorsBeforeExport(node) {
 }
 function Decorator(node) {
   this.tokenChar(64);
-  this.print(node.expression);
+  const {
+    expression
+  } = node;
+  this.print(expression);
   this.newline();
 }
 function OptionalMemberExpression(node) {
@@ -163,29 +166,25 @@ function OptionalMemberExpression(node) {
 }
 function OptionalCallExpression(node) {
   this.print(node.callee);
-  {
-    this.print(node.typeParameters);
-  }
+  this.print(node.typeParameters);
   if (node.optional) {
     this.token("?.");
   }
   this.print(node.typeArguments);
   this.tokenChar(40);
-  const exit = this.enterDelimited();
-  this.printList(node.arguments);
-  exit();
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  this.printList(node.arguments, undefined, undefined, undefined, undefined, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   this.rightParens(node);
 }
 function CallExpression(node) {
   this.print(node.callee);
   this.print(node.typeArguments);
-  {
-    this.print(node.typeParameters);
-  }
+  this.print(node.typeParameters);
   this.tokenChar(40);
-  const exit = this.enterDelimited();
-  this.printList(node.arguments, this.shouldPrintTrailingComma(")"));
-  exit();
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
+  this.printList(node.arguments, this.shouldPrintTrailingComma(")"), undefined, undefined, undefined, true);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   this.rightParens(node);
 }
 function Import() {
@@ -234,11 +233,21 @@ function AssignmentPattern(node) {
 function AssignmentExpression(node) {
   this.print(node.left);
   this.space();
-  if (node.operator === "in" || node.operator === "instanceof") {
-    this.word(node.operator);
+  this.token(node.operator, false, 0, true);
+  this.space();
+  this.print(node.right);
+}
+function BinaryExpression(node) {
+  this.print(node.left);
+  this.space();
+  const {
+    operator
+  } = node;
+  if (operator.charCodeAt(0) === 105) {
+    this.word(operator);
   } else {
-    this.token(node.operator);
-    this._endsWithDiv = node.operator === "/";
+    this.token(operator, false, 0, true);
+    this.setLastChar(operator.charCodeAt(operator.length - 1));
   }
   this.space();
   this.print(node.right);
@@ -258,11 +267,11 @@ function MemberExpression(node) {
     computed = true;
   }
   if (computed) {
-    const exit = this.enterDelimited();
+    const oldNoLineTerminatorAfterNode = this.enterDelimited();
     this.tokenChar(91);
-    this.print(node.property);
+    this.print(node.property, undefined, true);
     this.tokenChar(93);
-    exit();
+    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   } else {
     this.tokenChar(46);
     this.print(node.property);

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/flow.js

@@ -109,7 +109,7 @@ function DeclareClass(node, parent) {
   }
   this.word("class");
   this.space();
-  this._interfaceish(node);
+  _interfaceish.call(this, node);
 }
 function DeclareFunction(node, parent) {
   if (!isDeclareExportDeclaration(parent)) {
@@ -140,7 +140,7 @@ function DeclaredPredicate(node) {
 function DeclareInterface(node) {
   this.word("declare");
   this.space();
-  this.InterfaceDeclaration(node);
+  InterfaceDeclaration.call(this, node);
 }
 function DeclareModule(node) {
   this.word("declare");
@@ -162,14 +162,14 @@ function DeclareModuleExports(node) {
 function DeclareTypeAlias(node) {
   this.word("declare");
   this.space();
-  this.TypeAlias(node);
+  TypeAlias.call(this, node);
 }
 function DeclareOpaqueType(node, parent) {
   if (!isDeclareExportDeclaration(parent)) {
     this.word("declare");
     this.space();
   }
-  this.OpaqueType(node);
+  OpaqueType.call(this, node);
 }
 function DeclareVariable(node, parent) {
   if (!isDeclareExportDeclaration(parent)) {
@@ -397,7 +397,7 @@ function _variance(node) {
 function InterfaceDeclaration(node) {
   this.word("interface");
   this.space();
-  this._interfaceish(node);
+  _interfaceish.call(this, node);
 }
 function andSeparator(occurrenceCount) {
   this.space();
@@ -475,7 +475,7 @@ function TypeParameterInstantiation(node) {
   this.tokenChar(62);
 }
 function TypeParameter(node) {
-  this._variance(node);
+  _variance.call(this, node);
   this.word(node.name);
   if (node.bound) {
     this.print(node.bound);
@@ -517,14 +517,12 @@ function ObjectTypeAnnotation(node) {
   if (props.length) {
     this.newline();
     this.space();
-    this.printJoin(props, true, true, undefined, undefined, function addNewlines(leading) {
-      if (leading && !props[0]) return 1;
-    }, () => {
+    this.printJoin(props, true, true, () => {
       if (props.length !== 1 || node.inexact) {
         this.tokenChar(44);
         this.space();
       }
-    });
+    }, true);
     this.space();
   }
   if (node.inexact) {
@@ -570,7 +568,7 @@ function ObjectTypeIndexer(node) {
     this.word("static");
     this.space();
   }
-  this._variance(node);
+  _variance.call(this, node);
   this.tokenChar(91);
   if (node.id) {
     this.print(node.id);
@@ -596,7 +594,7 @@ function ObjectTypeProperty(node) {
     this.word(node.kind);
     this.space();
   }
-  this._variance(node);
+  _variance.call(this, node);
   this.print(node.key);
   if (node.optional) this.tokenChar(63);
   if (!node.method) {

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/jsx.js

@@ -80,12 +80,10 @@ function spaceSeparator() {
 function JSXOpeningElement(node) {
   this.tokenChar(60);
   this.print(node.name);
-  {
-    if (node.typeArguments) {
-      this.print(node.typeArguments);
-    }
-    this.print(node.typeParameters);
+  if (node.typeArguments) {
+    this.print(node.typeArguments);
   }
+  this.print(node.typeParameters);
   if (node.attributes.length > 0) {
     this.space();
     this.printJoin(node.attributes, undefined, undefined, spaceSeparator);

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/methods.js

@@ -17,39 +17,40 @@ var _index = require("../node/index.js");
 const {
   isIdentifier
 } = _t;
-function _params(node, idNode, parentNode) {
+function _params(node, noLineTerminator, idNode, parentNode) {
   this.print(node.typeParameters);
-  const nameInfo = _getFuncIdName.call(this, idNode, parentNode);
-  if (nameInfo) {
-    this.sourceIdentifierName(nameInfo.name, nameInfo.pos);
+  if (idNode !== undefined || parentNode !== undefined) {
+    const nameInfo = _getFuncIdName.call(this, idNode, parentNode);
+    if (nameInfo) {
+      this.sourceIdentifierName(nameInfo.name, nameInfo.pos);
+    }
   }
   this.tokenChar(40);
-  this._parameters(node.params, ")");
-  const noLineTerminator = node.type === "ArrowFunctionExpression";
+  _parameters.call(this, node.params, 41);
   this.print(node.returnType, noLineTerminator);
   this._noLineTerminator = noLineTerminator;
 }
 function _parameters(parameters, endToken) {
-  const exit = this.enterDelimited();
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
   const trailingComma = this.shouldPrintTrailingComma(endToken);
   const paramLength = parameters.length;
   for (let i = 0; i < paramLength; i++) {
-    this._param(parameters[i]);
+    _param.call(this, parameters[i]);
     if (trailingComma || i < paramLength - 1) {
-      this.token(",", null, i);
+      this.tokenChar(44, i);
       this.space();
     }
   }
-  this.token(endToken);
-  exit();
+  this.tokenChar(endToken);
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
 }
 function _param(parameter) {
-  this.printJoin(parameter.decorators);
-  this.print(parameter);
+  this.printJoin(parameter.decorators, undefined, undefined, undefined, undefined, true);
+  this.print(parameter, undefined, true);
   if (parameter.optional) {
     this.tokenChar(63);
   }
-  this.print(parameter.typeAnnotation);
+  this.print(parameter.typeAnnotation, undefined, true);
 }
 function _methodHead(node) {
   const kind = node.kind;
@@ -77,7 +78,11 @@ function _methodHead(node) {
   if (node.optional) {
     this.tokenChar(63);
   }
-  this._params(node, node.computed && node.key.type !== "StringLiteral" ? undefined : node.key, undefined);
+  if (this._buf._map) {
+    _params.call(this, node, false, node.computed && node.key.type !== "StringLiteral" ? undefined : node.key);
+  } else {
+    _params.call(this, node, false);
+  }
 }
 function _predicate(node, noLineTerminatorAfter) {
   if (node.predicate) {
@@ -88,18 +93,18 @@ function _predicate(node, noLineTerminatorAfter) {
     this.print(node.predicate, noLineTerminatorAfter);
   }
 }
-function _functionHead(node, parent) {
+function _functionHead(node, parent, hasPredicate) {
   if (node.async) {
     this.word("async");
     if (!this.format.preserveFormat) {
-      this._endsWithInnerRaw = false;
+      this._innerCommentsState = 0;
     }
     this.space();
   }
   this.word("function");
   if (node.generator) {
     if (!this.format.preserveFormat) {
-      this._endsWithInnerRaw = false;
+      this._innerCommentsState = 0;
     }
     this.tokenChar(42);
   }
@@ -107,13 +112,17 @@ function _functionHead(node, parent) {
   if (node.id) {
     this.print(node.id);
   }
-  this._params(node, node.id, parent);
-  if (node.type !== "TSDeclareFunction") {
-    this._predicate(node);
+  if (this._buf._map) {
+    _params.call(this, node, false, node.id, parent);
+  } else {
+    _params.call(this, node, false);
+  }
+  if (hasPredicate) {
+    _predicate.call(this, node);
   }
 }
 function FunctionExpression(node, parent) {
-  this._functionHead(node, parent);
+  _functionHead.call(this, node, parent, true);
   this.space();
   this.print(node.body);
 }
@@ -122,12 +131,12 @@ function ArrowFunctionExpression(node, parent) {
     this.word("async", true);
     this.space();
   }
-  if (this._shouldPrintArrowParamsParens(node)) {
-    this._params(node, undefined, parent);
+  if (_shouldPrintArrowParamsParens.call(this, node)) {
+    _params.call(this, node, true, undefined, this._buf._map ? parent : undefined);
   } else {
     this.print(node.params[0], true);
   }
-  this._predicate(node, true);
+  _predicate.call(this, node, true);
   this.space();
   this.printInnerComments();
   this.token("=>");

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/modules.js

@@ -18,6 +18,7 @@ exports.ImportSpecifier = ImportSpecifier;
 exports._printAttributes = _printAttributes;
 var _t = require("@babel/types");
 var _index = require("../node/index.js");
+var _expressions = require("./expressions.js");
 const {
   isClassDeclaration,
   isExportDefaultSpecifier,
@@ -69,12 +70,14 @@ let warningShown = false;
 function _printAttributes(node, hasPreviousBrace) {
   var _node$extra;
   const {
-    importAttributesKeyword
-  } = this.format;
-  const {
-    attributes,
+    attributes
+  } = node;
+  var {
     assertions
   } = node;
+  const {
+    importAttributesKeyword
+  } = this.format;
   if (attributes && !importAttributesKeyword && node.extra && (node.extra.deprecatedAssertSyntax || node.extra.deprecatedWithLegacySyntax) && !warningShown) {
     warningShown = true;
     console.warn(`\
@@ -93,11 +96,11 @@ Please specify the "importAttributesKeyword" generator option, whose value can b
     return;
   }
   const occurrenceCount = hasPreviousBrace ? 1 : 0;
-  this.token("{", null, occurrenceCount);
+  this.token("{", undefined, occurrenceCount);
   this.space();
   this.printList(attributes || assertions, this.shouldPrintTrailingComma("}"));
   this.space();
-  this.token("}", null, occurrenceCount);
+  this.token("}", undefined, occurrenceCount);
 }
 function ExportAllDeclaration(node) {
   var _node$attributes, _node$assertions;
@@ -114,14 +117,14 @@ function ExportAllDeclaration(node) {
   if ((_node$attributes = node.attributes) != null && _node$attributes.length || (_node$assertions = node.assertions) != null && _node$assertions.length) {
     this.print(node.source, true);
     this.space();
-    this._printAttributes(node, false);
+    _printAttributes.call(this, node, false);
   } else {
     this.print(node.source);
   }
   this.semicolon();
 }
 function maybePrintDecoratorsBeforeExport(printer, node) {
-  if (isClassDeclaration(node.declaration) && printer._shouldPrintDecoratorsBeforeExport(node)) {
+  if (isClassDeclaration(node.declaration) && _expressions._shouldPrintDecoratorsBeforeExport.call(printer, node)) {
     printer.printJoin(node.declaration.decorators);
   }
 }
@@ -172,7 +175,7 @@ function ExportNamedDeclaration(node) {
       if ((_node$attributes2 = node.attributes) != null && _node$attributes2.length || (_node$assertions2 = node.assertions) != null && _node$assertions2.length) {
         this.print(node.source, true);
         this.space();
-        this._printAttributes(node, hasBrace);
+        _printAttributes.call(this, node, hasBrace);
       } else {
         this.print(node.source);
       }
@@ -245,7 +248,7 @@ function ImportDeclaration(node) {
   if ((_node$attributes3 = node.attributes) != null && _node$attributes3.length || (_node$assertions3 = node.assertions) != null && _node$assertions3.length) {
     this.print(node.source, true);
     this.space();
-    this._printAttributes(node, hasBrace);
+    _printAttributes.call(this, node, hasBrace);
   } else {
     this.print(node.source);
   }

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/statements.js

@@ -8,7 +8,8 @@ exports.CatchClause = CatchClause;
 exports.ContinueStatement = ContinueStatement;
 exports.DebuggerStatement = DebuggerStatement;
 exports.DoWhileStatement = DoWhileStatement;
-exports.ForOfStatement = exports.ForInStatement = void 0;
+exports.ForInStatement = ForInStatement;
+exports.ForOfStatement = ForOfStatement;
 exports.ForStatement = ForStatement;
 exports.IfStatement = IfStatement;
 exports.LabeledStatement = LabeledStatement;
@@ -22,9 +23,9 @@ exports.VariableDeclarator = VariableDeclarator;
 exports.WhileStatement = WhileStatement;
 exports.WithStatement = WithStatement;
 var _t = require("@babel/types");
+var _index = require("../node/index.js");
 const {
   isFor,
-  isForStatement,
   isIfStatement,
   isStatement
 } = _t;
@@ -34,7 +35,7 @@ function WithStatement(node) {
   this.tokenChar(40);
   this.print(node.object);
   this.tokenChar(41);
-  this.printBlock(node);
+  this.printBlock(node.body);
 }
 function IfStatement(node) {
   this.word("if");
@@ -75,23 +76,21 @@ function ForStatement(node) {
   this.word("for");
   this.space();
   this.tokenChar(40);
-  {
-    const exit = this.enterForStatementInit();
-    this.print(node.init);
-    exit();
-  }
+  this.tokenContext |= _index.TokenContext.forInitHead | _index.TokenContext.forInOrInitHeadAccumulate;
+  this.print(node.init);
+  this.tokenContext = _index.TokenContext.normal;
   this.tokenChar(59);
   if (node.test) {
     this.space();
     this.print(node.test);
   }
-  this.token(";", false, 1);
+  this.tokenChar(59, 1);
   if (node.update) {
     this.space();
     this.print(node.update);
   }
   this.tokenChar(41);
-  this.printBlock(node);
+  this.printBlock(node.body);
 }
 function WhileStatement(node) {
   this.word("while");
@@ -99,32 +98,41 @@ function WhileStatement(node) {
   this.tokenChar(40);
   this.print(node.test);
   this.tokenChar(41);
-  this.printBlock(node);
+  this.printBlock(node.body);
 }
-function ForXStatement(node) {
+function ForInStatement(node) {
   this.word("for");
   this.space();
-  const isForOf = node.type === "ForOfStatement";
-  if (isForOf && node.await) {
+  this.noIndentInnerCommentsHere();
+  this.tokenChar(40);
+  this.tokenContext |= _index.TokenContext.forInHead | _index.TokenContext.forInOrInitHeadAccumulate;
+  this.print(node.left);
+  this.tokenContext = _index.TokenContext.normal;
+  this.space();
+  this.word("in");
+  this.space();
+  this.print(node.right);
+  this.tokenChar(41);
+  this.printBlock(node.body);
+}
+function ForOfStatement(node) {
+  this.word("for");
+  this.space();
+  if (node.await) {
     this.word("await");
     this.space();
   }
   this.noIndentInnerCommentsHere();
   this.tokenChar(40);
-  {
-    const exit = this.enterForXStatementInit(isForOf);
-    this.print(node.left);
-    exit == null || exit();
-  }
+  this.tokenContext |= _index.TokenContext.forOfHead;
+  this.print(node.left);
   this.space();
-  this.word(isForOf ? "of" : "in");
+  this.word("of");
   this.space();
   this.print(node.right);
   this.tokenChar(41);
-  this.printBlock(node);
+  this.printBlock(node.body);
 }
-const ForInStatement = exports.ForInStatement = ForXStatement;
-const ForOfStatement = exports.ForOfStatement = ForXStatement;
 function DoWhileStatement(node) {
   this.word("do");
   this.space();
@@ -203,9 +211,7 @@ function SwitchStatement(node) {
   this.tokenChar(41);
   this.space();
   this.tokenChar(123);
-  this.printSequence(node.cases, true, undefined, function addNewlines(leading, cas) {
-    if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
-  });
+  this.printSequence(node.cases, true);
   this.rightBrace(node);
 }
 function SwitchCase(node) {
@@ -227,6 +233,10 @@ function DebuggerStatement() {
   this.word("debugger");
   this.semicolon();
 }
+function commaSeparatorWithNewline(occurrenceCount) {
+  this.tokenChar(44, occurrenceCount);
+  this.newline();
+}
 function VariableDeclaration(node, parent) {
   if (node.declare) {
     this.word("declare");
@@ -235,12 +245,15 @@ function VariableDeclaration(node, parent) {
   const {
     kind
   } = node;
-  if (kind === "await using") {
-    this.word("await");
-    this.space();
-    this.word("using", true);
-  } else {
-    this.word(kind, kind === "using");
+  switch (kind) {
+    case "await using":
+      this.word("await");
+      this.space();
+    case "using":
+      this.word("using", true);
+      break;
+    default:
+      this.word(kind);
   }
   this.space();
   let hasInits = false;
@@ -248,18 +261,23 @@ function VariableDeclaration(node, parent) {
     for (const declar of node.declarations) {
       if (declar.init) {
         hasInits = true;
+        break;
       }
     }
   }
-  this.printList(node.declarations, undefined, undefined, node.declarations.length > 1, hasInits ? function (occurrenceCount) {
-    this.token(",", false, occurrenceCount);
-    this.newline();
-  } : undefined);
-  if (isFor(parent)) {
-    if (isForStatement(parent)) {
-      if (parent.init === node) return;
-    } else {
-      if (parent.left === node) return;
+  this.printList(node.declarations, undefined, undefined, node.declarations.length > 1, hasInits ? commaSeparatorWithNewline : undefined);
+  if (parent != null) {
+    switch (parent.type) {
+      case "ForStatement":
+        if (parent.init === node) {
+          return;
+        }
+        break;
+      case "ForInStatement":
+      case "ForOfStatement":
+        if (parent.left === node) {
+          return;
+        }
     }
   }
   this.semicolon();

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/template-literals.js

@@ -9,9 +9,7 @@ exports.TemplateLiteral = TemplateLiteral;
 exports._printTemplate = _printTemplate;
 function TaggedTemplateExpression(node) {
   this.print(node.tag);
-  {
-    this.print(node.typeParameters);
-  }
+  this.print(node.typeParameters);
   this.print(node.quasi);
 }
 function TemplateElement() {
@@ -34,7 +32,7 @@ function _printTemplate(node, substitutions) {
   this.token(partRaw + "`", true);
 }
 function TemplateLiteral(node) {
-  this._printTemplate(node, node.expressions);
+  _printTemplate.call(this, node, node.expressions);
 }
 
 //# sourceMappingURL=template-literals.js.map

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/types.js

@@ -16,25 +16,21 @@ exports.ObjectProperty = ObjectProperty;
 exports.PipelineBareFunction = PipelineBareFunction;
 exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference;
 exports.PipelineTopicExpression = PipelineTopicExpression;
-exports.RecordExpression = RecordExpression;
 exports.RegExpLiteral = RegExpLiteral;
 exports.SpreadElement = exports.RestElement = RestElement;
 exports.StringLiteral = StringLiteral;
 exports.TopicReference = TopicReference;
-exports.TupleExpression = TupleExpression;
 exports.VoidPattern = VoidPattern;
 exports._getRawIdentifier = _getRawIdentifier;
 var _t = require("@babel/types");
 var _jsesc = require("jsesc");
+var _methods = require("./methods.js");
 const {
   isAssignmentPattern,
   isIdentifier
 } = _t;
-let lastRawIdentNode = null;
 let lastRawIdentResult = "";
 function _getRawIdentifier(node) {
-  if (node === lastRawIdentNode) return lastRawIdentResult;
-  lastRawIdentNode = node;
   const {
     name
   } = node;
@@ -46,9 +42,11 @@ function _getRawIdentifier(node) {
   return lastRawIdentResult = node.name;
 }
 function Identifier(node) {
-  var _node$loc;
-  this.sourceIdentifierName(((_node$loc = node.loc) == null ? void 0 : _node$loc.identifierName) || node.name);
-  this.word(this.tokenMap ? this._getRawIdentifier(node) : node.name);
+  if (this._buf._map) {
+    var _node$loc;
+    this.sourceIdentifierName(((_node$loc = node.loc) == null ? void 0 : _node$loc.identifierName) || node.name);
+  }
+  this.word(this.tokenMap ? lastRawIdentResult : node.name);
 }
 function ArgumentPlaceholder() {
   this.tokenChar(63);
@@ -61,18 +59,17 @@ function ObjectExpression(node) {
   const props = node.properties;
   this.tokenChar(123);
   if (props.length) {
-    const exit = this.enterDelimited();
+    const oldNoLineTerminatorAfterNode = this.enterDelimited();
     this.space();
-    this.printList(props, this.shouldPrintTrailingComma("}"), true, true);
+    this.printList(props, this.shouldPrintTrailingComma("}"), true, true, undefined, true);
     this.space();
-    exit();
+    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   }
-  this.sourceWithOffset("end", node.loc, -1);
-  this.tokenChar(125);
+  this.rightBrace(node);
 }
 function ObjectMethod(node) {
   this.printJoin(node.decorators);
-  this._methodHead(node);
+  _methods._methodHead.call(this, node);
   this.space();
   this.print(node.body);
 }
@@ -100,76 +97,24 @@ function ArrayExpression(node) {
   const elems = node.elements;
   const len = elems.length;
   this.tokenChar(91);
-  const exit = this.enterDelimited();
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
   for (let i = 0; i < elems.length; i++) {
     const elem = elems[i];
     if (elem) {
       if (i > 0) this.space();
-      this.print(elem);
+      this.print(elem, undefined, true);
       if (i < len - 1 || this.shouldPrintTrailingComma("]")) {
-        this.token(",", false, i);
+        this.tokenChar(44, i);
       }
     } else {
-      this.token(",", false, i);
+      this.tokenChar(44, i);
     }
   }
-  exit();
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   this.tokenChar(93);
 }
-function RecordExpression(node) {
-  const props = node.properties;
-  let startToken;
-  let endToken;
-  {
-    if (this.format.recordAndTupleSyntaxType === "bar") {
-      startToken = "{|";
-      endToken = "|}";
-    } else if (this.format.recordAndTupleSyntaxType !== "hash" && this.format.recordAndTupleSyntaxType != null) {
-      throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`);
-    } else {
-      startToken = "#{";
-      endToken = "}";
-    }
-  }
-  this.token(startToken);
-  if (props.length) {
-    this.space();
-    this.printList(props, this.shouldPrintTrailingComma(endToken), true, true);
-    this.space();
-  }
-  this.token(endToken);
-}
-function TupleExpression(node) {
-  const elems = node.elements;
-  const len = elems.length;
-  let startToken;
-  let endToken;
-  {
-    if (this.format.recordAndTupleSyntaxType === "bar") {
-      startToken = "[|";
-      endToken = "|]";
-    } else if (this.format.recordAndTupleSyntaxType === "hash") {
-      startToken = "#[";
-      endToken = "]";
-    } else {
-      throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`);
-    }
-  }
-  this.token(startToken);
-  for (let i = 0; i < elems.length; i++) {
-    const elem = elems[i];
-    if (elem) {
-      if (i > 0) this.space();
-      this.print(elem);
-      if (i < len - 1 || this.shouldPrintTrailingComma(endToken)) {
-        this.token(",", false, i);
-      }
-    }
-  }
-  this.token(endToken);
-}
 function RegExpLiteral(node) {
-  this.word(`/${node.pattern}/${node.flags}`);
+  this.word(`/${node.pattern}/${node.flags}`, false);
 }
 function BooleanLiteral(node) {
   this.word(node.value ? "true" : "false");

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/generators/typescript.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.TSAnyKeyword = TSAnyKeyword;
 exports.TSArrayType = TSArrayType;
-exports.TSSatisfiesExpression = exports.TSAsExpression = TSTypeExpression;
+exports.TSAsExpression = TSAsExpression;
 exports.TSBigIntKeyword = TSBigIntKeyword;
 exports.TSBooleanKeyword = TSBooleanKeyword;
 exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
@@ -49,6 +49,7 @@ exports.TSParenthesizedType = TSParenthesizedType;
 exports.TSPropertySignature = TSPropertySignature;
 exports.TSQualifiedName = TSQualifiedName;
 exports.TSRestType = TSRestType;
+exports.TSSatisfiesExpression = TSSatisfiesExpression;
 exports.TSStringKeyword = TSStringKeyword;
 exports.TSSymbolKeyword = TSSymbolKeyword;
 exports.TSTemplateLiteralType = TSTemplateLiteralType;
@@ -68,10 +69,10 @@ exports.TSUndefinedKeyword = TSUndefinedKeyword;
 exports.TSUnionType = TSUnionType;
 exports.TSUnknownKeyword = TSUnknownKeyword;
 exports.TSVoidKeyword = TSVoidKeyword;
-exports.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers;
-exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType;
-exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName;
-exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;
+exports._tsPrintClassMemberModifiers = _tsPrintClassMemberModifiers;
+var _methods = require("./methods.js");
+var _classes = require("./classes.js");
+var _templateLiterals = require("./template-literals.js");
 function TSTypeAnnotation(node, parent) {
   this.token((parent.type === "TSFunctionType" || parent.type === "TSConstructorType") && parent.typeAnnotation === node ? "=>" : ":");
   this.space();
@@ -124,18 +125,18 @@ function TSParameterProperty(node) {
     this.word("readonly");
     this.space();
   }
-  this._param(node.parameter);
+  _methods._param.call(this, node.parameter);
 }
 function TSDeclareFunction(node, parent) {
   if (node.declare) {
     this.word("declare");
     this.space();
   }
-  this._functionHead(node, parent);
+  _methods._functionHead.call(this, node, parent, false);
   this.semicolon();
 }
 function TSDeclareMethod(node) {
-  this._classMethodHead(node);
+  _classes._classMethodHead.call(this, node);
   this.semicolon();
 }
 function TSQualifiedName(node) {
@@ -144,7 +145,7 @@ function TSQualifiedName(node) {
   this.print(node.right);
 }
 function TSCallSignatureDeclaration(node) {
-  this.tsPrintSignatureDeclarationBase(node);
+  tsPrintSignatureDeclarationBase.call(this, node);
   maybePrintTrailingCommaOrSemicolon(this, node);
 }
 function maybePrintTrailingCommaOrSemicolon(printer, node) {
@@ -161,7 +162,7 @@ function maybePrintTrailingCommaOrSemicolon(printer, node) {
 function TSConstructSignatureDeclaration(node) {
   this.word("new");
   this.space();
-  this.tsPrintSignatureDeclarationBase(node);
+  tsPrintSignatureDeclarationBase.call(this, node);
   maybePrintTrailingCommaOrSemicolon(this, node);
 }
 function TSPropertySignature(node) {
@@ -172,7 +173,7 @@ function TSPropertySignature(node) {
     this.word("readonly");
     this.space();
   }
-  this.tsPrintPropertyOrMethodName(node);
+  tsPrintPropertyOrMethodName.call(this, node);
   this.print(node.typeAnnotation);
   maybePrintTrailingCommaOrSemicolon(this, node);
 }
@@ -196,8 +197,8 @@ function TSMethodSignature(node) {
     this.word(kind);
     this.space();
   }
-  this.tsPrintPropertyOrMethodName(node);
-  this.tsPrintSignatureDeclarationBase(node);
+  tsPrintPropertyOrMethodName.call(this, node);
+  tsPrintSignatureDeclarationBase.call(this, node);
   maybePrintTrailingCommaOrSemicolon(this, node);
 }
 function TSIndexSignature(node) {
@@ -214,7 +215,7 @@ function TSIndexSignature(node) {
     this.space();
   }
   this.tokenChar(91);
-  this._parameters(node.parameters, "]");
+  _methods._parameters.call(this, node.parameters, 93);
   this.print(node.typeAnnotation);
   maybePrintTrailingCommaOrSemicolon(this, node);
 }
@@ -261,7 +262,7 @@ function TSThisType() {
   this.word("this");
 }
 function TSFunctionType(node) {
-  this.tsPrintFunctionOrConstructorType(node);
+  tsPrintFunctionOrConstructorType.call(this, node);
 }
 function TSConstructorType(node) {
   if (node.abstract) {
@@ -270,7 +271,7 @@ function TSConstructorType(node) {
   }
   this.word("new");
   this.space();
-  this.tsPrintFunctionOrConstructorType(node);
+  tsPrintFunctionOrConstructorType.call(this, node);
 }
 function tsPrintFunctionOrConstructorType(node) {
   const {
@@ -279,7 +280,7 @@ function tsPrintFunctionOrConstructorType(node) {
   const parameters = node.parameters;
   this.print(typeParameters);
   this.tokenChar(40);
-  this._parameters(parameters, ")");
+  _methods._parameters.call(this, parameters, 41);
   this.space();
   const returnType = node.typeAnnotation;
   this.print(returnType);
@@ -312,7 +313,7 @@ function TSTypeQuery(node) {
   }
 }
 function TSTypeLiteral(node) {
-  printBraced(this, node, () => this.printJoin(node.members, true, true));
+  printBraced(this, node, () => this.printJoin(node.members, true, true, undefined, undefined, true));
 }
 function TSArrayType(node) {
   this.print(node.elementType, true);
@@ -354,7 +355,7 @@ function tsPrintUnionOrIntersectionType(printer, node, sep) {
   }
   printer.printJoin(node.types, undefined, undefined, function (i) {
     this.space();
-    this.token(sep, null, i + hasLeadingToken);
+    this.token(sep, undefined, i + hasLeadingToken);
     this.space();
   });
 }
@@ -401,7 +402,7 @@ function TSMappedType(node) {
     typeAnnotation
   } = node;
   this.tokenChar(123);
-  const exit = this.enterDelimited();
+  const oldNoLineTerminatorAfterNode = this.enterDelimited();
   this.space();
   if (readonly) {
     tokenIfPlusMinus(this, readonly);
@@ -409,20 +410,16 @@ function TSMappedType(node) {
     this.space();
   }
   this.tokenChar(91);
-  {
-    this.word(node.typeParameter.name);
-  }
+  this.word(node.typeParameter.name);
   this.space();
   this.word("in");
   this.space();
-  {
-    this.print(node.typeParameter.constraint);
-  }
+  this.print(node.typeParameter.constraint, undefined, true);
   if (nameType) {
     this.space();
     this.word("as");
     this.space();
-    this.print(nameType);
+    this.print(nameType, undefined, true);
   }
   this.tokenChar(93);
   if (optional) {
@@ -432,10 +429,10 @@ function TSMappedType(node) {
   if (typeAnnotation) {
     this.tokenChar(58);
     this.space();
-    this.print(typeAnnotation);
+    this.print(typeAnnotation, undefined, true);
   }
   this.space();
-  exit();
+  this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   this.tokenChar(125);
 }
 function tokenIfPlusMinus(self, tok) {
@@ -444,7 +441,7 @@ function tokenIfPlusMinus(self, tok) {
   }
 }
 function TSTemplateLiteralType(node) {
-  this._printTemplate(node, node.types);
+  _templateLiterals._printTemplate.call(this, node, node.types);
 }
 function TSLiteralType(node) {
   this.print(node.literal);
@@ -479,7 +476,7 @@ function TSInterfaceDeclaration(node) {
   this.print(body);
 }
 function TSInterfaceBody(node) {
-  printBraced(this, node, () => this.printJoin(node.body, true, true));
+  printBraced(this, node, () => this.printJoin(node.body, true, true, undefined, undefined, true));
 }
 function TSTypeAliasDeclaration(node) {
   const {
@@ -502,15 +499,25 @@ function TSTypeAliasDeclaration(node) {
   this.print(typeAnnotation);
   this.semicolon();
 }
-function TSTypeExpression(node) {
+function TSAsExpression(node) {
+  const {
+    expression,
+    typeAnnotation
+  } = node;
+  this.print(expression, true);
+  this.space();
+  this.word("as");
+  this.space();
+  this.print(typeAnnotation);
+}
+function TSSatisfiesExpression(node) {
   const {
-    type,
     expression,
     typeAnnotation
   } = node;
   this.print(expression, true);
   this.space();
-  this.word(type === "TSAsExpression" ? "as" : "satisfies");
+  this.word("satisfies");
   this.space();
   this.print(typeAnnotation);
 }
@@ -527,9 +534,7 @@ function TSTypeAssertion(node) {
 }
 function TSInstantiationExpression(node) {
   this.print(node.expression);
-  {
-    this.print(node.typeParameters);
-  }
+  this.print(node.typeParameters);
 }
 function TSEnumDeclaration(node) {
   const {
@@ -549,14 +554,12 @@ function TSEnumDeclaration(node) {
   this.space();
   this.print(id);
   this.space();
-  {
-    TSEnumBody.call(this, node);
-  }
+  TSEnumBody.call(this, node);
 }
 function TSEnumBody(node) {
   printBraced(this, node, () => {
     var _this$shouldPrintTrai;
-    return this.printList(node.members, (_this$shouldPrintTrai = this.shouldPrintTrailingComma("}")) != null ? _this$shouldPrintTrai : true, true, true);
+    return this.printList(node.members, (_this$shouldPrintTrai = this.shouldPrintTrailingComma("}")) != null ? _this$shouldPrintTrai : true, true, true, undefined, true);
   });
 }
 function TSEnumMember(node) {
@@ -582,38 +585,35 @@ function TSModuleDeclaration(node) {
     this.word("declare");
     this.space();
   }
-  {
-    if (!node.global) {
-      this.word(kind != null ? kind : id.type === "Identifier" ? "namespace" : "module");
-      this.space();
-    }
-    this.print(id);
-    if (!node.body) {
-      this.semicolon();
-      return;
-    }
-    let body = node.body;
-    while (body.type === "TSModuleDeclaration") {
-      this.tokenChar(46);
-      this.print(body.id);
-      body = body.body;
-    }
+  if (!node.global) {
+    this.word(kind != null ? kind : id.type === "Identifier" ? "namespace" : "module");
     this.space();
-    this.print(body);
   }
+  this.print(id);
+  if (!node.body) {
+    this.semicolon();
+    return;
+  }
+  let body = node.body;
+  while (body.type === "TSModuleDeclaration") {
+    this.tokenChar(46);
+    this.print(body.id);
+    body = body.body;
+  }
+  this.space();
+  this.print(body);
 }
 function TSModuleBlock(node) {
-  printBraced(this, node, () => this.printSequence(node.body, true));
+  printBraced(this, node, () => this.printSequence(node.body, true, true));
 }
 function TSImportType(node) {
   const {
-    argument,
     qualifier,
     options
   } = node;
   this.word("import");
   this.tokenChar(40);
-  this.print(argument);
+  this.print(node.argument);
   if (options) {
     this.tokenChar(44);
     this.print(options);
@@ -654,6 +654,7 @@ function TSExternalModuleReference(node) {
 function TSNonNullExpression(node) {
   this.print(node.expression);
   this.tokenChar(33);
+  this.setLastChar(33);
 }
 function TSExportAssignment(node) {
   this.word("export");
@@ -680,11 +681,11 @@ function tsPrintSignatureDeclarationBase(node) {
   const parameters = node.parameters;
   this.print(typeParameters);
   this.tokenChar(40);
-  this._parameters(parameters, ")");
+  _methods._parameters.call(this, parameters, 41);
   const returnType = node.typeAnnotation;
   this.print(returnType);
 }
-function tsPrintClassMemberModifiers(node) {
+function _tsPrintClassMemberModifiers(node) {
   const isPrivateField = node.type === "ClassPrivateProperty";
   const isPublicField = node.type === "ClassAccessorProperty" || node.type === "ClassProperty";
   printModifiersList(this, node, [isPublicField && node.declare && "declare", !isPrivateField && node.accessibility]);
@@ -696,9 +697,9 @@ function tsPrintClassMemberModifiers(node) {
 }
 function printBraced(printer, node, cb) {
   printer.token("{");
-  const exit = printer.enterDelimited();
+  const oldNoLineTerminatorAfterNode = printer.enterDelimited();
   cb();
-  exit();
+  printer._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
   printer.rightBrace(node);
 }
 function printModifiersList(printer, node, modifiers) {
@@ -714,6 +715,7 @@ function printModifiersList(printer, node, modifiers) {
       modifiersSet.delete(tok.value);
       return modifiersSet.size === 0;
     }
+    return false;
   });
   for (const modifier of modifiersSet) {
     printer.word(modifier);

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/index.js

@@ -8,6 +8,7 @@ exports.generate = generate;
 var _sourceMap = require("./source-map.js");
 var _printer = require("./printer.js");
 function normalizeOptions(code, opts, ast) {
+  var _opts$recordAndTupleS;
   if (opts.experimental_preserveFormat) {
     if (typeof code !== "string") {
       throw new Error("`experimental_preserveFormat` requires the original `code` to be passed to @babel/generator as a string");
@@ -48,15 +49,12 @@ function normalizeOptions(code, opts, ast) {
       wrap: true,
       minimal: false
     }, opts.jsescOption),
-    topicToken: opts.topicToken,
-    importAttributesKeyword: opts.importAttributesKeyword
+    topicToken: opts.topicToken
   };
-  {
-    var _opts$recordAndTupleS;
-    format.decoratorsBeforeExport = opts.decoratorsBeforeExport;
-    format.jsescOption.json = opts.jsonCompatibleStrings;
-    format.recordAndTupleSyntaxType = (_opts$recordAndTupleS = opts.recordAndTupleSyntaxType) != null ? _opts$recordAndTupleS : "hash";
-  }
+  format.decoratorsBeforeExport = opts.decoratorsBeforeExport;
+  format.jsescOption.json = opts.jsonCompatibleStrings;
+  format.recordAndTupleSyntaxType = (_opts$recordAndTupleS = opts.recordAndTupleSyntaxType) != null ? _opts$recordAndTupleS : "hash";
+  format.importAttributesKeyword = opts.importAttributesKeyword;
   if (format.minified) {
     format.compact = true;
     format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
@@ -85,22 +83,20 @@ function normalizeOptions(code, opts, ast) {
   }
   return format;
 }
-{
-  exports.CodeGenerator = class CodeGenerator {
-    constructor(ast, opts = {}, code) {
-      this._ast = void 0;
-      this._format = void 0;
-      this._map = void 0;
-      this._ast = ast;
-      this._format = normalizeOptions(code, opts, ast);
-      this._map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
-    }
-    generate() {
-      const printer = new _printer.default(this._format, this._map);
-      return printer.generate(this._ast);
-    }
-  };
-}
+exports.CodeGenerator = class CodeGenerator {
+  constructor(ast, opts = {}, code) {
+    this._ast = void 0;
+    this._format = void 0;
+    this._map = void 0;
+    this._ast = ast;
+    this._format = normalizeOptions(code, opts, ast);
+    this._map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
+  }
+  generate() {
+    const printer = new _printer.default(this._format, this._map);
+    return printer.generate(this._ast);
+  }
+};
 function generate(ast, opts = {}, code) {
   const format = normalizeOptions(code, opts, ast);
   const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/node/index.js

@@ -5,22 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.TokenContext = void 0;
 exports.isLastChild = isLastChild;
-exports.needsParens = needsParens;
-exports.needsWhitespace = needsWhitespace;
-exports.needsWhitespaceAfter = needsWhitespaceAfter;
-exports.needsWhitespaceBefore = needsWhitespaceBefore;
-var whitespace = require("./whitespace.js");
+exports.parentNeedsParens = parentNeedsParens;
 var parens = require("./parentheses.js");
 var _t = require("@babel/types");
+var _nodes = require("../nodes.js");
 const {
-  FLIPPED_ALIAS_KEYS,
-  VISITOR_KEYS,
-  isCallExpression,
-  isDecorator,
-  isExpressionStatement,
-  isMemberExpression,
-  isNewExpression,
-  isParenthesizedExpression
+  VISITOR_KEYS
 } = _t;
 const TokenContext = exports.TokenContext = {
   normal: 0,
@@ -34,63 +24,32 @@ const TokenContext = exports.TokenContext = {
   forInOrInitHeadAccumulate: 128,
   forInOrInitHeadAccumulatePassThroughMask: 128
 };
-function expandAliases(obj) {
-  const map = new Map();
-  function add(type, func) {
-    const fn = map.get(type);
-    map.set(type, fn ? function (node, parent, stack, getRawIdentifier) {
-      var _fn;
-      return (_fn = fn(node, parent, stack, getRawIdentifier)) != null ? _fn : func(node, parent, stack, getRawIdentifier);
-    } : func);
+for (const type of Object.keys(parens)) {
+  const func = parens[type];
+  if (_nodes.generatorInfosMap.has(type)) {
+    _nodes.generatorInfosMap.get(type)[2] = func;
   }
-  for (const type of Object.keys(obj)) {
-    const aliases = FLIPPED_ALIAS_KEYS[type];
-    if (aliases) {
-      for (const alias of aliases) {
-        add(alias, obj[type]);
-      }
-    } else {
-      add(type, obj[type]);
-    }
-  }
-  return map;
 }
-const expandedParens = expandAliases(parens);
-const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
 function isOrHasCallExpression(node) {
-  if (isCallExpression(node)) {
-    return true;
-  }
-  return isMemberExpression(node) && isOrHasCallExpression(node.object);
-}
-function needsWhitespace(node, parent, type) {
-  var _expandedWhitespaceNo;
-  if (!node) return false;
-  if (isExpressionStatement(node)) {
-    node = node.expression;
-  }
-  const flag = (_expandedWhitespaceNo = expandedWhitespaceNodes.get(node.type)) == null ? void 0 : _expandedWhitespaceNo(node, parent);
-  if (typeof flag === "number") {
-    return (flag & type) !== 0;
+  switch (node.type) {
+    case "CallExpression":
+      return true;
+    case "MemberExpression":
+      return isOrHasCallExpression(node.object);
   }
   return false;
 }
-function needsWhitespaceBefore(node, parent) {
-  return needsWhitespace(node, parent, 1);
-}
-function needsWhitespaceAfter(node, parent) {
-  return needsWhitespace(node, parent, 2);
-}
-function needsParens(node, parent, tokenContext, getRawIdentifier) {
-  var _expandedParens$get;
-  if (!parent) return false;
-  if (isNewExpression(parent) && parent.callee === node) {
-    if (isOrHasCallExpression(node)) return true;
-  }
-  if (isDecorator(parent)) {
-    return !isDecoratorMemberExpression(node) && !(isCallExpression(node) && isDecoratorMemberExpression(node.callee)) && !isParenthesizedExpression(node);
+function parentNeedsParens(node, parent, parentId) {
+  switch (parentId) {
+    case 112:
+      if (parent.callee === node) {
+        if (isOrHasCallExpression(node)) return true;
+      }
+      break;
+    case 42:
+      return !isDecoratorMemberExpression(node) && !(node.type === "CallExpression" && isDecoratorMemberExpression(node.callee)) && node.type !== "ParenthesizedExpression";
   }
-  return (_expandedParens$get = expandedParens.get(node.type)) == null ? void 0 : _expandedParens$get(node, parent, tokenContext, getRawIdentifier);
+  return false;
 }
 function isDecoratorMemberExpression(node) {
   switch (node.type) {

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/node/parentheses.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AssignmentExpression = AssignmentExpression;
-exports.Binary = Binary;
 exports.BinaryExpression = BinaryExpression;
 exports.ClassExpression = ClassExpression;
 exports.ArrowFunctionExpression = exports.ConditionalExpression = ConditionalExpression;
@@ -24,7 +23,7 @@ exports.TSConstructorType = exports.TSFunctionType = TSFunctionType;
 exports.TSInferType = TSInferType;
 exports.TSInstantiationExpression = TSInstantiationExpression;
 exports.TSIntersectionType = TSIntersectionType;
-exports.UnaryLike = exports.TSTypeAssertion = UnaryLike;
+exports.SpreadElement = exports.UnaryExpression = exports.TSTypeAssertion = UnaryLike;
 exports.TSTypeOperator = TSTypeOperator;
 exports.TSUnionType = TSUnionType;
 exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
@@ -33,230 +32,267 @@ exports.AwaitExpression = exports.YieldExpression = YieldExpression;
 var _t = require("@babel/types");
 var _index = require("./index.js");
 const {
-  isArrayTypeAnnotation,
-  isBinaryExpression,
-  isCallExpression,
-  isForOfStatement,
-  isIndexedAccessType,
   isMemberExpression,
-  isObjectPattern,
   isOptionalMemberExpression,
   isYieldExpression,
   isStatement
 } = _t;
-const PRECEDENCE = new Map([["||", 0], ["??", 0], ["|>", 0], ["&&", 1], ["|", 2], ["^", 3], ["&", 4], ["==", 5], ["===", 5], ["!=", 5], ["!==", 5], ["<", 6], [">", 6], ["<=", 6], [">=", 6], ["in", 6], ["instanceof", 6], [">>", 7], ["<<", 7], [">>>", 7], ["+", 8], ["-", 8], ["*", 9], ["/", 9], ["%", 9], ["**", 10]]);
-function getBinaryPrecedence(node, nodeType) {
-  if (nodeType === "BinaryExpression" || nodeType === "LogicalExpression") {
-    return PRECEDENCE.get(node.operator);
-  }
-  if (nodeType === "TSAsExpression" || nodeType === "TSSatisfiesExpression") {
-    return PRECEDENCE.get("in");
-  }
-}
-function isTSTypeExpression(nodeType) {
-  return nodeType === "TSAsExpression" || nodeType === "TSSatisfiesExpression" || nodeType === "TSTypeAssertion";
+const PRECEDENCE = new Map([["||", 0], ["??", 1], ["&&", 2], ["|", 3], ["^", 4], ["&", 5], ["==", 6], ["===", 6], ["!=", 6], ["!==", 6], ["<", 7], [">", 7], ["<=", 7], [">=", 7], ["in", 7], ["instanceof", 7], [">>", 8], ["<<", 8], [">>>", 8], ["+", 9], ["-", 9], ["*", 10], ["/", 10], ["%", 10], ["**", 11]]);
+function isTSTypeExpression(nodeId) {
+  return nodeId === 156 || nodeId === 201 || nodeId === 209;
 }
-const isClassExtendsClause = (node, parent) => {
-  const parentType = parent.type;
-  return (parentType === "ClassDeclaration" || parentType === "ClassExpression") && parent.superClass === node;
+const isClassExtendsClause = (node, parent, parentId) => {
+  return (parentId === 21 || parentId === 22) && parent.superClass === node;
 };
-const hasPostfixPart = (node, parent) => {
-  const parentType = parent.type;
-  return (parentType === "MemberExpression" || parentType === "OptionalMemberExpression") && parent.object === node || (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression") && parent.callee === node || parentType === "TaggedTemplateExpression" && parent.tag === node || parentType === "TSNonNullExpression";
+const hasPostfixPart = (node, parent, parentId) => {
+  switch (parentId) {
+    case 108:
+    case 132:
+      return parent.object === node;
+    case 17:
+    case 130:
+    case 112:
+      return parent.callee === node;
+    case 222:
+      return parent.tag === node;
+    case 191:
+      return true;
+  }
+  return false;
 };
-function NullableTypeAnnotation(node, parent) {
-  return isArrayTypeAnnotation(parent);
+function NullableTypeAnnotation(node, parent, parentId) {
+  return parentId === 4;
 }
-function FunctionTypeAnnotation(node, parent, tokenContext) {
-  const parentType = parent.type;
-  return (parentType === "UnionTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "ArrayTypeAnnotation" || Boolean(tokenContext & _index.TokenContext.arrowFlowReturnType)
+function FunctionTypeAnnotation(node, parent, parentId, tokenContext) {
+  return (parentId === 239 || parentId === 90 || parentId === 4 || (tokenContext & _index.TokenContext.arrowFlowReturnType) > 0
   );
 }
-function UpdateExpression(node, parent) {
-  return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
+function UpdateExpression(node, parent, parentId) {
+  return hasPostfixPart(node, parent, parentId) || isClassExtendsClause(node, parent, parentId);
 }
 function needsParenBeforeExpressionBrace(tokenContext) {
-  return Boolean(tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.arrowBody));
+  return (tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.arrowBody)) > 0;
 }
-function ObjectExpression(node, parent, tokenContext) {
+function ObjectExpression(node, parent, parentId, tokenContext) {
   return needsParenBeforeExpressionBrace(tokenContext);
 }
-function DoExpression(node, parent, tokenContext) {
-  return !node.async && Boolean(tokenContext & _index.TokenContext.expressionStatement);
+function DoExpression(node, parent, parentId, tokenContext) {
+  return (tokenContext & _index.TokenContext.expressionStatement) > 0 && !node.async;
 }
-function Binary(node, parent) {
-  const parentType = parent.type;
-  if (node.type === "BinaryExpression" && node.operator === "**" && parentType === "BinaryExpression" && parent.operator === "**") {
-    return parent.left === node;
-  }
-  if (isClassExtendsClause(node, parent)) {
+function BinaryLike(node, parent, parentId, nodeType) {
+  if (isClassExtendsClause(node, parent, parentId)) {
     return true;
   }
-  if (hasPostfixPart(node, parent) || parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "AwaitExpression") {
+  if (hasPostfixPart(node, parent, parentId) || parentId === 238 || parentId === 145 || parentId === 8) {
     return true;
   }
-  const parentPos = getBinaryPrecedence(parent, parentType);
-  if (parentPos != null) {
-    const nodePos = getBinaryPrecedence(node, node.type);
-    if (parentPos === nodePos && parentType === "BinaryExpression" && parent.right === node || parentPos > nodePos) {
+  let parentPos;
+  switch (parentId) {
+    case 10:
+    case 107:
+      parentPos = PRECEDENCE.get(parent.operator);
+      break;
+    case 156:
+    case 201:
+      parentPos = 7;
+  }
+  if (parentPos !== undefined) {
+    const nodePos = nodeType === 2 ? 7 : PRECEDENCE.get(node.operator);
+    if (parentPos > nodePos) return true;
+    if (parentPos === nodePos && parentId === 10 && (nodePos === 11 ? parent.left === node : parent.right === node)) {
+      return true;
+    }
+    if (nodeType === 1 && parentId === 107 && (nodePos === 1 && parentPos !== 1 || parentPos === 1 && nodePos !== 1)) {
       return true;
     }
   }
-  return undefined;
+  return false;
 }
-function UnionTypeAnnotation(node, parent) {
-  const parentType = parent.type;
-  return parentType === "ArrayTypeAnnotation" || parentType === "NullableTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "UnionTypeAnnotation";
+function UnionTypeAnnotation(node, parent, parentId) {
+  switch (parentId) {
+    case 4:
+    case 115:
+    case 90:
+    case 239:
+      return true;
+  }
+  return false;
 }
-function OptionalIndexedAccessType(node, parent) {
-  return isIndexedAccessType(parent) && parent.objectType === node;
+function OptionalIndexedAccessType(node, parent, parentId) {
+  return parentId === 84 && parent.objectType === node;
 }
-function TSAsExpression(node, parent) {
-  if ((parent.type === "AssignmentExpression" || parent.type === "AssignmentPattern") && parent.left === node) {
+function TSAsExpression(node, parent, parentId) {
+  if ((parentId === 6 || parentId === 7) && parent.left === node) {
     return true;
   }
-  if (parent.type === "BinaryExpression" && (parent.operator === "|" || parent.operator === "&") && node === parent.left) {
+  if (parentId === 10 && (parent.operator === "|" || parent.operator === "&") && node === parent.left) {
     return true;
   }
-  return Binary(node, parent);
+  return BinaryLike(node, parent, parentId, 2);
 }
-function TSConditionalType(node, parent) {
-  const parentType = parent.type;
-  if (parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType" || parentType === "TSTypeOperator" || parentType === "TSTypeParameter") {
-    return true;
-  }
-  if ((parentType === "TSIntersectionType" || parentType === "TSUnionType") && parent.types[0] === node) {
-    return true;
-  }
-  if (parentType === "TSConditionalType" && (parent.checkType === node || parent.extendsType === node)) {
-    return true;
+function TSConditionalType(node, parent, parentId) {
+  switch (parentId) {
+    case 155:
+    case 195:
+    case 211:
+    case 212:
+      return true;
+    case 175:
+      return parent.objectType === node;
+    case 181:
+    case 219:
+      return parent.types[0] === node;
+    case 161:
+      return parent.checkType === node || parent.extendsType === node;
   }
   return false;
 }
-function TSUnionType(node, parent) {
-  const parentType = parent.type;
-  return parentType === "TSIntersectionType" || parentType === "TSTypeOperator" || parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType";
+function TSUnionType(node, parent, parentId) {
+  switch (parentId) {
+    case 181:
+    case 211:
+    case 155:
+    case 195:
+      return true;
+    case 175:
+      return parent.objectType === node;
+  }
+  return false;
 }
-function TSIntersectionType(node, parent) {
-  const parentType = parent.type;
-  return parentType === "TSTypeOperator" || parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType";
+function TSIntersectionType(node, parent, parentId) {
+  return parentId === 211 || TSTypeOperator(node, parent, parentId);
 }
-function TSInferType(node, parent) {
-  const parentType = parent.type;
-  if (parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType") {
+function TSInferType(node, parent, parentId) {
+  if (TSTypeOperator(node, parent, parentId)) {
+    return true;
+  }
+  if ((parentId === 181 || parentId === 219) && node.typeParameter.constraint && parent.types[0] === node) {
     return true;
   }
-  if (node.typeParameter.constraint) {
-    if ((parentType === "TSIntersectionType" || parentType === "TSUnionType") && parent.types[0] === node) {
+  return false;
+}
+function TSTypeOperator(node, parent, parentId) {
+  switch (parentId) {
+    case 155:
+    case 195:
       return true;
-    }
+    case 175:
+      if (parent.objectType === node) {
+        return true;
+      }
   }
   return false;
 }
-function TSTypeOperator(node, parent) {
-  const parentType = parent.type;
-  return parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType";
+function TSInstantiationExpression(node, parent, parentId) {
+  switch (parentId) {
+    case 17:
+    case 130:
+    case 112:
+    case 177:
+      return (parent.typeParameters
+      ) != null;
+  }
+  return false;
 }
-function TSInstantiationExpression(node, parent) {
-  const parentType = parent.type;
-  return (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression" || parentType === "TSInstantiationExpression") && !!parent.typeParameters;
+function TSFunctionType(node, parent, parentId) {
+  if (TSUnionType(node, parent, parentId)) return true;
+  return parentId === 219 || parentId === 161 && (parent.checkType === node || parent.extendsType === node);
 }
-function TSFunctionType(node, parent) {
-  const parentType = parent.type;
-  return parentType === "TSIntersectionType" || parentType === "TSUnionType" || parentType === "TSTypeOperator" || parentType === "TSOptionalType" || parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSConditionalType" && (parent.checkType === node || parent.extendsType === node);
+function BinaryExpression(node, parent, parentId, tokenContext) {
+  if (BinaryLike(node, parent, parentId, 0)) return true;
+  return (tokenContext & _index.TokenContext.forInOrInitHeadAccumulate) > 0 && node.operator === "in";
 }
-function BinaryExpression(node, parent, tokenContext) {
-  return node.operator === "in" && Boolean(tokenContext & _index.TokenContext.forInOrInitHeadAccumulate);
+function LogicalExpression(node, parent, parentId) {
+  return BinaryLike(node, parent, parentId, 1);
 }
-function SequenceExpression(node, parent) {
-  const parentType = parent.type;
-  if (parentType === "SequenceExpression" || parentType === "ParenthesizedExpression" || parentType === "MemberExpression" && parent.property === node || parentType === "OptionalMemberExpression" && parent.property === node || parentType === "TemplateLiteral") {
+function SequenceExpression(node, parent, parentId) {
+  if (parentId === 144 || parentId === 133 || parentId === 108 && parent.property === node || parentId === 132 && parent.property === node || parentId === 224) {
     return false;
   }
-  if (parentType === "ClassDeclaration") {
+  if (parentId === 21) {
     return true;
   }
-  if (parentType === "ForOfStatement") {
+  if (parentId === 68) {
     return parent.right === node;
   }
-  if (parentType === "ExportDefaultDeclaration") {
+  if (parentId === 60) {
     return true;
   }
   return !isStatement(parent);
 }
-function YieldExpression(node, parent) {
-  const parentType = parent.type;
-  return parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "UnaryExpression" || parentType === "SpreadElement" || hasPostfixPart(node, parent) || parentType === "AwaitExpression" && isYieldExpression(node) || parentType === "ConditionalExpression" && node === parent.test || isClassExtendsClause(node, parent) || isTSTypeExpression(parentType);
+function YieldExpression(node, parent, parentId) {
+  return parentId === 10 || parentId === 107 || parentId === 238 || parentId === 145 || hasPostfixPart(node, parent, parentId) || parentId === 8 && isYieldExpression(node) || parentId === 28 && node === parent.test || isClassExtendsClause(node, parent, parentId) || isTSTypeExpression(parentId);
 }
-function ClassExpression(node, parent, tokenContext) {
-  return Boolean(tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault));
+function ClassExpression(node, parent, parentId, tokenContext) {
+  return (tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault)) > 0;
 }
-function UnaryLike(node, parent) {
-  return hasPostfixPart(node, parent) || isBinaryExpression(parent) && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent);
+function UnaryLike(node, parent, parentId) {
+  return hasPostfixPart(node, parent, parentId) || parentId === 10 && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent, parentId);
 }
-function FunctionExpression(node, parent, tokenContext) {
-  return Boolean(tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault));
+function FunctionExpression(node, parent, parentId, tokenContext) {
+  return (tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault)) > 0;
 }
-function ConditionalExpression(node, parent) {
-  const parentType = parent.type;
-  if (parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "ConditionalExpression" && parent.test === node || parentType === "AwaitExpression" || isTSTypeExpression(parentType)) {
+function ConditionalExpression(node, parent, parentId) {
+  switch (parentId) {
+    case 238:
+    case 145:
+    case 10:
+    case 107:
+    case 8:
+      return true;
+    case 28:
+      if (parent.test === node) {
+        return true;
+      }
+  }
+  if (isTSTypeExpression(parentId)) {
     return true;
   }
-  return UnaryLike(node, parent);
-}
-function OptionalMemberExpression(node, parent) {
-  return isCallExpression(parent) && parent.callee === node || isMemberExpression(parent) && parent.object === node;
+  return UnaryLike(node, parent, parentId);
 }
-function AssignmentExpression(node, parent, tokenContext) {
-  if (needsParenBeforeExpressionBrace(tokenContext) && isObjectPattern(node.left)) {
-    return true;
-  } else {
-    return ConditionalExpression(node, parent);
+function OptionalMemberExpression(node, parent, parentId) {
+  switch (parentId) {
+    case 17:
+      return parent.callee === node;
+    case 108:
+      return parent.object === node;
   }
+  return false;
 }
-function LogicalExpression(node, parent) {
-  const parentType = parent.type;
-  if (isTSTypeExpression(parentType)) return true;
-  if (parentType !== "LogicalExpression") return false;
-  switch (node.operator) {
-    case "||":
-      return parent.operator === "??" || parent.operator === "&&";
-    case "&&":
-      return parent.operator === "??";
-    case "??":
-      return parent.operator !== "??";
+function AssignmentExpression(node, parent, parentId, tokenContext) {
+  if (needsParenBeforeExpressionBrace(tokenContext) && node.left.type === "ObjectPattern") {
+    return true;
   }
+  return ConditionalExpression(node, parent, parentId);
 }
-function Identifier(node, parent, tokenContext, getRawIdentifier) {
+function Identifier(node, parent, parentId, tokenContext, getRawIdentifier) {
   var _node$extra;
-  const parentType = parent.type;
-  if ((_node$extra = node.extra) != null && _node$extra.parenthesized && parentType === "AssignmentExpression" && parent.left === node) {
+  if (getRawIdentifier && getRawIdentifier(node) !== node.name) {
+    return false;
+  }
+  if (parentId === 6 && (_node$extra = node.extra) != null && _node$extra.parenthesized && parent.left === node) {
     const rightType = parent.right.type;
     if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) {
       return true;
     }
   }
-  if (getRawIdentifier && getRawIdentifier(node) !== node.name) {
-    return false;
-  }
-  if (node.name === "let") {
-    const isFollowedByBracket = isMemberExpression(parent, {
-      object: node,
-      computed: true
-    }) || isOptionalMemberExpression(parent, {
-      object: node,
-      computed: true,
-      optional: false
-    });
-    if (isFollowedByBracket && tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.forInitHead | _index.TokenContext.forInHead)) {
-      return true;
+  if (tokenContext & _index.TokenContext.forOfHead || (parentId === 108 || parentId === 132) && tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.forInitHead | _index.TokenContext.forInHead)) {
+    if (node.name === "let") {
+      const isFollowedByBracket = isMemberExpression(parent, {
+        object: node,
+        computed: true
+      }) || isOptionalMemberExpression(parent, {
+        object: node,
+        computed: true,
+        optional: false
+      });
+      if (isFollowedByBracket && tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.forInitHead | _index.TokenContext.forInHead)) {
+        return true;
+      }
+      return (tokenContext & _index.TokenContext.forOfHead) > 0;
     }
-    return Boolean(tokenContext & _index.TokenContext.forOfHead);
   }
-  return node.name === "async" && isForOfStatement(parent, {
-    left: node,
-    await: false
-  });
+  return parentId === 68 && parent.left === node && node.name === "async" && !parent.await;
 }
 
 //# sourceMappingURL=parentheses.js.map

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/node/whitespace.js

@@ -1,145 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.nodes = void 0;
-var _t = require("@babel/types");
-const {
-  FLIPPED_ALIAS_KEYS,
-  isArrayExpression,
-  isAssignmentExpression,
-  isBinary,
-  isBlockStatement,
-  isCallExpression,
-  isFunction,
-  isIdentifier,
-  isLiteral,
-  isMemberExpression,
-  isObjectExpression,
-  isOptionalCallExpression,
-  isOptionalMemberExpression,
-  isStringLiteral
-} = _t;
-function crawlInternal(node, state) {
-  if (!node) return state;
-  if (isMemberExpression(node) || isOptionalMemberExpression(node)) {
-    crawlInternal(node.object, state);
-    if (node.computed) crawlInternal(node.property, state);
-  } else if (isBinary(node) || isAssignmentExpression(node)) {
-    crawlInternal(node.left, state);
-    crawlInternal(node.right, state);
-  } else if (isCallExpression(node) || isOptionalCallExpression(node)) {
-    state.hasCall = true;
-    crawlInternal(node.callee, state);
-  } else if (isFunction(node)) {
-    state.hasFunction = true;
-  } else if (isIdentifier(node)) {
-    state.hasHelper = state.hasHelper || node.callee && isHelper(node.callee);
-  }
-  return state;
-}
-function crawl(node) {
-  return crawlInternal(node, {
-    hasCall: false,
-    hasFunction: false,
-    hasHelper: false
-  });
-}
-function isHelper(node) {
-  if (!node) return false;
-  if (isMemberExpression(node)) {
-    return isHelper(node.object) || isHelper(node.property);
-  } else if (isIdentifier(node)) {
-    return node.name === "require" || node.name.charCodeAt(0) === 95;
-  } else if (isCallExpression(node)) {
-    return isHelper(node.callee);
-  } else if (isBinary(node) || isAssignmentExpression(node)) {
-    return isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right);
-  } else {
-    return false;
-  }
-}
-function isType(node) {
-  return isLiteral(node) || isObjectExpression(node) || isArrayExpression(node) || isIdentifier(node) || isMemberExpression(node);
-}
-const nodes = exports.nodes = {
-  AssignmentExpression(node) {
-    const state = crawl(node.right);
-    if (state.hasCall && state.hasHelper || state.hasFunction) {
-      return state.hasFunction ? 1 | 2 : 2;
-    }
-  },
-  SwitchCase(node, parent) {
-    return (!!node.consequent.length || parent.cases[0] === node ? 1 : 0) | (!node.consequent.length && parent.cases[parent.cases.length - 1] === node ? 2 : 0);
-  },
-  LogicalExpression(node) {
-    if (isFunction(node.left) || isFunction(node.right)) {
-      return 2;
-    }
-  },
-  Literal(node) {
-    if (isStringLiteral(node) && node.value === "use strict") {
-      return 2;
-    }
-  },
-  CallExpression(node) {
-    if (isFunction(node.callee) || isHelper(node)) {
-      return 1 | 2;
-    }
-  },
-  OptionalCallExpression(node) {
-    if (isFunction(node.callee)) {
-      return 1 | 2;
-    }
-  },
-  VariableDeclaration(node) {
-    for (let i = 0; i < node.declarations.length; i++) {
-      const declar = node.declarations[i];
-      let enabled = isHelper(declar.id) && !isType(declar.init);
-      if (!enabled && declar.init) {
-        const state = crawl(declar.init);
-        enabled = isHelper(declar.init) && state.hasCall || state.hasFunction;
-      }
-      if (enabled) {
-        return 1 | 2;
-      }
-    }
-  },
-  IfStatement(node) {
-    if (isBlockStatement(node.consequent)) {
-      return 1 | 2;
-    }
-  }
-};
-nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) {
-  if (parent.properties[0] === node) {
-    return 1;
-  }
-};
-nodes.ObjectTypeCallProperty = function (node, parent) {
-  var _parent$properties;
-  if (parent.callProperties[0] === node && !((_parent$properties = parent.properties) != null && _parent$properties.length)) {
-    return 1;
-  }
-};
-nodes.ObjectTypeIndexer = function (node, parent) {
-  var _parent$properties2, _parent$callPropertie;
-  if (parent.indexers[0] === node && !((_parent$properties2 = parent.properties) != null && _parent$properties2.length) && !((_parent$callPropertie = parent.callProperties) != null && _parent$callPropertie.length)) {
-    return 1;
-  }
-};
-nodes.ObjectTypeInternalSlot = function (node, parent) {
-  var _parent$properties3, _parent$callPropertie2, _parent$indexers;
-  if (parent.internalSlots[0] === node && !((_parent$properties3 = parent.properties) != null && _parent$properties3.length) && !((_parent$callPropertie2 = parent.callProperties) != null && _parent$callPropertie2.length) && !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)) {
-    return 1;
-  }
-};
-[["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) {
-  [type].concat(FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) {
-    const ret = amounts ? 1 | 2 : 0;
-    nodes[type] = () => ret;
-  });
-});
-
-//# sourceMappingURL=whitespace.js.map

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/printer.js

@@ -6,11 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _buffer = require("./buffer.js");
 var _index = require("./node/index.js");
-var n = _index;
+var _nodes = require("./nodes.js");
 var _t = require("@babel/types");
 var _tokenMap = require("./token-map.js");
-var generatorFunctions = require("./generators/index.js");
-var _deprecated = require("./generators/deprecated.js");
+var _types2 = require("./generators/types.js");
 const {
   isExpression,
   isFunction,
@@ -26,15 +25,13 @@ const HAS_NEWLINE_OR_BlOCK_COMMENT_END = /[\n\r\u2028\u2029]|\*\//;
 function commentIsNewline(c) {
   return c.type === "CommentLine" || HAS_NEWLINE.test(c.value);
 }
-const {
-  needsParens
-} = n;
 class Printer {
-  constructor(format, map, tokens, originalCode) {
+  constructor(format, map, tokens = null, originalCode = null) {
     this.tokenContext = _index.TokenContext.normal;
     this._tokens = null;
     this._originalCode = null;
     this._currentNode = null;
+    this._currentTypeId = null;
     this._indent = 0;
     this._indentRepeat = 0;
     this._insideAux = false;
@@ -42,83 +39,79 @@ class Printer {
     this._noLineTerminatorAfterNode = null;
     this._printAuxAfterOnNextUserNode = false;
     this._printedComments = new Set();
-    this._endsWithInteger = false;
-    this._endsWithWord = false;
-    this._endsWithDiv = false;
     this._lastCommentLine = 0;
-    this._endsWithInnerRaw = false;
-    this._indentInnerComments = true;
+    this._innerCommentsState = 0;
+    this._flags = 0;
     this.tokenMap = null;
-    this._boundGetRawIdentifier = this._getRawIdentifier.bind(this);
+    this._boundGetRawIdentifier = null;
     this._printSemicolonBeforeNextNode = -1;
     this._printSemicolonBeforeNextToken = -1;
     this.format = format;
     this._tokens = tokens;
     this._originalCode = originalCode;
     this._indentRepeat = format.indent.style.length;
-    this._inputMap = map == null ? void 0 : map._inputMap;
+    this._inputMap = (map == null ? void 0 : map._inputMap) || null;
     this._buf = new _buffer.default(map, format.indent.style[0]);
-  }
-  enterForStatementInit() {
-    this.tokenContext |= _index.TokenContext.forInitHead | _index.TokenContext.forInOrInitHeadAccumulate;
-    return () => this.tokenContext = _index.TokenContext.normal;
-  }
-  enterForXStatementInit(isForOf) {
-    if (isForOf) {
-      this.tokenContext |= _index.TokenContext.forOfHead;
-      return null;
-    } else {
-      this.tokenContext |= _index.TokenContext.forInHead | _index.TokenContext.forInOrInitHeadAccumulate;
-      return () => this.tokenContext = _index.TokenContext.normal;
+    const {
+      preserveFormat,
+      compact,
+      concise,
+      retainLines,
+      retainFunctionParens
+    } = format;
+    if (preserveFormat) {
+      this._flags |= 1;
+    }
+    if (compact) {
+      this._flags |= 2;
+    }
+    if (concise) {
+      this._flags |= 4;
+    }
+    if (retainLines) {
+      this._flags |= 8;
+    }
+    if (retainFunctionParens) {
+      this._flags |= 16;
+    }
+    if (format.auxiliaryCommentBefore || format.auxiliaryCommentAfter) {
+      this._flags |= 32;
     }
   }
   enterDelimited() {
-    const oldTokenContext = this.tokenContext;
     const oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
-    if (!(oldTokenContext & _index.TokenContext.forInOrInitHeadAccumulate) && oldNoLineTerminatorAfterNode === null) {
-      return () => {};
+    if (oldNoLineTerminatorAfterNode !== null) {
+      this._noLineTerminatorAfterNode = null;
     }
-    this._noLineTerminatorAfterNode = null;
-    this.tokenContext = _index.TokenContext.normal;
-    return () => {
-      this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
-      this.tokenContext = oldTokenContext;
-    };
+    return oldNoLineTerminatorAfterNode;
   }
   generate(ast) {
     if (this.format.preserveFormat) {
       this.tokenMap = new _tokenMap.TokenMap(ast, this._tokens, this._originalCode);
+      this._boundGetRawIdentifier = _types2._getRawIdentifier.bind(this);
     }
     this.print(ast);
     this._maybeAddAuxComment();
     return this._buf.get();
   }
-  indent() {
-    const {
-      format
-    } = this;
-    if (format.preserveFormat || format.compact || format.concise) {
+  indent(flags = this._flags) {
+    if (flags & (1 | 2 | 4)) {
       return;
     }
-    this._indent++;
+    this._indent += this._indentRepeat;
   }
-  dedent() {
-    const {
-      format
-    } = this;
-    if (format.preserveFormat || format.compact || format.concise) {
+  dedent(flags = this._flags) {
+    if (flags & (1 | 2 | 4)) {
       return;
     }
-    this._indent--;
+    this._indent -= this._indentRepeat;
   }
   semicolon(force = false) {
-    this._maybeAddAuxComment();
-    if (force) {
-      this._appendChar(59);
-      this._noLineTerminator = false;
-      return;
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
     }
-    if (this.tokenMap) {
+    if (flags & 1) {
       const node = this._currentNode;
       if (node.start != null && node.end != null) {
         if (!this.tokenMap.endMatches(node, ";")) {
@@ -129,7 +122,11 @@ class Printer {
         this._catchUpTo(this._tokens[indexes[indexes.length - 1]].loc.start);
       }
     }
-    this._queue(59);
+    if (force) {
+      this._appendChar(59);
+    } else {
+      this._queue(59);
+    }
     this._noLineTerminator = false;
   }
   rightBrace(node) {
@@ -144,15 +141,14 @@ class Printer {
     this.tokenChar(41);
   }
   space(force = false) {
-    const {
-      format
-    } = this;
-    if (format.compact || format.preserveFormat) return;
+    if (this._flags & (1 | 2)) {
+      return;
+    }
     if (force) {
       this._space();
-    } else if (this._buf.hasContent()) {
-      const lastCp = this.getLastChar();
-      if (lastCp !== 32 && lastCp !== 10) {
+    } else {
+      const lastCp = this.getLastChar(true);
+      if (lastCp !== 0 && lastCp !== 32 && lastCp !== 10) {
         this._space();
       }
     }
@@ -160,13 +156,17 @@ class Printer {
   word(str, noLineTerminatorAfter = false) {
     this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask;
     this._maybePrintInnerComments(str);
-    this._maybeAddAuxComment();
-    if (this.tokenMap) this._catchUpToCurrentToken(str);
-    if (this._endsWithWord || this._endsWithDiv && str.charCodeAt(0) === 47) {
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) this._catchUpToCurrentToken(str);
+    const lastChar = this.getLastChar();
+    if (lastChar === -2 || lastChar === -3 || lastChar === 47 && str.charCodeAt(0) === 47) {
       this._space();
     }
     this._append(str, false);
-    this._endsWithWord = true;
+    this.setLastChar(-3);
     this._noLineTerminator = noLineTerminatorAfter;
   }
   number(str, number) {
@@ -178,61 +178,68 @@ class Printer {
       return false;
     }
     this.word(str);
-    this._endsWithInteger = Number.isInteger(number) && !isNonDecimalLiteral(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46;
+    if (Number.isInteger(number) && !isNonDecimalLiteral(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46) {
+      this.setLastChar(-2);
+    }
   }
-  token(str, maybeNewline = false, occurrenceCount = 0) {
+  token(str, maybeNewline = false, occurrenceCount = 0, mayNeedSpace = false) {
     this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask;
     this._maybePrintInnerComments(str, occurrenceCount);
-    this._maybeAddAuxComment();
-    if (this.tokenMap) this._catchUpToCurrentToken(str, occurrenceCount);
-    const lastChar = this.getLastChar();
-    const strFirst = str.charCodeAt(0);
-    if (lastChar === 33 && (str === "--" || strFirst === 61) || strFirst === 43 && lastChar === 43 || strFirst === 45 && lastChar === 45 || strFirst === 46 && this._endsWithInteger) {
-      this._space();
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) {
+      this._catchUpToCurrentToken(str, occurrenceCount);
+    }
+    if (mayNeedSpace) {
+      const strFirst = str.charCodeAt(0);
+      if ((strFirst === 45 && str === "--" || strFirst === 61) && this.getLastChar() === 33 || strFirst === 43 && this.getLastChar() === 43 || strFirst === 45 && this.getLastChar() === 45 || strFirst === 46 && this.getLastChar() === -2) {
+        this._space();
+      }
     }
     this._append(str, maybeNewline);
     this._noLineTerminator = false;
   }
-  tokenChar(char) {
+  tokenChar(char, occurrenceCount = 0) {
     this.tokenContext &= _index.TokenContext.forInOrInitHeadAccumulatePassThroughMask;
-    const str = String.fromCharCode(char);
-    this._maybePrintInnerComments(str);
-    this._maybeAddAuxComment();
-    if (this.tokenMap) this._catchUpToCurrentToken(str);
-    const lastChar = this.getLastChar();
-    if (char === 43 && lastChar === 43 || char === 45 && lastChar === 45 || char === 46 && this._endsWithInteger) {
+    this._maybePrintInnerComments(char, occurrenceCount);
+    const flags = this._flags;
+    if (flags & 32) {
+      this._maybeAddAuxComment();
+    }
+    if (flags & 1) {
+      this._catchUpToCurrentToken(char, occurrenceCount);
+    }
+    if (char === 43 && this.getLastChar() === 43 || char === 45 && this.getLastChar() === 45 || char === 46 && this.getLastChar() === -2) {
       this._space();
     }
     this._appendChar(char);
     this._noLineTerminator = false;
   }
-  newline(i = 1, force) {
+  newline(i = 1, flags = this._flags) {
     if (i <= 0) return;
-    if (!force) {
-      if (this.format.retainLines || this.format.compact) return;
-      if (this.format.concise) {
-        this.space();
-        return;
-      }
+    if (flags & (8 | 2)) {
+      return;
+    }
+    if (flags & 4) {
+      this.space();
+      return;
     }
     if (i > 2) i = 2;
     i -= this._buf.getNewlineCount();
     for (let j = 0; j < i; j++) {
       this._newline();
     }
-    return;
   }
   endsWith(char) {
-    return this.getLastChar() === char;
-  }
-  getLastChar() {
-    return this._buf.getLastChar();
+    return this.getLastChar(true) === char;
   }
-  endsWithCharAndNewline() {
-    return this._buf.endsWithCharAndNewline();
+  getLastChar(checkQueue) {
+    return this._buf.getLastChar(checkQueue);
   }
-  removeTrailingNewline() {
-    this._buf.removeTrailingNewline();
+  setLastChar(char) {
+    this._buf._last = char;
   }
   exactSource(loc, cb) {
     if (!loc) {
@@ -262,49 +269,40 @@ class Printer {
     this._queue(32);
   }
   _newline() {
-    this._queue(10);
+    if (this._buf._queuedChar === 32) this._buf._queuedChar = 0;
+    this._appendChar(10, true);
   }
   _catchUpToCurrentToken(str, occurrenceCount = 0) {
     const token = this.tokenMap.findMatching(this._currentNode, str, occurrenceCount);
     if (token) this._catchUpTo(token.loc.start);
     if (this._printSemicolonBeforeNextToken !== -1 && this._printSemicolonBeforeNextToken === this._buf.getCurrentLine()) {
-      this._buf.appendChar(59);
-      this._endsWithWord = false;
-      this._endsWithInteger = false;
-      this._endsWithDiv = false;
+      this._appendChar(59, true);
     }
     this._printSemicolonBeforeNextToken = -1;
     this._printSemicolonBeforeNextNode = -1;
   }
   _append(str, maybeNewline) {
-    this._maybeIndent(str.charCodeAt(0));
+    this._maybeIndent();
     this._buf.append(str, maybeNewline);
-    this._endsWithWord = false;
-    this._endsWithInteger = false;
-    this._endsWithDiv = false;
   }
-  _appendChar(char) {
-    this._maybeIndent(char);
+  _appendChar(char, noIndent) {
+    if (!noIndent) {
+      this._maybeIndent();
+    }
     this._buf.appendChar(char);
-    this._endsWithWord = false;
-    this._endsWithInteger = false;
-    this._endsWithDiv = false;
   }
   _queue(char) {
-    this._maybeIndent(char);
     this._buf.queue(char);
-    this._endsWithWord = false;
-    this._endsWithInteger = false;
+    this.setLastChar(-1);
   }
-  _maybeIndent(firstChar) {
-    if (this._indent && firstChar !== 10 && this.endsWith(10)) {
-      this._buf.queueIndentation(this._getIndent());
+  _maybeIndent() {
+    const indent = this._shouldIndent();
+    if (indent > 0) {
+      this._buf._appendChar(-1, indent, false);
     }
   }
-  _shouldIndent(firstChar) {
-    if (this._indent && firstChar !== 10 && this.endsWith(10)) {
-      return true;
-    }
+  _shouldIndent() {
+    return this.endsWith(10) ? this._indent : 0;
   }
   catchUp(line) {
     if (!this.format.retainLines) return;
@@ -314,11 +312,9 @@ class Printer {
     }
   }
   _catchUp(prop, loc) {
-    const {
-      format
-    } = this;
-    if (!format.preserveFormat) {
-      if (format.retainLines && loc != null && loc[prop]) {
+    const flags = this._flags;
+    if ((flags & 1) === 0) {
+      if (flags & 8 && loc != null && loc[prop]) {
         this.catchUp(loc[prop].line);
       }
       return;
@@ -342,64 +338,80 @@ class Printer {
     if (spacesCount > 0) {
       const spaces = this._originalCode ? this._originalCode.slice(index - spacesCount, index).replace(/[^\t\x0B\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]/gu, " ") : " ".repeat(spacesCount);
       this._append(spaces, false);
+      this.setLastChar(32);
     }
   }
-  _getIndent() {
-    return this._indentRepeat * this._indent;
-  }
   printTerminatorless(node) {
     this._noLineTerminator = true;
     this.print(node);
   }
-  print(node, noLineTerminatorAfter, trailingCommentsLineOffset) {
-    var _node$extra, _node$leadingComments, _node$leadingComments2;
+  print(node, noLineTerminatorAfter = false, resetTokenContext = false, trailingCommentsLineOffset) {
+    var _node$leadingComments, _node$leadingComments2;
     if (!node) return;
-    this._endsWithInnerRaw = false;
-    const nodeType = node.type;
-    const format = this.format;
-    const oldConcise = format.concise;
+    this._innerCommentsState = 0;
+    const {
+      type,
+      loc,
+      extra
+    } = node;
+    const flags = this._flags;
+    let changedFlags = false;
     if (node._compact) {
-      format.concise = true;
+      this._flags |= 4;
+      changedFlags = true;
     }
-    const printMethod = this[nodeType];
-    if (printMethod === undefined) {
-      throw new ReferenceError(`unknown node of type ${JSON.stringify(nodeType)} with constructor ${JSON.stringify(node.constructor.name)}`);
+    const nodeInfo = _nodes.generatorInfosMap.get(type);
+    if (nodeInfo === undefined) {
+      throw new ReferenceError(`unknown node of type ${JSON.stringify(type)} with constructor ${JSON.stringify(node.constructor.name)}`);
     }
+    const [printMethod, nodeId, needsParens] = nodeInfo;
     const parent = this._currentNode;
+    const parentId = this._currentTypeId;
     this._currentNode = node;
-    if (this.tokenMap) {
+    this._currentTypeId = nodeId;
+    if (flags & 1) {
       this._printSemicolonBeforeNextToken = this._printSemicolonBeforeNextNode;
     }
-    const oldInAux = this._insideAux;
-    this._insideAux = node.loc == null;
-    this._maybeAddAuxComment(this._insideAux && !oldInAux);
-    const parenthesized = (_node$extra = node.extra) == null ? void 0 : _node$extra.parenthesized;
-    let shouldPrintParens = parenthesized && format.preserveFormat || parenthesized && format.retainFunctionParens && nodeType === "FunctionExpression" || needsParens(node, parent, this.tokenContext, format.preserveFormat ? this._boundGetRawIdentifier : undefined);
+    let oldInAux;
+    if (flags & 32) {
+      oldInAux = this._insideAux;
+      this._insideAux = loc == null;
+      this._maybeAddAuxComment(this._insideAux && !oldInAux);
+    }
+    let oldTokenContext = 0;
+    if (resetTokenContext) {
+      oldTokenContext = this.tokenContext;
+      if (oldTokenContext & _index.TokenContext.forInOrInitHeadAccumulate) {
+        this.tokenContext = 0;
+      } else {
+        oldTokenContext = 0;
+      }
+    }
+    const parenthesized = extra != null && extra.parenthesized;
+    let shouldPrintParens = parenthesized && flags & 1 || parenthesized && flags & 16 && nodeId === 71 || parent && ((0, _index.parentNeedsParens)(node, parent, parentId) || needsParens != null && needsParens(node, parent, parentId, this.tokenContext, flags & 1 ? this._boundGetRawIdentifier : undefined));
     if (!shouldPrintParens && parenthesized && (_node$leadingComments = node.leadingComments) != null && _node$leadingComments.length && node.leadingComments[0].type === "CommentBlock") {
-      const parentType = parent == null ? void 0 : parent.type;
-      switch (parentType) {
-        case "ExpressionStatement":
-        case "VariableDeclarator":
-        case "AssignmentExpression":
-        case "ReturnStatement":
+      switch (parentId) {
+        case 65:
+        case 243:
+        case 6:
+        case 143:
           break;
-        case "CallExpression":
-        case "OptionalCallExpression":
-        case "NewExpression":
+        case 17:
+        case 130:
+        case 112:
           if (parent.callee !== node) break;
         default:
           shouldPrintParens = true;
       }
     }
     let indentParenthesized = false;
-    if (!shouldPrintParens && this._noLineTerminator && ((_node$leadingComments2 = node.leadingComments) != null && _node$leadingComments2.some(commentIsNewline) || this.format.retainLines && node.loc && node.loc.start.line > this._buf.getCurrentLine())) {
+    if (!shouldPrintParens && this._noLineTerminator && ((_node$leadingComments2 = node.leadingComments) != null && _node$leadingComments2.some(commentIsNewline) || flags & 8 && loc && loc.start.line > this._buf.getCurrentLine())) {
       shouldPrintParens = true;
       indentParenthesized = true;
     }
     let oldNoLineTerminatorAfterNode;
-    let oldTokenContext;
     if (!shouldPrintParens) {
-      noLineTerminatorAfter || (noLineTerminatorAfter = parent && this._noLineTerminatorAfterNode === parent && n.isLastChild(parent, node));
+      noLineTerminatorAfter || (noLineTerminatorAfter = !!parent && this._noLineTerminatorAfterNode === parent && (0, _index.isLastChild)(parent, node));
       if (noLineTerminatorAfter) {
         var _node$trailingComment;
         if ((_node$trailingComment = node.trailingComments) != null && _node$trailingComment.some(commentIsNewline)) {
@@ -413,18 +425,18 @@ class Printer {
     if (shouldPrintParens) {
       this.tokenChar(40);
       if (indentParenthesized) this.indent();
-      this._endsWithInnerRaw = false;
-      if (this.tokenContext & _index.TokenContext.forInOrInitHeadAccumulate) {
+      this._innerCommentsState = 0;
+      if (!resetTokenContext) {
         oldTokenContext = this.tokenContext;
-        this.tokenContext = _index.TokenContext.normal;
+      }
+      if (oldTokenContext & _index.TokenContext.forInOrInitHeadAccumulate) {
+        this.tokenContext = 0;
       }
       oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
       this._noLineTerminatorAfterNode = null;
     }
-    this._lastCommentLine = 0;
     this._printLeadingComments(node, parent);
-    const loc = nodeType === "Program" || nodeType === "File" ? null : node.loc;
-    this.exactSource(loc, printMethod.bind(this, node, parent));
+    this.exactSource(nodeId === 139 || nodeId === 66 ? null : loc, printMethod.bind(this, node, parent));
     if (shouldPrintParens) {
       this._printTrailingComments(node, parent);
       if (indentParenthesized) {
@@ -433,20 +445,25 @@ class Printer {
       }
       this.tokenChar(41);
       this._noLineTerminator = noLineTerminatorAfter;
-      if (oldTokenContext) this.tokenContext = oldTokenContext;
     } else if (noLineTerminatorAfter && !this._noLineTerminator) {
       this._noLineTerminator = true;
       this._printTrailingComments(node, parent);
     } else {
       this._printTrailingComments(node, parent, trailingCommentsLineOffset);
     }
+    if (oldTokenContext) this.tokenContext = oldTokenContext;
     this._currentNode = parent;
-    format.concise = oldConcise;
-    this._insideAux = oldInAux;
-    if (oldNoLineTerminatorAfterNode !== undefined) {
+    this._currentTypeId = parentId;
+    if (changedFlags) {
+      this._flags = flags;
+    }
+    if (flags & 32) {
+      this._insideAux = oldInAux;
+    }
+    if (oldNoLineTerminatorAfterNode != null) {
       this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
     }
-    this._endsWithInnerRaw = false;
+    this._innerCommentsState = 0;
   }
   _maybeAddAuxComment(enteredPositionlessNode) {
     if (enteredPositionlessNode) this._printAuxBeforeComment();
@@ -480,47 +497,46 @@ class Printer {
       return extra.raw;
     }
   }
-  printJoin(nodes, statement, indent, separator, printTrailingSeparator, addNewlines, iterator, trailingCommentsLineOffset) {
+  printJoin(nodes, statement, indent, separator, printTrailingSeparator, resetTokenContext, trailingCommentsLineOffset) {
     if (!(nodes != null && nodes.length)) return;
-    if (indent == null && this.format.retainLines) {
+    const flags = this._flags;
+    if (indent == null && flags & 8) {
       var _nodes$0$loc;
       const startLine = (_nodes$0$loc = nodes[0].loc) == null ? void 0 : _nodes$0$loc.start.line;
       if (startLine != null && startLine !== this._buf.getCurrentLine()) {
         indent = true;
       }
     }
-    if (indent) this.indent();
-    const newlineOpts = {
-      addNewlines: addNewlines,
-      nextNodeStartLine: 0
-    };
-    const boundSeparator = separator == null ? void 0 : separator.bind(this);
+    if (indent) this.indent(flags);
     const len = nodes.length;
     for (let i = 0; i < len; i++) {
       const node = nodes[i];
       if (!node) continue;
-      if (statement) this._printNewline(i === 0, newlineOpts);
-      this.print(node, undefined, trailingCommentsLineOffset || 0);
-      iterator == null || iterator(node, i);
-      if (boundSeparator != null) {
-        if (i < len - 1) boundSeparator(i, false);else if (printTrailingSeparator) boundSeparator(i, true);
+      if (statement && i === 0 && this._buf.hasContent()) {
+        this.newline(1, flags);
+      }
+      this.print(node, false, resetTokenContext, trailingCommentsLineOffset || 0);
+      if (separator != null) {
+        if (i < len - 1) separator.call(this, i, false);else if (printTrailingSeparator) separator.call(this, i, true);
       }
       if (statement) {
-        var _node$trailingComment2;
-        if (!((_node$trailingComment2 = node.trailingComments) != null && _node$trailingComment2.length)) {
-          this._lastCommentLine = 0;
-        }
         if (i + 1 === len) {
-          this.newline(1);
+          this.newline(1, flags);
         } else {
-          var _nextNode$loc;
-          const nextNode = nodes[i + 1];
-          newlineOpts.nextNodeStartLine = ((_nextNode$loc = nextNode.loc) == null ? void 0 : _nextNode$loc.start.line) || 0;
-          this._printNewline(true, newlineOpts);
+          const lastCommentLine = this._lastCommentLine;
+          if (lastCommentLine > 0) {
+            var _nodes$loc;
+            const offset = (((_nodes$loc = nodes[i + 1].loc) == null ? void 0 : _nodes$loc.start.line) || 0) - lastCommentLine;
+            if (offset >= 0) {
+              this.newline(offset || 1, flags);
+              continue;
+            }
+          }
+          this.newline(1, flags);
         }
       }
     }
-    if (indent) this.dedent();
+    if (indent) this.dedent(flags);
   }
   printAndIndentOnComments(node) {
     const indent = node.leadingComments && node.leadingComments.length > 0;
@@ -528,12 +544,11 @@ class Printer {
     this.print(node);
     if (indent) this.dedent();
   }
-  printBlock(parent) {
-    const node = parent.body;
-    if (node.type !== "EmptyStatement") {
+  printBlock(body) {
+    if (body.type !== "EmptyStatement") {
       this.space();
     }
-    this.print(node);
+    this.print(body);
   }
   _printTrailingComments(node, parent, lineOffset) {
     const {
@@ -545,6 +560,8 @@ class Printer {
     }
     if (trailingComments != null && trailingComments.length) {
       this._printComments(2, trailingComments, node, parent, lineOffset);
+    } else {
+      this._lastCommentLine = 0;
     }
   }
   _printLeadingComments(node, parent) {
@@ -553,65 +570,48 @@ class Printer {
     this._printComments(0, comments, node, parent);
   }
   _maybePrintInnerComments(nextTokenStr, nextTokenOccurrenceCount) {
-    if (this._endsWithInnerRaw) {
-      var _this$tokenMap;
-      this.printInnerComments((_this$tokenMap = this.tokenMap) == null ? void 0 : _this$tokenMap.findMatching(this._currentNode, nextTokenStr, nextTokenOccurrenceCount));
+    var _this$tokenMap;
+    const state = this._innerCommentsState;
+    switch (state & 3) {
+      case 0:
+        this._innerCommentsState = 1 | 4;
+        return;
+      case 1:
+        this.printInnerComments((state & 4) > 0, (_this$tokenMap = this.tokenMap) == null ? void 0 : _this$tokenMap.findMatching(this._currentNode, nextTokenStr, nextTokenOccurrenceCount));
     }
-    this._endsWithInnerRaw = true;
-    this._indentInnerComments = true;
   }
-  printInnerComments(nextToken) {
+  printInnerComments(indent = true, nextToken) {
     const node = this._currentNode;
     const comments = node.innerComments;
-    if (!(comments != null && comments.length)) return;
+    if (!(comments != null && comments.length)) {
+      this._innerCommentsState = 2;
+      return;
+    }
     const hasSpace = this.endsWith(32);
-    const indent = this._indentInnerComments;
-    const printedCommentsCount = this._printedComments.size;
     if (indent) this.indent();
-    this._printComments(1, comments, node, undefined, undefined, nextToken);
-    if (hasSpace && printedCommentsCount !== this._printedComments.size) {
-      this.space();
+    switch (this._printComments(1, comments, node, undefined, undefined, nextToken)) {
+      case 2:
+        this._innerCommentsState = 2;
+      case 1:
+        if (hasSpace) this.space();
     }
     if (indent) this.dedent();
   }
   noIndentInnerCommentsHere() {
-    this._indentInnerComments = false;
+    this._innerCommentsState &= ~4;
   }
-  printSequence(nodes, indent, trailingCommentsLineOffset, addNewlines) {
-    this.printJoin(nodes, true, indent != null ? indent : false, undefined, undefined, addNewlines, undefined, trailingCommentsLineOffset);
+  printSequence(nodes, indent, resetTokenContext, trailingCommentsLineOffset) {
+    this.printJoin(nodes, true, indent != null ? indent : false, undefined, undefined, resetTokenContext, trailingCommentsLineOffset);
   }
-  printList(items, printTrailingSeparator, statement, indent, separator, iterator) {
-    this.printJoin(items, statement, indent, separator != null ? separator : commaSeparator, printTrailingSeparator, undefined, iterator);
+  printList(items, printTrailingSeparator, statement, indent, separator, resetTokenContext) {
+    this.printJoin(items, statement, indent, separator != null ? separator : commaSeparator, printTrailingSeparator, resetTokenContext);
   }
   shouldPrintTrailingComma(listEnd) {
     if (!this.tokenMap) return null;
-    const listEndIndex = this.tokenMap.findLastIndex(this._currentNode, token => this.tokenMap.matchesOriginal(token, listEnd));
+    const listEndIndex = this.tokenMap.findLastIndex(this._currentNode, token => this.tokenMap.matchesOriginal(token, typeof listEnd === "number" ? String.fromCharCode(listEnd) : listEnd));
     if (listEndIndex <= 0) return null;
     return this.tokenMap.matchesOriginal(this._tokens[listEndIndex - 1], ",");
   }
-  _printNewline(newLine, opts) {
-    const format = this.format;
-    if (format.retainLines || format.compact) return;
-    if (format.concise) {
-      this.space();
-      return;
-    }
-    if (!newLine) {
-      return;
-    }
-    const startLine = opts.nextNodeStartLine;
-    const lastCommentLine = this._lastCommentLine;
-    if (startLine > 0 && lastCommentLine > 0) {
-      const offset = startLine - lastCommentLine;
-      if (offset >= 0) {
-        this.newline(offset || 1);
-        return;
-      }
-    }
-    if (this._buf.hasContent()) {
-      this.newline(1);
-    }
-  }
   _shouldPrintComment(comment, nextToken) {
     if (comment.ignore) return 0;
     if (this._printedComments.has(comment)) return 0;
@@ -633,13 +633,19 @@ class Printer {
   _printComment(comment, skipNewLines) {
     const noLineTerminator = this._noLineTerminator;
     const isBlockComment = comment.type === "CommentBlock";
-    const printNewLines = isBlockComment && skipNewLines !== 1 && !this._noLineTerminator;
+    const printNewLines = isBlockComment && skipNewLines !== 1 && !noLineTerminator;
     if (printNewLines && this._buf.hasContent() && skipNewLines !== 2) {
       this.newline(1);
     }
-    const lastCharCode = this.getLastChar();
-    if (lastCharCode !== 91 && lastCharCode !== 123 && lastCharCode !== 40) {
-      this.space();
+    switch (this.getLastChar(true)) {
+      case 47:
+        this._space();
+      case 91:
+      case 123:
+      case 40:
+        break;
+      default:
+        this.space();
     }
     let val;
     if (isBlockComment) {
@@ -651,12 +657,12 @@ class Printer {
           const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
           val = val.replace(newlineRegex, "\n");
         }
-        if (this.format.concise) {
+        if (this._flags & 4) {
           val = val.replace(/\n(?!$)/g, `\n`);
         } else {
           let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn();
-          if (this._shouldIndent(47) || this.format.retainLines) {
-            indentSize += this._getIndent();
+          if (this._shouldIndent() || this.format.retainLines) {
+            indentSize += this._indent;
           }
           val = val.replace(/\n(?!$)/g, `\n${" ".repeat(indentSize)}`);
         }
@@ -666,24 +672,10 @@ class Printer {
     } else {
       val = `/*${comment.value}*/`;
     }
-    if (this._endsWithDiv) this._space();
-    if (this.tokenMap) {
-      const {
-        _printSemicolonBeforeNextToken,
-        _printSemicolonBeforeNextNode
-      } = this;
-      this._printSemicolonBeforeNextToken = -1;
-      this._printSemicolonBeforeNextNode = -1;
-      this.source("start", comment.loc);
-      this._append(val, isBlockComment);
-      this._printSemicolonBeforeNextNode = _printSemicolonBeforeNextNode;
-      this._printSemicolonBeforeNextToken = _printSemicolonBeforeNextToken;
-    } else {
-      this.source("start", comment.loc);
-      this._append(val, isBlockComment);
-    }
+    this.source("start", comment.loc);
+    this._append(val, isBlockComment);
     if (!isBlockComment && !noLineTerminator) {
-      this.newline(1, true);
+      this._newline();
     }
     if (printNewLines && skipNewLines !== 3) {
       this.newline(1);
@@ -697,13 +689,15 @@ class Printer {
     const nodeEndLine = hasLoc ? nodeLoc.end.line : 0;
     let lastLine = 0;
     let leadingCommentNewline = 0;
-    const maybeNewline = this._noLineTerminator ? function () {} : this.newline.bind(this);
+    const {
+      _noLineTerminator,
+      _flags
+    } = this;
     for (let i = 0; i < len; i++) {
       const comment = comments[i];
       const shouldPrint = this._shouldPrintComment(comment, nextToken);
       if (shouldPrint === 2) {
-        hasLoc = false;
-        break;
+        return i === 0 ? 0 : 1;
       }
       if (hasLoc && comment.loc && shouldPrint === 1) {
         const commentStartLine = comment.loc.start.line;
@@ -718,25 +712,37 @@ class Printer {
             offset = commentStartLine - lastLine;
           }
           lastLine = commentEndLine;
-          maybeNewline(offset);
+          if (offset > 0 && !_noLineTerminator) {
+            this.newline(offset, _flags);
+          }
           this._printComment(comment, 1);
           if (i + 1 === len) {
-            maybeNewline(Math.max(nodeStartLine - lastLine, leadingCommentNewline));
+            const count = Math.max(nodeStartLine - lastLine, leadingCommentNewline);
+            if (count > 0 && !_noLineTerminator) {
+              this.newline(count, _flags);
+            }
             lastLine = nodeStartLine;
           }
         } else if (type === 1) {
           const offset = commentStartLine - (i === 0 ? nodeStartLine : lastLine);
           lastLine = commentEndLine;
-          maybeNewline(offset);
+          if (offset > 0 && !_noLineTerminator) {
+            this.newline(offset, _flags);
+          }
           this._printComment(comment, 1);
           if (i + 1 === len) {
-            maybeNewline(Math.min(1, nodeEndLine - lastLine));
+            const count = Math.min(1, nodeEndLine - lastLine);
+            if (count > 0 && !_noLineTerminator) {
+              this.newline(count, _flags);
+            }
             lastLine = nodeEndLine;
           }
         } else {
           const offset = commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine);
           lastLine = commentEndLine;
-          maybeNewline(offset);
+          if (offset > 0 && !_noLineTerminator) {
+            this.newline(offset, _flags);
+          }
           this._printComment(comment, 1);
         }
       } else {
@@ -748,9 +754,7 @@ class Printer {
           const singleLine = comment.loc ? comment.loc.start.line === comment.loc.end.line : !HAS_NEWLINE.test(comment.value);
           const shouldSkipNewline = singleLine && !isStatement(node) && !isClassBody(parent) && !isTSInterfaceBody(parent) && !isTSEnumMember(node);
           if (type === 0) {
-            this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction(parent, {
-              body: node
-            }) ? 1 : 0);
+            this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction(parent) && parent.body === node ? 1 : 0);
           } else if (shouldSkipNewline && type === 2) {
             this._printComment(comment, 1);
           } else {
@@ -766,15 +770,12 @@ class Printer {
     if (type === 2 && hasLoc && lastLine) {
       this._lastCommentLine = lastLine;
     }
+    return 2;
   }
 }
-Object.assign(Printer.prototype, generatorFunctions);
-{
-  (0, _deprecated.addDeprecatedGenerators)(Printer);
-}
 var _default = exports.default = Printer;
 function commaSeparator(occurrenceCount, last) {
-  this.token(",", false, occurrenceCount);
+  this.tokenChar(44, occurrenceCount);
   if (!last) this.space();
 }
 

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/source-map.js

@@ -15,7 +15,7 @@ class SourceMap {
     this._lastGenLine = 0;
     this._lastSourceLine = 0;
     this._lastSourceColumn = 0;
-    this._inputMap = void 0;
+    this._inputMap = null;
     const map = this._map = new _genMapping.GenMapping({
       sourceRoot: opts.sourceRoot
     });
@@ -56,7 +56,7 @@ class SourceMap {
       if (this._inputMap) {
         originalMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, {
           line,
-          column
+          column: column
         });
         if (!originalMapping.name && identifierNamePos) {
           const originalIdentifierMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, identifierNamePos);
@@ -66,6 +66,7 @@ class SourceMap {
         }
       } else {
         originalMapping = {
+          name: null,
           source: (filename == null ? void 0 : filename.replace(/\\/g, "/")) || this._sourceFileName,
           line: line,
           column: column

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/lib/token-map.js

@@ -22,7 +22,7 @@ class TokenMap {
       const indexes = this._getTokensIndexesOfNode(node);
       if (indexes.length > 0) this._nodesToTokenIndexes.set(node, indexes);
     });
-    this._tokensCache = null;
+    this._tokensCache.clear();
   }
   has(node) {
     return this._nodesToTokenIndexes.has(node);
@@ -55,11 +55,14 @@ class TokenMap {
   findMatching(node, test, occurrenceCount = 0) {
     const indexes = this._nodesToTokenIndexes.get(node);
     if (indexes) {
+      if (typeof test === "number") {
+        test = String.fromCharCode(test);
+      }
       let i = 0;
       const count = occurrenceCount;
       if (count > 1) {
         const cache = this._nodesOccurrencesCountCache.get(node);
-        if (cache && cache.test === test && cache.count < count) {
+        if ((cache == null ? void 0 : cache.test) === test && cache.count < count) {
           i = cache.i + 1;
           occurrenceCount -= cache.count + 1;
         }
@@ -103,6 +106,7 @@ class TokenMap {
     return this.matchesOriginal(tok, test);
   }
   _getTokensIndexesOfNode(node) {
+    var _node$declaration;
     if (node.start == null || node.end == null) return [];
     const {
       first,
@@ -110,7 +114,7 @@ class TokenMap {
     } = this._findTokensOfNode(node, 0, this._tokens.length - 1);
     let low = first;
     const children = childrenIterator(node);
-    if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") && node.declaration && node.declaration.type === "ClassDeclaration") {
+    if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") && ((_node$declaration = node.declaration) == null ? void 0 : _node$declaration.type) === "ClassDeclaration") {
       children.next();
     }
     const indexes = [];

node_modules/@babel/helper-module-transforms/node_modules/@babel/generator/package.json

@@ -1,70 +1,39 @@
 {
-  "_from": "@babel/generator@^7.28.3",
-  "_id": "@babel/generator@7.28.3",
-  "_inBundle": false,
-  "_integrity": "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==",
-  "_location": "/@babel/helper-module-transforms/@babel/generator",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "@babel/generator@^7.28.3",
-    "name": "@babel/generator",
-    "escapedName": "@babel%2fgenerator",
-    "scope": "@babel",
-    "rawSpec": "^7.28.3",
-    "saveSpec": null,
-    "fetchSpec": "^7.28.3"
-  },
-  "_requiredBy": [
-    "/@babel/helper-module-transforms/@babel/traverse"
-  ],
-  "_resolved": "https://registry.npmmirror.com/@babel/generator/-/generator-7.28.3.tgz",
-  "_shasum": "9626c1741c650cbac39121694a0f2d7451b8ef3e",
-  "_spec": "@babel/generator@^7.28.3",
-  "_where": "D:\\HTC\\program\\善行少年\\security-enterprise-admin\\node_modules\\@babel\\helper-module-transforms\\node_modules\\@babel\\traverse",
-  "author": {
-    "name": "The Babel Team",
-    "url": "https://babel.dev/team"
+  "name": "@babel/generator",
+  "version": "7.29.1",
+  "description": "Turns an AST into code.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
   },
-  "bugs": {
-    "url": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-generator"
   },
-  "bundleDependencies": false,
+  "homepage": "https://babel.dev/docs/en/next/babel-generator",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen",
+  "main": "./lib/index.js",
+  "files": [
+    "lib"
+  ],
   "dependencies": {
-    "@babel/parser": "^7.28.3",
-    "@babel/types": "^7.28.2",
+    "@babel/parser": "^7.29.0",
+    "@babel/types": "^7.29.0",
     "@jridgewell/gen-mapping": "^0.3.12",
     "@jridgewell/trace-mapping": "^0.3.28",
     "jsesc": "^3.0.2"
   },
-  "deprecated": false,
-  "description": "Turns an AST into code.",
   "devDependencies": {
-    "@babel/core": "^7.28.3",
-    "@babel/helper-fixtures": "^7.28.0",
-    "@babel/plugin-transform-typescript": "^7.28.0",
+    "@babel/core": "^7.29.0",
+    "@babel/helper-fixtures": "^7.28.6",
+    "@babel/plugin-transform-typescript": "^7.28.6",
     "@jridgewell/sourcemap-codec": "^1.5.3",
     "charcodes": "^0.2.0"
   },
   "engines": {
     "node": ">=6.9.0"
   },
-  "files": [
-    "lib"
-  ],
-  "homepage": "https://babel.dev/docs/en/next/babel-generator",
-  "license": "MIT",
-  "main": "./lib/index.js",
-  "name": "@babel/generator",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/babel/babel.git",
-    "directory": "packages/babel-generator"
-  },
-  "type": "commonjs",
-  "version": "7.28.3"
-}
+  "type": "commonjs"
+}

node_modules/@babel/helper-module-transforms/node_modules/@babel/helper-module-imports/package.json

@@ -1,60 +1,28 @@
 {
-  "_from": "@babel/helper-module-imports@^7.27.1",
-  "_id": "@babel/helper-module-imports@7.27.1",
-  "_inBundle": false,
-  "_integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
-  "_location": "/@babel/helper-module-transforms/@babel/helper-module-imports",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "@babel/helper-module-imports@^7.27.1",
-    "name": "@babel/helper-module-imports",
-    "escapedName": "@babel%2fhelper-module-imports",
-    "scope": "@babel",
-    "rawSpec": "^7.27.1",
-    "saveSpec": null,
-    "fetchSpec": "^7.27.1"
-  },
-  "_requiredBy": [
-    "/@babel/helper-module-transforms"
-  ],
-  "_resolved": "https://registry.npmmirror.com/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
-  "_shasum": "7ef769a323e2655e126673bb6d2d6913bbead204",
-  "_spec": "@babel/helper-module-imports@^7.27.1",
-  "_where": "D:\\HTC\\program\\善行少年\\security-enterprise-admin\\node_modules\\@babel\\helper-module-transforms",
-  "author": {
-    "name": "The Babel Team",
-    "url": "https://babel.dev/team"
-  },
-  "bugs": {
-    "url": "https://github.com/babel/babel/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "@babel/traverse": "^7.27.1",
-    "@babel/types": "^7.27.1"
-  },
-  "deprecated": false,
+  "name": "@babel/helper-module-imports",
+  "version": "7.28.6",
   "description": "Babel helper functions for inserting module loads",
-  "devDependencies": {
-    "@babel/core": "^7.27.1"
-  },
-  "engines": {
-    "node": ">=6.9.0"
-  },
+  "author": "The Babel Team (https://babel.dev/team)",
   "homepage": "https://babel.dev/docs/en/next/babel-helper-module-imports",
   "license": "MIT",
-  "main": "./lib/index.js",
-  "name": "@babel/helper-module-imports",
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/babel/babel.git",
+    "url": "https://github.com/babel/babel.git",
     "directory": "packages/babel-helper-module-imports"
   },
-  "type": "commonjs",
-  "version": "7.27.1"
-}
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/traverse": "^7.28.6",
+    "@babel/types": "^7.28.6"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.6"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}

node_modules/@babel/helper-module-transforms/node_modules/@babel/template/package.json

@@ -1,58 +1,27 @@
 {
-  "_from": "@babel/template@^7.27.2",
-  "_id": "@babel/template@7.27.2",
-  "_inBundle": false,
-  "_integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
-  "_location": "/@babel/helper-module-transforms/@babel/template",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "@babel/template@^7.27.2",
-    "name": "@babel/template",
-    "escapedName": "@babel%2ftemplate",
-    "scope": "@babel",
-    "rawSpec": "^7.27.2",
-    "saveSpec": null,
-    "fetchSpec": "^7.27.2"
-  },
-  "_requiredBy": [
-    "/@babel/helper-module-transforms/@babel/traverse"
-  ],
-  "_resolved": "https://registry.npmmirror.com/@babel/template/-/template-7.27.2.tgz",
-  "_shasum": "fa78ceed3c4e7b63ebf6cb39e5852fca45f6809d",
-  "_spec": "@babel/template@^7.27.2",
-  "_where": "D:\\HTC\\program\\善行少年\\security-enterprise-admin\\node_modules\\@babel\\helper-module-transforms\\node_modules\\@babel\\traverse",
-  "author": {
-    "name": "The Babel Team",
-    "url": "https://babel.dev/team"
-  },
-  "bugs": {
-    "url": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20template%22+is%3Aopen"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "@babel/code-frame": "^7.27.1",
-    "@babel/parser": "^7.27.2",
-    "@babel/types": "^7.27.1"
-  },
-  "deprecated": false,
+  "name": "@babel/template",
+  "version": "7.28.6",
   "description": "Generate an AST from a string template.",
-  "engines": {
-    "node": ">=6.9.0"
-  },
+  "author": "The Babel Team (https://babel.dev/team)",
   "homepage": "https://babel.dev/docs/en/next/babel-template",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20template%22+is%3Aopen",
   "license": "MIT",
-  "main": "./lib/index.js",
-  "name": "@babel/template",
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/babel/babel.git",
+    "url": "https://github.com/babel/babel.git",
     "directory": "packages/babel-template"
   },
-  "type": "commonjs",
-  "version": "7.27.2"
-}
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/code-frame": "^7.28.6",
+    "@babel/parser": "^7.28.6",
+    "@babel/types": "^7.28.6"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}

node_modules/@babel/helper-module-transforms/node_modules/@babel/traverse/lib/cache.js

@@ -29,7 +29,6 @@ function getCachedPaths(path) {
   return pathsCache.get(parent);
 }
 function getOrCreateCachedPaths(node, parentPath) {
-  ;
   let paths = pathsCache.get(node);
   if (!paths) pathsCache.set(node, paths = new Map());
   return paths;