chore：更换到主分支

.env

@@ -0,0 +1,5 @@
+# public path
+VITE_PUBLIC_PATH = /
+
+# Cross-domain proxy, you can configure multiple
+VITE_PROXY = [ ["/api", "http://127.0.0.1:3000" ] ]

.env.development

@@ -0,0 +1,11 @@
+# port
+VITE_PORT = 3001
+
+# open
+VITE_OPEN = false
+
+# public path
+VITE_PUBLIC_PATH = /
+
+# Cross-domain proxy, you can configure multiple
+VITE_PROXY = [ ["/api", "http://127.0.0.1:3000" ] ]

.env.production

@@ -0,0 +1,2 @@
+# public path
+VITE_PUBLIC_PATH = /manages/

.gitignore

@@ -0,0 +1,4 @@
+/node_modules
+/dist
+.DS_Store
+src/.DS_Store

README.md

@@ -1,17 +1,56 @@
-# 后端管理项目文档
+# Vue3.0后台管理系统
+### 功能已开发完毕，新需求请提issues  
+
+## 知识库地址
+
+帮助你获取最新的 API  
+[vue3.0 中文文档地址]: https://vue3js.cn/docs/zh/  
+[element-plus 中文文档地址]: https://element-plus.org/#/zh-CN  
+[composition-Api 中文文档地址]: https://composition-api.vuejs.org/zh/  
+[vue-router-next 文档地址]: https://next.router.vuejs.org/  
+[next.vuex 文档地址]: https://next.vuex.vuejs.org/  
+[vite 源码]: https://github.com/vitejs/vite  
+[vite 文档地址]: https://vitejs.dev/  
+[vite 中文文档地址（非官方版本）]: https://vite-design.surge.sh/guide/chinese-doc.html  
+[vue-i18n-next]: https://vue-i18n-next.intlify.dev/  
+[composition-api-vue-i18n-next]: https://vue-i18n-next.intlify.dev/advanced/composition.html#local-scope  
 
 ## 安装依赖
+
 ```
 npm install
 ```
 
-## 文档启动
+## 项目运行
+
 ```
-npm run docs
+npm run serve
 ```
 
-## 文档打包
+## 项目打包
+
 ```
-npm run docs:build
+npm run build
 ```
-打包后会在.vitepress文件夹下生成dist目录
+
+## 注意点
+
+请先全局安装 typescript、ts-node、vite 如安装请忽略
+
+```
+npm install -g typescript
+npm install -g ts-node
+npm install -g create-vite-app
+```
+
+坑位  
+1.  
+path模块线上部署会遇到process is undefined问题  
+解决办法：在源码中开头加入window.process = {}  
+issues：https://github.com/jinder/path/issues/7  
+2.  
+运行项目时控制台报NODE_ENV not found  
+解决办法：删除node_modules和package-lock.json文件，重新npm install  
+3.  
+运行项目会感觉菜单切换比较卡，这个原因是使用route造成的，watch(route)是隐式的{ deep: true }，最好使用watchEffect  
+issues：https://github.com/vuejs/vue-next/issues/2027  

babel.config.js

@@ -0,0 +1,6 @@
+
+const productPlugins = []
+process.env.NODE_ENV === "production" && productPlugins.push("transform-remove-console")
+module.exports = {
+  plugins: [...productPlugins],
+}

build/proxy.ts

@@ -0,0 +1,19 @@
+type ProxyItem = [string, string];
+
+type ProxyList = ProxyItem[];
+
+const regExps = (value: string,reg: string): string => {
+  return value.replace(new RegExp(reg, 'g'), '');
+}
+
+export function createProxy(list: ProxyList = []) {
+  const ret: any = {};
+  for (const [prefix, target] of list) {
+    ret[prefix] = {
+      target: target,
+      changeOrigin: true,
+      rewrite: (path:string) => regExps(path, prefix)
+    };
+  }
+  return ret;
+}

build/utils.ts

@@ -0,0 +1,38 @@
+import dotenv from 'dotenv';
+
+export interface ViteEnv {
+  VITE_PORT: number;
+  VITE_OPEN: boolean;
+  VITE_USE_MOCK: boolean;
+  VITE_PUBLIC_PATH: string;
+  VITE_PROXY: [string, string][];
+}
+
+export function loadEnv(): ViteEnv {
+  const env = process.env.NODE_ENV;
+  const ret: any = {};
+  const envList = [`.env.${env}.local`, `.env.${env}`, '.env.local', '.env', ,]
+  envList.forEach((e) => {
+    dotenv.config({
+      path: e,
+    });
+  });
+  for (const envName of Object.keys(process.env)) {
+    let realName = (process.env as any)[envName].replace(/\\n/g, '\n');
+    realName = realName === 'true' ? true : realName === 'false' ? false : realName;
+    if (envName === 'VITE_PORT') {
+      realName = Number(realName);
+    }
+    if (envName === 'VITE_OPEN') {
+      realName = Boolean(realName);
+    }
+    if (envName === 'VITE_PROXY') {
+      try {
+        realName = JSON.parse(realName);
+      } catch (error) { }
+    }
+    ret[envName] = realName;
+    process.env[envName] = realName;
+  }
+  return ret;
+}

deploy.sh

@@ -1,27 +0,0 @@
-#!/usr/bin/env sh
-
-# 确保脚本抛出遇到的错误
-set -e
-
-# 生成静态文件
-npm run docs:build
-
-# 进入生成的文件夹
-cd docs/.vitepress/dist
-
-touch .nojekyll
-
-# 如果是发布到自定义域名
-# echo 'www.example.com' > CNAME
-
-git init
-git add -A
-git commit -m 'deploy'
-
-# 如果发布到 https://<USERNAME>.github.io
-git push -f git@github.com:xiaoxian521/xiaoxian521.github.io.git master:main
-
-# 如果发布到 https://<USERNAME>.github.io/<REPO>
-# git push -f git@github.com:<USERNAME>/<REPO>.git master:gh-pages
-
-cd -

docs/.vitepress/config.js

@@ -1,47 +0,0 @@
-const config = {
-  title: '简约而不简单的文档',
-  themeConfig: {
-    repo: 'https://github.com/xiaoxian521',
-    docsDir: 'docs',
-    locales: {
-      '/': {
-        lang: 'zh-CN',
-        nav: [
-          { text: '书写规范', link: '/zh/standard/' },
-          { text: '插件分享', link: '/zh/plugs/' },
-        ],
-        sidebar: [
-          {
-            text: '简介',
-            children: [
-              { text: '项目描述', link: '/zh/introduction/description' },
-              { text: '开源精神', link: '/zh/introduction/openSource' },
-              { text: '贡献者', link: '/zh/introduction/contributor' },
-              { text: '设计图及UI规范', link: '/zh/introduction/ui' },
-            ],
-          },
-        ],
-      },
-      '/en/': {
-        lang: 'en-US',
-        nav: [
-          { text: 'Standard', link: '/en/standard/' },
-          { text: 'PlugsShare', link: '/zh/plugs/' },
-        ],
-        sidebar: [
-          {
-            text: 'introduction',
-            children: [
-              { text: 'description', link: '/en/introduction/description' },
-              { text: 'openSource', link: '/en/introduction/openSource' },
-              { text: 'contributor', link: '/en/introduction/contributor' },
-              { text: 'DesignDrawing、UISpecification', link: '/en/introduction/ui' },
-            ],
-          },
-        ],
-      },
-    }
-  }
-}
-
-module.exports = config

docs/en/index.md

@@ -1,8 +0,0 @@
-:tada: :100:
-::: tip
-Welcome to join the open source family. Let's look at the document on the left and explore it! :heart_eyes_cat:
-:::
-
-::: warning
-This document is written by vitepress. As vitepress is being improved, it is normal to encounter small bugs in browsing :joy:
-:::

docs/en/introduction/contributor.md

@@ -1,33 +0,0 @@
-# contributor
-
-:tada: :100:
-::: tip
-```
-和尚 
-```
-GitHub：https://github.com/xiaoxian521
-:::
-
-:tada: :100:
-::: tip
-```
-chenxi 
-```
-GitHub：https://github.com/chenxi19950223/wxnode
-:::
-
-:tada: :100:
-::: tip
-```
-ChaoSuperScholar 
-```
-GitHub：https://github.com/ChaoSuperScholar/smallhouse
-:::
-
-:tada: :100:
-::: tip
-```
-Yinwenxu 
-```
-GitHub：https://github.com/Yinwenxu/Student
-:::

docs/en/introduction/description.md

@@ -1,8 +0,0 @@
-# description
-
-### A system of adding, deleting, modifying and checking based on TS
-
-## Main Technologies:
-| front end | after end | database | 
-| -- |:--:| -- |
-| Vue3.0、React、Angular | Node | MySQL、MongoDB、SQlite | 

docs/en/introduction/openSource.md

@@ -1,26 +0,0 @@
-# openSource
-
-## Why contribute to open source?
-
-### Improve software you rely on
-Lots of open source contributors start by being users of software they contribute to. When you find a bug in an open source software you use, you may want to look at the source to see if you can patch it yourself. If that’s the case, then contributing the patch back is the best way to ensure that your friends (and yourself when you update to the next release) will be able to benefit from it.
-
-### Improve existing skills
-Whether it’s coding, user interface design, graphic design, writing, or organizing, if you’re looking for practice, there’s a task for you on an open source project.
-
-### Meet people who are interested in similar things
-Open source projects with warm, welcoming communities keep people coming back for years. Many people form lifelong friendships through their participation in open source, whether it’s running into each other at conferences or late night online chats about burritos.
-
-### Find mentors and teach others
-Working with others on a shared project means you’ll have to explain how you do things, as well as ask other people for help. The acts of learning and teaching can be a fulfilling activity for everyone involved.
-
-### Build public artifacts that help you grow a reputation (and a career)
-By definition, all of your open source work is public, which means you get free examples to take anywhere as a demonstration of what you can do.
-
-### Learn people skills
-Open source offers opportunities to practice leadership and management skills, such as resolving conflicts, organizing teams of people, and prioritizing work.
-
-### It’s empowering to be able to make changes, even small ones
-You don’t have to become a lifelong contributor to enjoy participating in open source. Have you ever seen a typo on a website, and wished someone would fix it? On an open source project, you can do just that. Open source helps people feel agency over their lives and how they experience the world, and that in itself is gratifying.
-
-### You can learn about the open source spirit here: http://opensource.guide/

docs/en/introduction/ui.md

@@ -1,15 +0,0 @@
-## UI specification
-#### 1. A good "product" reflects your cultural and aesthetic details, ha ha, try to unify the page effect! :grin:
-#### 2. Using the unified icon, I will pull you into the corresponding iconfont project :kissing_heart:
-
-## Design drawings
-
-![Screen shot](./images/bg.png)
-#### Background image (right click to save as picture)
-![Screen shot](./images/login.png)
-#### Login page
-![Screen shot](./images/register.png)
-#### Register page
-
-## Project reference address (UI appearance)
-http://beautiful.panm.cn/vue-admin-beautiful-pro/?hmsr=github&hmpl=&hmcu=&hmkw=&hmci=#/login?redirect=%2Findex

docs/en/plugs/index.md

@@ -1,37 +0,0 @@
-## 1. VsCode Plugs
-
-please install TSLint、Vetur、vscode-icons、ES7 React
-
-## 2. Quick generation of code fragment by vscode
-Ctrl+Shift+P Check configure user code fragment search vue.json Copy the code below Enter Vue in the .vue file and press enter
-```
-{
-	"Vue3.0Quick template generation": {
-		"prefix": "Vue3.0",
-		"body": [
-			"<template>",
-			"\t<div>\n",
-			"\t</div>",
-			"</template>\n",
-			"<script lang='ts'>",
-			"export default {",
-			"\tsetup(){",
-			"\t\treturn{\n\n\t\t}",
-			"\t},",
-			"}",
-			"</script>\n",
-			"<style scoped>\n",
-			"</style>",
-			"$2"
-		],
-		"description": "Vue3.0"
-	}
-}
-```
-![Screen shot](./images/snip.gif)
-## 3. hyper
-
-![Screen shot](./images/hyper.gif)
-
-A beautification command panel plug-in, based on TS, version: windows, MAC, Linux  
-Download address: https://hyper.is/#installation

docs/en/standard/index.md

@@ -1,16 +0,0 @@
-# Writing Standard
-
-:tada: :100:
-::: tip
-① Interface documents use swagger
-② The author must strictly abide by the tslint writing rules in the project
-③ The author must strictly follow the code naming semantics and improve the readability of the code
-④ The author must go through the unit test to ensure the usability of the code
-⑤ Typescript must be used completely to ensure code rigor and maintainability
-⑥ If the code submitted by the writer conflicts, it must be resolved first. In pushing, GIT push - f origin branch is strictly prohibited
-⑦ Put Vue code under Vue TS branch, react code under react TS branch and angular code under angular TS branch
-:::
-
-::: danger
-Managers are not allowed to push or merge the code directly into the main branch. The main branch is only used to store the back-end code and document code. In this way, it avoids the need to wait for a long time to pull the code for the first time. After the code is written as a whole, it will be merged into the main branch
-:::

docs/index.md

@@ -1,12 +0,0 @@
-:tada: :100:
-::: tip
-欢迎加入开源大家庭，下面让我们来查看左侧文档进行相关探索吧！:heart_eyes_cat:
-:::
-
-::: warning
-本文档采用vitepress编写，因vitepress正在完善中，浏览中如遇小bug是正常现象。 :joy:
-:::
-
-::: danger
-开发者可能都是比较忙的，感谢付出你的时间来开发此项目，进程会慢，但一定会做完，加油！ :thumbsup:
-:::

docs/zh/introduction/contributor.md

@@ -1,32 +0,0 @@
-# 贡献者
-
-:tada: :100:
-::: tip
-```
-和尚 
-```
-GitHub：https://github.com/xiaoxian521
-:::
-
-:tada: :100:
-::: tip
-```
-chenxi 
-```
-GitHub：https://github.com/chenxi19950223/wxnode
-:::
-
-:tada: :100:
-::: tip
-```
-ChaoSuperScholar 
-```
-GitHub：https://github.com/ChaoSuperScholar/smallhouse
-:::
-
-:tada: :100:
-::: tip
-```
-Yinwenxu 
-```
-:::

docs/zh/introduction/description.md

@@ -1,8 +0,0 @@
-# 项目描述
-
-### 一套整体基于TS的增删改查系统
-
-## 主要技术：
-| 前端 | 后端 | 数据库 | 
-| -- |:--:| -- |
-| Vue3.0、React、Angular | Node | MySQL、MongoDB、SQlite | 

docs/zh/introduction/openSource.md

@@ -1,23 +0,0 @@
-# 开源精神
-
-## 为什么要为开源做贡献？
-
-### 巩固现有技能
-无论是撰写代码、设计用户界面、图形设计、撰写文档、亦或是组织活动，假如你有实践的愿望，你总能在开源项目中找到自己的位置。
-
-### 遇见那些和你”臭味相投”的人
-开源项目一般都会有一个和谐、热心的社区，以让大家团结一致。实际上，开源界经常发生这样的情形，很多人的深厚友谊都是通过共同参与开源所建立起来的，至于具体的方式，可能是在一次技术研讨会上相谈甚欢，也可能是一直在聊天室中探讨问题。
-
-### 寻找导师，并且尝试帮助他人
-和他人共同在一个共享的项目下工作，这意味着需要向他人解释清楚自己是如何做的，同理，也需要向他人求助，询问别人是如何做的。相互学习和彼此教学对于每位参与者都能满载而归。
-
-### 在公众间建立你的声誉（职业口碑）
-根据开源的定义，你在开源下所有的工作都是公开的，这也就意味着开源项目是一个很好展示你实力的地方。
-
-### 学习领导和管理的艺术
-开源为实践领导力和管理技能提供了很好的机会，比如解决冲突、组织团队、工作的优先级排列。
-
-### 鼓励作出改变，哪怕改变是很微小的
-在开源的世界里，作出贡献的不一定非得是花了很长时间拥有大量经验的人。你是否遇到过浏览某些网站发现有拼写错误，希望有人能修改它？其实，在开源的项目中，你只需要做就可以了。没有那么多的顾忌，开源让人们在很舒服的状态做事，而这才是这个世界应有的体验。
-
-### 关于开源精神你可以来这里学习：http://opensource.guide/zh-hans/

docs/zh/introduction/ui.md

@@ -1,15 +0,0 @@
-## UI规范
-#### 1. 一款好的“产品”体现了您的文化、审美底蕴，哈哈，尽量页面效果统一！ :grin:
-#### 2. 使用统一的icon，我会拉你们进对应的iconfont项目！ :kissing_heart:
-
-## 设计图
-
-![Screen shot](./images/bg.png)
-#### 背景图（可右键另存为图片）
-![Screen shot](./images/login.png)
-#### 登录页
-![Screen shot](./images/register.png)
-#### 注册页
-
-## 项目参考地址（UI外观）
-http://beautiful.panm.cn/vue-admin-beautiful-pro/?hmsr=github&hmpl=&hmcu=&hmkw=&hmci=#/login?redirect=%2Findex

docs/zh/plugs/index.md

@@ -1,38 +0,0 @@
-## 1. VsCode插件
-
-请安装TSLint、Vetur、vscode-icons、ES7 React
-
-## 2. VsCode快速生成代码片段
-Ctrl+Shift+P 选中配置用户代码片段 搜索vue.json，将下面代码复制进去，在.vue文件输入vue回车即可
-```
-{
-	"Vue3.0快速生成模板": {
-		"prefix": "Vue3.0",
-		"body": [
-			"<template>",
-			"\t<div>\n",
-			"\t</div>",
-			"</template>\n",
-			"<script lang='ts'>",
-			"export default {",
-			"\tsetup(){",
-			"\t\treturn{\n\n\t\t}",
-			"\t},",
-			"}",
-			"</script>\n",
-			"<style scoped>\n",
-			"</style>",
-			"$2"
-		],
-		"description": "Vue3.0"
-	}
-}
-```
-![Screen shot](./images/snip.gif)
-
-## 3. hyper
-
-![Screen shot](./images/hyper.gif)
-
-一款美化命令面板插件，基于TS，版本：windows、mac、linux  
-下载地址：https://hyper.is/#installation

docs/zh/standard/index.md

@@ -1,16 +0,0 @@
-# 书写规范
-
-:tada: :100:
-::: tip
-① 接口文档使用Swagger  
-② 编写者必须严格遵守项目中tslint编写规则  
-③ 编写者必须严格遵循代码命名语义化、提高代码可读性  
-④ 编写者编写代码完毕必须经过单元测试，保证代码可用性  
-⑤ 编写必须完全使用TypeScript，保证代码严谨性、可维护性  
-⑥ 编写者提交代码发生冲突，必须先解决，在推送，严禁使用git push -f origin 分支  
-⑦ vue代码请放在vue-ts分支下，react代码请放在react-ts分支下，angular代码请放在angular-ts分支下
-:::
-
-::: danger
-管理者严禁将代码直接推送或合并到main分支，main分支只用来存放后端代码和文档代码，这样避免了首次拉取代码需要等很长时间，代码整体编写完毕后会合并到main分支
-:::

index.html

@@ -0,0 +1,262 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8">
+  <link rel="icon" href="/favicon.ico" />
+  <link rel="stylesheet" href="/iconfont.css" />
+  <link rel="stylesheet" href="/animate.css">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>后台管理系统</title>
+  <script src="https://cdn.bootcdn.net/ajax/libs/Sortable/1.13.0/Sortable.js"></script>
+  <script>
+    window.process = {}
+  </script>
+</head>
+<body>
+  <div id="app">
+     <style>
+        html,
+        body,
+        #app {
+          height: 100%;
+          margin: 0px;
+          padding: 0px;
+        }
+
+        .chromeframe {
+          margin: 0.2em 0;
+          background: #ccc;
+          color: #000;
+          padding: 0.2em 0;
+        }
+
+        #loader-wrapper {
+          position: fixed;
+          top: 0;
+          left: 0;
+          width: 100%;
+          height: 100%;
+          z-index: 999999;
+        }
+
+        #loader {
+          display: block;
+          position: relative;
+          left: 50%;
+          top: 50%;
+          width: 150px;
+          height: 150px;
+          margin: -75px 0 0 -75px;
+          border-radius: 50%;
+          border: 3px solid transparent;
+          /* COLOR 1 */
+          border-top-color: #FFF;
+          -webkit-animation: spin 2s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          -ms-animation: spin 2s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          -moz-animation: spin 2s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          -o-animation: spin 2s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          animation: spin 2s linear infinite;
+          /* Chrome, Firefox 16+, IE 10+, Opera */
+          z-index: 1001;
+        }
+
+        #loader:before {
+          content: "";
+          position: absolute;
+          top: 5px;
+          left: 5px;
+          right: 5px;
+          bottom: 5px;
+          border-radius: 50%;
+          border: 3px solid transparent;
+          /* COLOR 2 */
+          border-top-color: #FFF;
+          -webkit-animation: spin 3s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          -moz-animation: spin 3s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          -o-animation: spin 3s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          -ms-animation: spin 3s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          animation: spin 3s linear infinite;
+          /* Chrome, Firefox 16+, IE 10+, Opera */
+        }
+
+        #loader:after {
+          content: "";
+          position: absolute;
+          top: 15px;
+          left: 15px;
+          right: 15px;
+          bottom: 15px;
+          border-radius: 50%;
+          border: 3px solid transparent;
+          border-top-color: #FFF;
+          /* COLOR 3 */
+          -moz-animation: spin 1.5s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          -o-animation: spin 1.5s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          -ms-animation: spin 1.5s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          -webkit-animation: spin 1.5s linear infinite;
+          /* Chrome, Opera 15+, Safari 5+ */
+          animation: spin 1.5s linear infinite;
+          /* Chrome, Firefox 16+, IE 10+, Opera */
+        }
+
+        @-webkit-keyframes spin {
+          0% {
+            -webkit-transform: rotate(0deg);
+            /* Chrome, Opera 15+, Safari 3.1+ */
+            -ms-transform: rotate(0deg);
+            /* IE 9 */
+            transform: rotate(0deg);
+            /* Firefox 16+, IE 10+, Opera */
+          }
+
+          100% {
+            -webkit-transform: rotate(360deg);
+            /* Chrome, Opera 15+, Safari 3.1+ */
+            -ms-transform: rotate(360deg);
+            /* IE 9 */
+            transform: rotate(360deg);
+            /* Firefox 16+, IE 10+, Opera */
+          }
+        }
+
+        @keyframes spin {
+          0% {
+            -webkit-transform: rotate(0deg);
+            /* Chrome, Opera 15+, Safari 3.1+ */
+            -ms-transform: rotate(0deg);
+            /* IE 9 */
+            transform: rotate(0deg);
+            /* Firefox 16+, IE 10+, Opera */
+          }
+
+          100% {
+            -webkit-transform: rotate(360deg);
+            /* Chrome, Opera 15+, Safari 3.1+ */
+            -ms-transform: rotate(360deg);
+            /* IE 9 */
+            transform: rotate(360deg);
+            /* Firefox 16+, IE 10+, Opera */
+          }
+        }
+
+        #loader-wrapper .loader-section {
+          position: fixed;
+          top: 0;
+          width: 51%;
+          height: 100%;
+          background: #5d94f8;
+          /* Old browsers */
+          z-index: 1000;
+          -webkit-transform: translateX(0);
+          /* Chrome, Opera 15+, Safari 3.1+ */
+          -ms-transform: translateX(0);
+          /* IE 9 */
+          transform: translateX(0);
+          /* Firefox 16+, IE 10+, Opera */
+        }
+
+        #loader-wrapper .loader-section.section-left {
+          left: 0;
+        }
+
+        #loader-wrapper .loader-section.section-right {
+          right: 0;
+        }
+
+        /* Loaded */
+        .loaded #loader-wrapper .loader-section.section-left {
+          -webkit-transform: translateX(-100%);
+          /* Chrome, Opera 15+, Safari 3.1+ */
+          -ms-transform: translateX(-100%);
+          /* IE 9 */
+          transform: translateX(-100%);
+          /* Firefox 16+, IE 10+, Opera */
+          -webkit-transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
+          transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
+        }
+
+        .loaded #loader-wrapper .loader-section.section-right {
+          -webkit-transform: translateX(100%);
+          /* Chrome, Opera 15+, Safari 3.1+ */
+          -ms-transform: translateX(100%);
+          /* IE 9 */
+          transform: translateX(100%);
+          /* Firefox 16+, IE 10+, Opera */
+          -webkit-transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
+          transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
+        }
+
+        .loaded #loader {
+          opacity: 0;
+          -webkit-transition: all 0.3s ease-out;
+          transition: all 0.3s ease-out;
+        }
+
+        .loaded #loader-wrapper {
+          visibility: hidden;
+          -webkit-transform: translateY(-100%);
+          /* Chrome, Opera 15+, Safari 3.1+ */
+          -ms-transform: translateY(-100%);
+          /* IE 9 */
+          transform: translateY(-100%);
+          /* Firefox 16+, IE 10+, Opera */
+          -webkit-transition: all 0.3s 1s ease-out;
+          transition: all 0.3s 1s ease-out;
+        }
+
+        /* JavaScript Turned Off */
+        .no-js #loader-wrapper {
+          display: none;
+        }
+
+        .no-js h1 {
+          color: #222222;
+        }
+
+        #loader-wrapper .load_title {
+          font-family: 'Open Sans';
+          color: #FFF;
+          font-size: 19px;
+          width: 100%;
+          text-align: center;
+          z-index: 9999999999999;
+          position: absolute;
+          top: 60%;
+          opacity: 1;
+          line-height: 30px;
+        }
+
+        #loader-wrapper .load_title span {
+          font-weight: normal;
+          font-style: italic;
+          font-size: 13px;
+          color: #FFF;
+          opacity: 0.5;
+        }
+    </style>
+    <div id="loader-wrapper">
+      <div id="loader"></div>
+      <div class="loader-section section-left"></div>
+      <div class="loader-section section-right"></div>
+      <div class="load_title">加载中,请耐心等待...
+        <br>
+        <span id="version">V0.0.1</span>
+      </div>
+    </div>
+  </div>
+  <script type="module" src="/src/main.ts"></script>
+</body>
+
+</html>

node_modules/.bin/esparse

@@ -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/../esprima/bin/esparse.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../esprima/bin/esparse.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/esparse.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\esprima\bin\esparse.js" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/esparse.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../esprima/bin/esparse.js" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../esprima/bin/esparse.js" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/esvalidate

@@ -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/../esprima/bin/esvalidate.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../esprima/bin/esvalidate.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/esvalidate.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\esprima\bin\esvalidate.js" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/esvalidate.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../esprima/bin/esvalidate.js" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../esprima/bin/esvalidate.js" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/is-docker

@@ -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/../is-docker/cli.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../is-docker/cli.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/is-docker.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\is-docker\cli.js" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/is-docker.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../is-docker/cli.js" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../is-docker/cli.js" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

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.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\js-yaml\bin\js-yaml.js" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/js-yaml.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../js-yaml/bin/js-yaml.js" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../js-yaml/bin/js-yaml.js" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/markdown-it

@@ -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/../markdown-it/bin/markdown-it.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../markdown-it/bin/markdown-it.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/markdown-it.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\markdown-it\bin\markdown-it.js" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/markdown-it.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../markdown-it/bin/markdown-it.js" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../markdown-it/bin/markdown-it.js" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/node-which

@@ -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/../which/bin/node-which" "$@"
-  ret=$?
-else 
-  node  "$basedir/../which/bin/node-which" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/node-which.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\which\bin\node-which" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/node-which.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../which/bin/node-which" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../which/bin/node-which" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/terser

@@ -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/../terser/bin/terser" "$@"
-  ret=$?
-else 
-  node  "$basedir/../terser/bin/terser" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/terser.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\terser\bin\terser" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/terser.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../terser/bin/terser" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../terser/bin/terser" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/vitepress

@@ -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/../vitepress/bin/vitepress.js" "$@"
-  ret=$?
-else 
-  node  "$basedir/../vitepress/bin/vitepress.js" "$@"
-  ret=$?
-fi
-exit $ret

node_modules/.bin/vitepress.cmd

@@ -1,17 +0,0 @@
-@ECHO off
-SETLOCAL
-CALL :find_dp0
-
-IF EXIST "%dp0%\node.exe" (
-  SET "_prog=%dp0%\node.exe"
-) ELSE (
-  SET "_prog=node"
-  SET PATHEXT=%PATHEXT:;.JS;=;%
-)
-
-"%_prog%"  "%dp0%\..\vitepress\bin\vitepress.js" %*
-ENDLOCAL
-EXIT /b %errorlevel%
-:find_dp0
-SET dp0=%~dp0
-EXIT /b

node_modules/.bin/vitepress.ps1

@@ -1,18 +0,0 @@
-#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-}
-$ret=0
-if (Test-Path "$basedir/node$exe") {
-  & "$basedir/node$exe"  "$basedir/../vitepress/bin/vitepress.js" $args
-  $ret=$LASTEXITCODE
-} else {
-  & "node$exe"  "$basedir/../vitepress/bin/vitepress.js" $args
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.vite_opt_cache/hash

@@ -1 +0,0 @@
-Q2anvQHGddPtypewx/fx89wZxo4=

node_modules/@babel/code-frame/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2014-present Sebastian McKenzie and other contributors
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/code-frame/README.md

@@ -1,19 +0,0 @@
-# @babel/code-frame
-
-> Generate errors that contain a code frame that point to source locations.
-
-See our website [@babel/code-frame](https://babeljs.io/docs/en/next/babel-code-frame.html) for more information.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/code-frame
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/code-frame --dev
-```

node_modules/@babel/code-frame/lib/index.js

@@ -1,167 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.codeFrameColumns = codeFrameColumns;
-exports.default = _default;
-
-var _highlight = _interopRequireWildcard(require("@babel/highlight"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-let deprecationWarningShown = false;
-
-function getDefs(chalk) {
-  return {
-    gutter: chalk.grey,
-    marker: chalk.red.bold,
-    message: chalk.red.bold
-  };
-}
-
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-
-function getMarkerLines(loc, source, opts) {
-  const startLoc = Object.assign({
-    column: 0,
-    line: -1
-  }, loc.start);
-  const endLoc = Object.assign({}, startLoc, loc.end);
-  const {
-    linesAbove = 2,
-    linesBelow = 3
-  } = opts || {};
-  const startLine = startLoc.line;
-  const startColumn = startLoc.column;
-  const endLine = endLoc.line;
-  const endColumn = endLoc.column;
-  let start = Math.max(startLine - (linesAbove + 1), 0);
-  let end = Math.min(source.length, endLine + linesBelow);
-
-  if (startLine === -1) {
-    start = 0;
-  }
-
-  if (endLine === -1) {
-    end = source.length;
-  }
-
-  const lineDiff = endLine - startLine;
-  const markerLines = {};
-
-  if (lineDiff) {
-    for (let i = 0; i <= lineDiff; i++) {
-      const lineNumber = i + startLine;
-
-      if (!startColumn) {
-        markerLines[lineNumber] = true;
-      } else if (i === 0) {
-        const sourceLength = source[lineNumber - 1].length;
-        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
-      } else if (i === lineDiff) {
-        markerLines[lineNumber] = [0, endColumn];
-      } else {
-        const sourceLength = source[lineNumber - i].length;
-        markerLines[lineNumber] = [0, sourceLength];
-      }
-    }
-  } else {
-    if (startColumn === endColumn) {
-      if (startColumn) {
-        markerLines[startLine] = [startColumn, 0];
-      } else {
-        markerLines[startLine] = true;
-      }
-    } else {
-      markerLines[startLine] = [startColumn, endColumn - startColumn];
-    }
-  }
-
-  return {
-    start,
-    end,
-    markerLines
-  };
-}
-
-function codeFrameColumns(rawLines, loc, opts = {}) {
-  const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
-  const chalk = (0, _highlight.getChalk)(opts);
-  const defs = getDefs(chalk);
-
-  const maybeHighlight = (chalkFn, string) => {
-    return highlighted ? chalkFn(string) : string;
-  };
-
-  const lines = rawLines.split(NEWLINE);
-  const {
-    start,
-    end,
-    markerLines
-  } = getMarkerLines(loc, lines, opts);
-  const hasColumns = loc.start && typeof loc.start.column === "number";
-  const numberMaxWidth = String(end).length;
-  const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
-  let frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => {
-    const number = start + 1 + index;
-    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
-    const gutter = ` ${paddedNumber} | `;
-    const hasMarker = markerLines[number];
-    const lastMarkerLine = !markerLines[number + 1];
-
-    if (hasMarker) {
-      let markerLine = "";
-
-      if (Array.isArray(hasMarker)) {
-        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
-        const numberOfMarkers = hasMarker[1] || 1;
-        markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
-
-        if (lastMarkerLine && opts.message) {
-          markerLine += " " + maybeHighlight(defs.message, opts.message);
-        }
-      }
-
-      return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
-    } else {
-      return ` ${maybeHighlight(defs.gutter, gutter)}${line}`;
-    }
-  }).join("\n");
-
-  if (opts.message && !hasColumns) {
-    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
-  }
-
-  if (highlighted) {
-    return chalk.reset(frame);
-  } else {
-    return frame;
-  }
-}
-
-function _default(rawLines, lineNumber, colNumber, opts = {}) {
-  if (!deprecationWarningShown) {
-    deprecationWarningShown = true;
-    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
-
-    if (process.emitWarning) {
-      process.emitWarning(message, "DeprecationWarning");
-    } else {
-      const deprecationError = new Error(message);
-      deprecationError.name = "DeprecationWarning";
-      console.warn(new Error(message));
-    }
-  }
-
-  colNumber = Math.max(colNumber, 0);
-  const location = {
-    start: {
-      column: colNumber,
-      line: lineNumber
-    }
-  };
-  return codeFrameColumns(rawLines, location, opts);
-}

node_modules/@babel/code-frame/package.json

@@ -1,62 +0,0 @@
-{
-  "_args": [
-    [
-      "@babel/code-frame@7.10.4",
-      "J:\\Github\\CURD-TS"
-    ]
-  ],
-  "_development": true,
-  "_from": "@babel/code-frame@7.10.4",
-  "_id": "@babel/code-frame@7.10.4",
-  "_inBundle": false,
-  "_integrity": "sha1-Fo2ho26Q2miujUnA8bSMfGJJITo=",
-  "_location": "/@babel/code-frame",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "@babel/code-frame@7.10.4",
-    "name": "@babel/code-frame",
-    "escapedName": "@babel%2fcode-frame",
-    "scope": "@babel",
-    "rawSpec": "7.10.4",
-    "saveSpec": null,
-    "fetchSpec": "7.10.4"
-  },
-  "_requiredBy": [
-    "/parse-json",
-    "/rollup-plugin-terser"
-  ],
-  "_resolved": "http://192.168.250.101:4873/@babel%2fcode-frame/-/code-frame-7.10.4.tgz",
-  "_spec": "7.10.4",
-  "_where": "J:\\Github\\CURD-TS",
-  "author": {
-    "name": "Sebastian McKenzie",
-    "email": "sebmck@gmail.com"
-  },
-  "bugs": {
-    "url": "https://github.com/babel/babel/issues"
-  },
-  "dependencies": {
-    "@babel/highlight": "^7.10.4"
-  },
-  "description": "Generate errors that contain a code frame that point to source locations.",
-  "devDependencies": {
-    "chalk": "^2.0.0",
-    "strip-ansi": "^4.0.0"
-  },
-  "gitHead": "7fd40d86a0d03ff0e9c3ea16b29689945433d4df",
-  "homepage": "https://babeljs.io/",
-  "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"
-  },
-  "version": "7.10.4"
-}

node_modules/@babel/helper-validator-identifier/README.md

@@ -2,7 +2,7 @@
 
 > Validate identifier/keywords name
 
-See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/en/next/babel-helper-validator-identifier.html) for more information.
+See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/en/babel-helper-validator-identifier) for more information.
 
 ## Install
 

node_modules/@babel/helper-validator-identifier/package.json

@@ -1,34 +1,32 @@
 {
   "_args": [
     [
-      "@babel/helper-validator-identifier@7.10.4",
+      "@babel/helper-validator-identifier@7.12.11",
       "J:\\Github\\CURD-TS"
     ]
   ],
-  "_development": true,
-  "_from": "@babel/helper-validator-identifier@7.10.4",
-  "_id": "@babel/helper-validator-identifier@7.10.4",
+  "_from": "@babel/helper-validator-identifier@7.12.11",
+  "_id": "@babel/helper-validator-identifier@7.12.11",
   "_inBundle": false,
-  "_integrity": "sha1-p4x6clHgH2FlEtMbEK3PUq2l4NI=",
+  "_integrity": "sha1-yaHwIZF9y1zPDU5FPjmQIpgfye0=",
   "_location": "/@babel/helper-validator-identifier",
   "_phantomChildren": {},
   "_requested": {
     "type": "version",
     "registry": true,
-    "raw": "@babel/helper-validator-identifier@7.10.4",
+    "raw": "@babel/helper-validator-identifier@7.12.11",
     "name": "@babel/helper-validator-identifier",
     "escapedName": "@babel%2fhelper-validator-identifier",
     "scope": "@babel",
-    "rawSpec": "7.10.4",
+    "rawSpec": "7.12.11",
     "saveSpec": null,
-    "fetchSpec": "7.10.4"
+    "fetchSpec": "7.12.11"
   },
   "_requiredBy": [
-    "/@babel/highlight",
     "/@babel/types"
   ],
-  "_resolved": "http://192.168.250.101:4873/@babel%2fhelper-validator-identifier/-/helper-validator-identifier-7.10.4.tgz",
-  "_spec": "7.10.4",
+  "_resolved": "http://192.168.250.101:4873/@babel%2fhelper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz",
+  "_spec": "7.12.11",
   "_where": "J:\\Github\\CURD-TS",
   "bugs": {
     "url": "https://github.com/babel/babel/issues"
@@ -39,7 +37,6 @@
     "unicode-13.0.0": "^0.8.0"
   },
   "exports": "./lib/index.js",
-  "gitHead": "7fd40d86a0d03ff0e9c3ea16b29689945433d4df",
   "homepage": "https://github.com/babel/babel#readme",
   "license": "MIT",
   "main": "./lib/index.js",
@@ -52,5 +49,5 @@
     "url": "git+https://github.com/babel/babel.git",
     "directory": "packages/babel-helper-validator-identifier"
   },
-  "version": "7.10.4"
+  "version": "7.12.11"
 }

node_modules/@babel/highlight/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2014-present Sebastian McKenzie and other contributors
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/highlight/README.md

@@ -1,19 +0,0 @@
-# @babel/highlight
-
-> Syntax highlight JavaScript strings for output in terminals.
-
-See our website [@babel/highlight](https://babeljs.io/docs/en/next/babel-highlight.html) for more information.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/highlight
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/highlight --dev
-```

node_modules/@babel/highlight/lib/index.js

@@ -1,107 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.shouldHighlight = shouldHighlight;
-exports.getChalk = getChalk;
-exports.default = highlight;
-
-var _jsTokens = _interopRequireWildcard(require("js-tokens"));
-
-var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
-
-var _chalk = _interopRequireDefault(require("chalk"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function getDefs(chalk) {
-  return {
-    keyword: chalk.cyan,
-    capitalized: chalk.yellow,
-    jsx_tag: chalk.yellow,
-    punctuator: chalk.yellow,
-    number: chalk.magenta,
-    string: chalk.green,
-    regex: chalk.magenta,
-    comment: chalk.grey,
-    invalid: chalk.white.bgRed.bold
-  };
-}
-
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-const JSX_TAG = /^[a-z][\w-]*$/i;
-const BRACKET = /^[()[\]{}]$/;
-
-function getTokenType(match) {
-  const [offset, text] = match.slice(-2);
-  const token = (0, _jsTokens.matchToToken)(match);
-
-  if (token.type === "name") {
-    if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isReservedWord)(token.value)) {
-      return "keyword";
-    }
-
-    if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == "</")) {
-      return "jsx_tag";
-    }
-
-    if (token.value[0] !== token.value[0].toLowerCase()) {
-      return "capitalized";
-    }
-  }
-
-  if (token.type === "punctuator" && BRACKET.test(token.value)) {
-    return "bracket";
-  }
-
-  if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
-    return "punctuator";
-  }
-
-  return token.type;
-}
-
-function highlightTokens(defs, text) {
-  return text.replace(_jsTokens.default, function (...args) {
-    const type = getTokenType(args);
-    const colorize = defs[type];
-
-    if (colorize) {
-      return args[0].split(NEWLINE).map(str => colorize(str)).join("\n");
-    } else {
-      return args[0];
-    }
-  });
-}
-
-function shouldHighlight(options) {
-  return _chalk.default.supportsColor || options.forceColor;
-}
-
-function getChalk(options) {
-  let chalk = _chalk.default;
-
-  if (options.forceColor) {
-    chalk = new _chalk.default.constructor({
-      enabled: true,
-      level: 1
-    });
-  }
-
-  return chalk;
-}
-
-function highlight(code, options = {}) {
-  if (shouldHighlight(options)) {
-    const chalk = getChalk(options);
-    const defs = getDefs(chalk);
-    return highlightTokens(defs, code);
-  } else {
-    return code;
-  }
-}

node_modules/@babel/highlight/package.json

@@ -1,62 +0,0 @@
-{
-  "_args": [
-    [
-      "@babel/highlight@7.10.4",
-      "J:\\Github\\CURD-TS"
-    ]
-  ],
-  "_development": true,
-  "_from": "@babel/highlight@7.10.4",
-  "_id": "@babel/highlight@7.10.4",
-  "_inBundle": false,
-  "_integrity": "sha1-fRvf1ldTU4+r5sOFls23bZrGAUM=",
-  "_location": "/@babel/highlight",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "@babel/highlight@7.10.4",
-    "name": "@babel/highlight",
-    "escapedName": "@babel%2fhighlight",
-    "scope": "@babel",
-    "rawSpec": "7.10.4",
-    "saveSpec": null,
-    "fetchSpec": "7.10.4"
-  },
-  "_requiredBy": [
-    "/@babel/code-frame"
-  ],
-  "_resolved": "http://192.168.250.101:4873/@babel%2fhighlight/-/highlight-7.10.4.tgz",
-  "_spec": "7.10.4",
-  "_where": "J:\\Github\\CURD-TS",
-  "author": {
-    "name": "suchipi",
-    "email": "me@suchipi.com"
-  },
-  "bugs": {
-    "url": "https://github.com/babel/babel/issues"
-  },
-  "dependencies": {
-    "@babel/helper-validator-identifier": "^7.10.4",
-    "chalk": "^2.0.0",
-    "js-tokens": "^4.0.0"
-  },
-  "description": "Syntax highlight JavaScript strings for output in terminals.",
-  "devDependencies": {
-    "strip-ansi": "^4.0.0"
-  },
-  "gitHead": "7fd40d86a0d03ff0e9c3ea16b29689945433d4df",
-  "homepage": "https://babeljs.io/",
-  "license": "MIT",
-  "main": "lib/index.js",
-  "name": "@babel/highlight",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/babel/babel.git",
-    "directory": "packages/babel-highlight"
-  },
-  "version": "7.10.4"
-}

node_modules/@babel/parser/lib/options.js

@@ -1,35 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getOptions = getOptions;
-exports.defaultOptions = void 0;
-const defaultOptions = {
-  sourceType: "script",
-  sourceFilename: undefined,
-  startLine: 1,
-  allowAwaitOutsideFunction: false,
-  allowReturnOutsideFunction: false,
-  allowImportExportEverywhere: false,
-  allowSuperOutsideMethod: false,
-  allowUndeclaredExports: false,
-  plugins: [],
-  strictMode: null,
-  ranges: false,
-  tokens: false,
-  createParenthesizedExpressions: false,
-  errorRecovery: false
-};
-exports.defaultOptions = defaultOptions;
-
-function getOptions(opts) {
-  const options = {};
-
-  for (let _i = 0, _Object$keys = Object.keys(defaultOptions); _i < _Object$keys.length; _i++) {
-    const key = _Object$keys[_i];
-    options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
-  }
-
-  return options;
-}

node_modules/@babel/parser/lib/parser/base.js

@@ -1,24 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-class BaseParser {
-  constructor() {
-    this.sawUnambiguousESM = false;
-    this.ambiguousScriptDifferentAst = false;
-  }
-
-  hasPlugin(name) {
-    return this.plugins.has(name);
-  }
-
-  getPluginOption(plugin, name) {
-    if (this.hasPlugin(plugin)) return this.plugins.get(plugin)[name];
-  }
-
-}
-
-exports.default = BaseParser;

node_modules/@babel/parser/lib/parser/comments.js

@@ -1,205 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _base = _interopRequireDefault(require("./base"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function last(stack) {
-  return stack[stack.length - 1];
-}
-
-class CommentsParser extends _base.default {
-  addComment(comment) {
-    if (this.filename) comment.loc.filename = this.filename;
-    this.state.trailingComments.push(comment);
-    this.state.leadingComments.push(comment);
-  }
-
-  adjustCommentsAfterTrailingComma(node, elements, takeAllComments) {
-    if (this.state.leadingComments.length === 0) {
-      return;
-    }
-
-    let lastElement = null;
-    let i = elements.length;
-
-    while (lastElement === null && i > 0) {
-      lastElement = elements[--i];
-    }
-
-    if (lastElement === null) {
-      return;
-    }
-
-    for (let j = 0; j < this.state.leadingComments.length; j++) {
-      if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
-        this.state.leadingComments.splice(j, 1);
-        j--;
-      }
-    }
-
-    const newTrailingComments = [];
-
-    for (let i = 0; i < this.state.leadingComments.length; i++) {
-      const leadingComment = this.state.leadingComments[i];
-
-      if (leadingComment.end < node.end) {
-        newTrailingComments.push(leadingComment);
-
-        if (!takeAllComments) {
-          this.state.leadingComments.splice(i, 1);
-          i--;
-        }
-      } else {
-        if (node.trailingComments === undefined) {
-          node.trailingComments = [];
-        }
-
-        node.trailingComments.push(leadingComment);
-      }
-    }
-
-    if (takeAllComments) this.state.leadingComments = [];
-
-    if (newTrailingComments.length > 0) {
-      lastElement.trailingComments = newTrailingComments;
-    } else if (lastElement.trailingComments !== undefined) {
-      lastElement.trailingComments = [];
-    }
-  }
-
-  processComment(node) {
-    if (node.type === "Program" && node.body.length > 0) return;
-    const stack = this.state.commentStack;
-    let firstChild, lastChild, trailingComments, i, j;
-
-    if (this.state.trailingComments.length > 0) {
-      if (this.state.trailingComments[0].start >= node.end) {
-        trailingComments = this.state.trailingComments;
-        this.state.trailingComments = [];
-      } else {
-        this.state.trailingComments.length = 0;
-      }
-    } else if (stack.length > 0) {
-      const lastInStack = last(stack);
-
-      if (lastInStack.trailingComments && lastInStack.trailingComments[0].start >= node.end) {
-        trailingComments = lastInStack.trailingComments;
-        delete lastInStack.trailingComments;
-      }
-    }
-
-    if (stack.length > 0 && last(stack).start >= node.start) {
-      firstChild = stack.pop();
-    }
-
-    while (stack.length > 0 && last(stack).start >= node.start) {
-      lastChild = stack.pop();
-    }
-
-    if (!lastChild && firstChild) lastChild = firstChild;
-
-    if (firstChild) {
-      switch (node.type) {
-        case "ObjectExpression":
-          this.adjustCommentsAfterTrailingComma(node, node.properties);
-          break;
-
-        case "ObjectPattern":
-          this.adjustCommentsAfterTrailingComma(node, node.properties, true);
-          break;
-
-        case "CallExpression":
-          this.adjustCommentsAfterTrailingComma(node, node.arguments);
-          break;
-
-        case "ArrayExpression":
-          this.adjustCommentsAfterTrailingComma(node, node.elements);
-          break;
-
-        case "ArrayPattern":
-          this.adjustCommentsAfterTrailingComma(node, node.elements, true);
-          break;
-      }
-    } else if (this.state.commentPreviousNode && (this.state.commentPreviousNode.type === "ImportSpecifier" && node.type !== "ImportSpecifier" || this.state.commentPreviousNode.type === "ExportSpecifier" && node.type !== "ExportSpecifier")) {
-      this.adjustCommentsAfterTrailingComma(node, [this.state.commentPreviousNode]);
-    }
-
-    if (lastChild) {
-      if (lastChild.leadingComments) {
-        if (lastChild !== node && lastChild.leadingComments.length > 0 && last(lastChild.leadingComments).end <= node.start) {
-          node.leadingComments = lastChild.leadingComments;
-          delete lastChild.leadingComments;
-        } else {
-          for (i = lastChild.leadingComments.length - 2; i >= 0; --i) {
-            if (lastChild.leadingComments[i].end <= node.start) {
-              node.leadingComments = lastChild.leadingComments.splice(0, i + 1);
-              break;
-            }
-          }
-        }
-      }
-    } else if (this.state.leadingComments.length > 0) {
-      if (last(this.state.leadingComments).end <= node.start) {
-        if (this.state.commentPreviousNode) {
-          for (j = 0; j < this.state.leadingComments.length; j++) {
-            if (this.state.leadingComments[j].end < this.state.commentPreviousNode.end) {
-              this.state.leadingComments.splice(j, 1);
-              j--;
-            }
-          }
-        }
-
-        if (this.state.leadingComments.length > 0) {
-          node.leadingComments = this.state.leadingComments;
-          this.state.leadingComments = [];
-        }
-      } else {
-        for (i = 0; i < this.state.leadingComments.length; i++) {
-          if (this.state.leadingComments[i].end > node.start) {
-            break;
-          }
-        }
-
-        const leadingComments = this.state.leadingComments.slice(0, i);
-
-        if (leadingComments.length) {
-          node.leadingComments = leadingComments;
-        }
-
-        trailingComments = this.state.leadingComments.slice(i);
-
-        if (trailingComments.length === 0) {
-          trailingComments = null;
-        }
-      }
-    }
-
-    this.state.commentPreviousNode = node;
-
-    if (trailingComments) {
-      if (trailingComments.length && trailingComments[0].start >= node.start && last(trailingComments).end <= node.end) {
-        node.innerComments = trailingComments;
-      } else {
-        const firstTrailingCommentIndex = trailingComments.findIndex(comment => comment.end >= node.end);
-
-        if (firstTrailingCommentIndex > 0) {
-          node.innerComments = trailingComments.slice(0, firstTrailingCommentIndex);
-          node.trailingComments = trailingComments.slice(firstTrailingCommentIndex);
-        } else {
-          node.trailingComments = trailingComments;
-        }
-      }
-    }
-
-    stack.push(node);
-  }
-
-}
-
-exports.default = CommentsParser;

node_modules/@babel/parser/lib/parser/error-message.js

@@ -1,154 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ErrorMessages = void 0;
-const ErrorMessages = Object.freeze({
-  AccessorIsGenerator: "A %0ter cannot be a generator",
-  ArgumentsInClass: "'arguments' is only allowed in functions and class methods",
-  AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block",
-  AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function",
-  AwaitExpressionFormalParameter: "await is not allowed in async function parameters",
-  AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules",
-  AwaitNotInAsyncFunction: "'await' is only allowed within async functions",
-  BadGetterArity: "getter must not have any formal parameters",
-  BadSetterArity: "setter must have exactly one formal parameter",
-  BadSetterRestParameter: "setter function argument must not be a rest parameter",
-  ConstructorClassField: "Classes may not have a field named 'constructor'",
-  ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'",
-  ConstructorIsAccessor: "Class constructor may not be an accessor",
-  ConstructorIsAsync: "Constructor can't be an async function",
-  ConstructorIsGenerator: "Constructor can't be a generator",
-  DeclarationMissingInitializer: "%0 require an initialization value",
-  DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. You can set the 'decoratorsBeforeExport' option to false to use the 'export @decorator class {}' syntax",
-  DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
-  DecoratorExportClass: "Using the export keyword between a decorator and a class is not allowed. Please use `export @dec class` instead.",
-  DecoratorSemicolon: "Decorators must not be followed by a semicolon",
-  DecoratorStaticBlock: "Decorators can't be used with a static block",
-  DeletePrivateField: "Deleting a private field is not allowed",
-  DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
-  DuplicateConstructor: "Duplicate constructor in the same class",
-  DuplicateDefaultExport: "Only one default export allowed per module.",
-  DuplicateExport: "`%0` has already been exported. Exported identifiers must be unique.",
-  DuplicateProto: "Redefinition of __proto__ property",
-  DuplicateRegExpFlags: "Duplicate regular expression flag",
-  DuplicateStaticBlock: "Duplicate static block in the same class",
-  ElementAfterRest: "Rest element must be last element",
-  EscapedCharNotAnIdentifier: "Invalid Unicode escape",
-  ExportBindingIsString: "A string literal cannot be used as an exported binding without `from`.\n- Did you mean `export { %0 as '%1' } from 'some-module'`?",
-  ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'",
-  ForInOfLoopInitializer: "%0 loop variable declaration may not have an initializer",
-  GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block",
-  IllegalBreakContinue: "Unsyntactic %0",
-  IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list",
-  IllegalReturn: "'return' outside of function",
-  ImportBindingIsString: 'A string literal cannot be used as an imported binding.\n- Did you mean `import { "%0" as foo }`?',
-  ImportCallArgumentTrailingComma: "Trailing comma is disallowed inside import(...) arguments",
-  ImportCallArity: "import() requires exactly %0",
-  ImportCallNotNewExpression: "Cannot use new with import(...)",
-  ImportCallSpreadArgument: "... is not allowed in import()",
-  ImportMetaOutsideModule: `import.meta may appear only with 'sourceType: "module"'`,
-  ImportOutsideModule: `'import' and 'export' may appear only with 'sourceType: "module"'`,
-  InvalidBigIntLiteral: "Invalid BigIntLiteral",
-  InvalidCodePoint: "Code point out of bounds",
-  InvalidDecimal: "Invalid decimal",
-  InvalidDigit: "Expected number in radix %0",
-  InvalidEscapeSequence: "Bad character escape sequence",
-  InvalidEscapeSequenceTemplate: "Invalid escape sequence in template",
-  InvalidEscapedReservedWord: "Escape sequence in keyword %0",
-  InvalidIdentifier: "Invalid identifier %0",
-  InvalidLhs: "Invalid left-hand side in %0",
-  InvalidLhsBinding: "Binding invalid left-hand side in %0",
-  InvalidNumber: "Invalid number",
-  InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'",
-  InvalidOrUnexpectedToken: "Unexpected character '%0'",
-  InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern",
-  InvalidPrivateFieldResolution: "Private name #%0 is not defined",
-  InvalidPropertyBindingPattern: "Binding member expression",
-  InvalidRecordProperty: "Only properties and spread elements are allowed in record definitions",
-  InvalidRestAssignmentPattern: "Invalid rest operator's argument",
-  LabelRedeclaration: "Label '%0' is already declared",
-  LetInLexicalBinding: "'let' is not allowed to be used as a name in 'let' or 'const' declarations.",
-  LineTerminatorBeforeArrow: "No line break is allowed before '=>'",
-  MalformedRegExpFlags: "Invalid regular expression flag",
-  MissingClassName: "A class name is required",
-  MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
-  MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX",
-  MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators",
-  ModuleAttributeDifferentFromType: "The only accepted module attribute is `type`",
-  ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values",
-  ModuleAttributesWithDuplicateKeys: 'Duplicate key "%0" is not allowed in module attributes',
-  ModuleExportNameHasLoneSurrogate: "An export name cannot include a lone surrogate, found '\\u%0'",
-  ModuleExportUndefined: "Export '%0' is not defined",
-  MultipleDefaultsInSwitch: "Multiple default clauses",
-  NewlineAfterThrow: "Illegal newline after throw",
-  NoCatchOrFinally: "Missing catch or finally clause",
-  NumberIdentifier: "Identifier directly after number",
-  NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences",
-  ObsoleteAwaitStar: "await* has been removed from the async functions proposal. Use Promise.all() instead.",
-  OptionalChainingNoNew: "constructors in/after an Optional Chain are not allowed",
-  OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain",
-  ParamDupe: "Argument name clash",
-  PatternHasAccessor: "Object pattern can't contain getter or setter",
-  PatternHasMethod: "Object pattern can't contain methods",
-  PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized',
-  PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression",
-  PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression",
-  PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference",
-  PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding",
-  PrimaryTopicRequiresSmartPipeline: "Primary Topic Reference found but pipelineOperator not passed 'smart' for 'proposal' option.",
-  PrivateInExpectedIn: "Private names are only allowed in property accesses (`obj.#%0`) or in `in` expressions (`#%0 in obj`)",
-  PrivateNameRedeclaration: "Duplicate private name #%0",
-  RecordExpressionBarIncorrectEndSyntaxType: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'",
-  RecordExpressionBarIncorrectStartSyntaxType: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'",
-  RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'",
-  RecordNoProto: "'__proto__' is not allowed in Record expressions",
-  RestTrailingComma: "Unexpected trailing comma after rest element",
-  SloppyFunction: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement",
-  StaticPrototype: "Classes may not have static property named prototype",
-  StrictDelete: "Deleting local variable in strict mode",
-  StrictEvalArguments: "Assigning to '%0' in strict mode",
-  StrictEvalArgumentsBinding: "Binding '%0' in strict mode",
-  StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block",
-  StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'",
-  StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode",
-  StrictWith: "'with' in strict mode",
-  SuperNotAllowed: "super() is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
-  SuperPrivateField: "Private fields can't be accessed on super",
-  TrailingDecorator: "Decorators must be attached to a class element",
-  TupleExpressionBarIncorrectEndSyntaxType: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'",
-  TupleExpressionBarIncorrectStartSyntaxType: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'",
-  TupleExpressionHashIncorrectStartSyntaxType: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'",
-  UnexpectedArgumentPlaceholder: "Unexpected argument placeholder",
-  UnexpectedAwaitAfterPipelineBody: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal',
-  UnexpectedDigitAfterHash: "Unexpected digit after hash token",
-  UnexpectedImportExport: "'import' and 'export' may only appear at the top level",
-  UnexpectedKeyword: "Unexpected keyword '%0'",
-  UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration",
-  UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context",
-  UnexpectedNewTarget: "new.target can only be used in functions",
-  UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits",
-  UnexpectedPrivateField: "Private names can only be used as the name of a class element (i.e. class C { #p = 42; #m() {} } )\n or a property of member expression (i.e. this.#p).",
-  UnexpectedReservedWord: "Unexpected reserved word '%0'",
-  UnexpectedSuper: "super is only allowed in object methods and classes",
-  UnexpectedToken: "Unexpected token '%0'",
-  UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
-  UnsupportedBind: "Binding should be performed on object property.",
-  UnsupportedDecoratorExport: "A decorated export must export a class declaration",
-  UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
-  UnsupportedImport: "import can only be used in import() or import.meta",
-  UnsupportedMetaProperty: "The only valid meta property for %0 is %0.%1",
-  UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters",
-  UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties",
-  UnsupportedSuper: "super can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop])",
-  UnterminatedComment: "Unterminated comment",
-  UnterminatedRegExp: "Unterminated regular expression",
-  UnterminatedString: "Unterminated string constant",
-  UnterminatedTemplate: "Unterminated template",
-  VarRedeclaration: "Identifier '%0' has already been declared",
-  YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator",
-  YieldInParameter: "Yield expression is not allowed in formal parameters",
-  ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0"
-});
-exports.ErrorMessages = ErrorMessages;

node_modules/@babel/parser/lib/parser/error.js

@@ -1,56 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "Errors", {
-  enumerable: true,
-  get: function () {
-    return _errorMessage.ErrorMessages;
-  }
-});
-exports.default = void 0;
-
-var _location = require("../util/location");
-
-var _comments = _interopRequireDefault(require("./comments"));
-
-var _errorMessage = require("./error-message.js");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class ParserError extends _comments.default {
-  getLocationForPosition(pos) {
-    let loc;
-    if (pos === this.state.start) loc = this.state.startLoc;else if (pos === this.state.lastTokStart) loc = this.state.lastTokStartLoc;else if (pos === this.state.end) loc = this.state.endLoc;else if (pos === this.state.lastTokEnd) loc = this.state.lastTokEndLoc;else loc = (0, _location.getLineInfo)(this.input, pos);
-    return loc;
-  }
-
-  raise(pos, errorTemplate, ...params) {
-    return this.raiseWithData(pos, undefined, errorTemplate, ...params);
-  }
-
-  raiseWithData(pos, data, errorTemplate, ...params) {
-    const loc = this.getLocationForPosition(pos);
-    const message = errorTemplate.replace(/%(\d+)/g, (_, i) => params[i]) + ` (${loc.line}:${loc.column})`;
-    return this._raise(Object.assign({
-      loc,
-      pos
-    }, data), message);
-  }
-
-  _raise(errorContext, message) {
-    const err = new SyntaxError(message);
-    Object.assign(err, errorContext);
-
-    if (this.options.errorRecovery) {
-      if (!this.isLookahead) this.state.errors.push(err);
-      return err;
-    } else {
-      throw err;
-    }
-  }
-
-}
-
-exports.default = ParserError;

node_modules/@babel/parser/lib/parser/expression.js

@@ -1,1835 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _types = require("../tokenizer/types");
-
-var _context = require("../tokenizer/context");
-
-var N = _interopRequireWildcard(require("../types"));
-
-var _lval = _interopRequireDefault(require("./lval"));
-
-var _identifier = require("../util/identifier");
-
-var _scopeflags = require("../util/scopeflags");
-
-var _util = require("./util");
-
-var _productionParameter = require("../util/production-parameter");
-
-var _expressionScope = require("../util/expression-scope.js");
-
-var _error = require("./error");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-class ExpressionParser extends _lval.default {
-  checkProto(prop, isRecord, protoRef, refExpressionErrors) {
-    if (prop.type === "SpreadElement" || prop.type === "ObjectMethod" || prop.computed || prop.shorthand) {
-      return;
-    }
-
-    const key = prop.key;
-    const name = key.type === "Identifier" ? key.name : key.value;
-
-    if (name === "__proto__") {
-      if (isRecord) {
-        this.raise(key.start, _error.Errors.RecordNoProto);
-        return;
-      }
-
-      if (protoRef.used) {
-        if (refExpressionErrors) {
-          if (refExpressionErrors.doubleProto === -1) {
-            refExpressionErrors.doubleProto = key.start;
-          }
-        } else {
-          this.raise(key.start, _error.Errors.DuplicateProto);
-        }
-      }
-
-      protoRef.used = true;
-    }
-  }
-
-  shouldExitDescending(expr, potentialArrowAt) {
-    return expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt;
-  }
-
-  getExpression() {
-    let paramFlags = _productionParameter.PARAM;
-
-    if (this.hasPlugin("topLevelAwait") && this.inModule) {
-      paramFlags |= _productionParameter.PARAM_AWAIT;
-    }
-
-    this.scope.enter(_scopeflags.SCOPE_PROGRAM);
-    this.prodParam.enter(paramFlags);
-    this.nextToken();
-    const expr = this.parseExpression();
-
-    if (!this.match(_types.types.eof)) {
-      this.unexpected();
-    }
-
-    expr.comments = this.state.comments;
-    expr.errors = this.state.errors;
-    return expr;
-  }
-
-  parseExpression(disallowIn, refExpressionErrors) {
-    if (disallowIn) {
-      return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors));
-    }
-
-    return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));
-  }
-
-  parseExpressionBase(refExpressionErrors) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const expr = this.parseMaybeAssign(refExpressionErrors);
-
-    if (this.match(_types.types.comma)) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.expressions = [expr];
-
-      while (this.eat(_types.types.comma)) {
-        node.expressions.push(this.parseMaybeAssign(refExpressionErrors));
-      }
-
-      this.toReferencedList(node.expressions);
-      return this.finishNode(node, "SequenceExpression");
-    }
-
-    return expr;
-  }
-
-  parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse, refNeedsArrowPos) {
-    return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos));
-  }
-
-  parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse, refNeedsArrowPos) {
-    return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos));
-  }
-
-  parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-
-    if (this.isContextual("yield")) {
-      if (this.prodParam.hasYield) {
-        this.state.exprAllowed = true;
-        let left = this.parseYield();
-
-        if (afterLeftParse) {
-          left = afterLeftParse.call(this, left, startPos, startLoc);
-        }
-
-        return left;
-      }
-    }
-
-    let ownExpressionErrors;
-
-    if (refExpressionErrors) {
-      ownExpressionErrors = false;
-    } else {
-      refExpressionErrors = new _util.ExpressionErrors();
-      ownExpressionErrors = true;
-    }
-
-    if (this.match(_types.types.parenL) || this.match(_types.types.name)) {
-      this.state.potentialArrowAt = this.state.start;
-    }
-
-    let left = this.parseMaybeConditional(refExpressionErrors, refNeedsArrowPos);
-
-    if (afterLeftParse) {
-      left = afterLeftParse.call(this, left, startPos, startLoc);
-    }
-
-    if (this.state.type.isAssign) {
-      const node = this.startNodeAt(startPos, startLoc);
-      const operator = this.state.value;
-      node.operator = operator;
-
-      if (this.match(_types.types.eq)) {
-        node.left = this.toAssignable(left);
-        refExpressionErrors.doubleProto = -1;
-      } else {
-        node.left = left;
-      }
-
-      if (refExpressionErrors.shorthandAssign >= node.left.start) {
-        refExpressionErrors.shorthandAssign = -1;
-      }
-
-      this.checkLVal(left, undefined, undefined, "assignment expression");
-      this.next();
-      node.right = this.parseMaybeAssign();
-      return this.finishNode(node, "AssignmentExpression");
-    } else if (ownExpressionErrors) {
-      this.checkExpressionErrors(refExpressionErrors, true);
-    }
-
-    return left;
-  }
-
-  parseMaybeConditional(refExpressionErrors, refNeedsArrowPos) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const potentialArrowAt = this.state.potentialArrowAt;
-    const expr = this.parseExprOps(refExpressionErrors);
-
-    if (this.shouldExitDescending(expr, potentialArrowAt)) {
-      return expr;
-    }
-
-    return this.parseConditional(expr, startPos, startLoc, refNeedsArrowPos);
-  }
-
-  parseConditional(expr, startPos, startLoc, refNeedsArrowPos) {
-    if (this.eat(_types.types.question)) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.test = expr;
-      node.consequent = this.parseMaybeAssignAllowIn();
-      this.expect(_types.types.colon);
-      node.alternate = this.parseMaybeAssign();
-      return this.finishNode(node, "ConditionalExpression");
-    }
-
-    return expr;
-  }
-
-  parseExprOps(refExpressionErrors) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const potentialArrowAt = this.state.potentialArrowAt;
-    const expr = this.parseMaybeUnary(refExpressionErrors);
-
-    if (this.shouldExitDescending(expr, potentialArrowAt)) {
-      return expr;
-    }
-
-    return this.parseExprOp(expr, startPos, startLoc, -1);
-  }
-
-  parseExprOp(left, leftStartPos, leftStartLoc, minPrec) {
-    let prec = this.state.type.binop;
-
-    if (prec != null && (this.prodParam.hasIn || !this.match(_types.types._in))) {
-      if (prec > minPrec) {
-        const op = this.state.type;
-
-        if (op === _types.types.pipeline) {
-          this.expectPlugin("pipelineOperator");
-
-          if (this.state.inFSharpPipelineDirectBody) {
-            return left;
-          }
-
-          this.state.inPipeline = true;
-          this.checkPipelineAtInfixOperator(left, leftStartPos);
-        }
-
-        const node = this.startNodeAt(leftStartPos, leftStartLoc);
-        node.left = left;
-        node.operator = this.state.value;
-
-        if (op === _types.types.exponent && left.type === "UnaryExpression" && (this.options.createParenthesizedExpressions || !(left.extra && left.extra.parenthesized))) {
-          this.raise(left.argument.start, _error.Errors.UnexpectedTokenUnaryExponentiation);
-        }
-
-        const logical = op === _types.types.logicalOR || op === _types.types.logicalAND;
-        const coalesce = op === _types.types.nullishCoalescing;
-
-        if (coalesce) {
-          prec = _types.types.logicalAND.binop;
-        }
-
-        this.next();
-
-        if (op === _types.types.pipeline && this.getPluginOption("pipelineOperator", "proposal") === "minimal") {
-          if (this.match(_types.types.name) && this.state.value === "await" && this.prodParam.hasAwait) {
-            throw this.raise(this.state.start, _error.Errors.UnexpectedAwaitAfterPipelineBody);
-          }
-        }
-
-        node.right = this.parseExprOpRightExpr(op, prec);
-        this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
-        const nextOp = this.state.type;
-
-        if (coalesce && (nextOp === _types.types.logicalOR || nextOp === _types.types.logicalAND) || logical && nextOp === _types.types.nullishCoalescing) {
-          throw this.raise(this.state.start, _error.Errors.MixingCoalesceWithLogical);
-        }
-
-        return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec);
-      }
-    }
-
-    return left;
-  }
-
-  parseExprOpRightExpr(op, prec) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-
-    switch (op) {
-      case _types.types.pipeline:
-        switch (this.getPluginOption("pipelineOperator", "proposal")) {
-          case "smart":
-            return this.withTopicPermittingContext(() => {
-              return this.parseSmartPipelineBody(this.parseExprOpBaseRightExpr(op, prec), startPos, startLoc);
-            });
-
-          case "fsharp":
-            return this.withSoloAwaitPermittingContext(() => {
-              return this.parseFSharpPipelineBody(prec);
-            });
-        }
-
-      default:
-        return this.parseExprOpBaseRightExpr(op, prec);
-    }
-  }
-
-  parseExprOpBaseRightExpr(op, prec) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    return this.parseExprOp(this.parseMaybeUnary(), startPos, startLoc, op.rightAssociative ? prec - 1 : prec);
-  }
-
-  parseMaybeUnary(refExpressionErrors) {
-    if (this.isContextual("await") && this.isAwaitAllowed()) {
-      return this.parseAwait();
-    }
-
-    const update = this.match(_types.types.incDec);
-    const node = this.startNode();
-
-    if (this.state.type.prefix) {
-      node.operator = this.state.value;
-      node.prefix = true;
-
-      if (this.match(_types.types._throw)) {
-        this.expectPlugin("throwExpressions");
-      }
-
-      const isDelete = this.match(_types.types._delete);
-      this.next();
-      node.argument = this.parseMaybeUnary();
-      this.checkExpressionErrors(refExpressionErrors, true);
-
-      if (this.state.strict && isDelete) {
-        const arg = node.argument;
-
-        if (arg.type === "Identifier") {
-          this.raise(node.start, _error.Errors.StrictDelete);
-        } else if ((arg.type === "MemberExpression" || arg.type === "OptionalMemberExpression") && arg.property.type === "PrivateName") {
-          this.raise(node.start, _error.Errors.DeletePrivateField);
-        }
-      }
-
-      if (!update) {
-        return this.finishNode(node, "UnaryExpression");
-      }
-    }
-
-    return this.parseUpdate(node, update, refExpressionErrors);
-  }
-
-  parseUpdate(node, update, refExpressionErrors) {
-    if (update) {
-      this.checkLVal(node.argument, undefined, undefined, "prefix operation");
-      return this.finishNode(node, "UpdateExpression");
-    }
-
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    let expr = this.parseExprSubscripts(refExpressionErrors);
-    if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;
-
-    while (this.state.type.postfix && !this.canInsertSemicolon()) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.operator = this.state.value;
-      node.prefix = false;
-      node.argument = expr;
-      this.checkLVal(expr, undefined, undefined, "postfix operation");
-      this.next();
-      expr = this.finishNode(node, "UpdateExpression");
-    }
-
-    return expr;
-  }
-
-  parseExprSubscripts(refExpressionErrors) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const potentialArrowAt = this.state.potentialArrowAt;
-    const expr = this.parseExprAtom(refExpressionErrors);
-
-    if (this.shouldExitDescending(expr, potentialArrowAt)) {
-      return expr;
-    }
-
-    return this.parseSubscripts(expr, startPos, startLoc);
-  }
-
-  parseSubscripts(base, startPos, startLoc, noCalls) {
-    const state = {
-      optionalChainMember: false,
-      maybeAsyncArrow: this.atPossibleAsyncArrow(base),
-      stop: false
-    };
-
-    do {
-      base = this.parseSubscript(base, startPos, startLoc, noCalls, state);
-      state.maybeAsyncArrow = false;
-    } while (!state.stop);
-
-    return base;
-  }
-
-  parseSubscript(base, startPos, startLoc, noCalls, state) {
-    if (!noCalls && this.eat(_types.types.doubleColon)) {
-      return this.parseBind(base, startPos, startLoc, noCalls, state);
-    } else if (this.match(_types.types.backQuote)) {
-      return this.parseTaggedTemplateExpression(base, startPos, startLoc, state);
-    }
-
-    let optional = false;
-
-    if (this.match(_types.types.questionDot)) {
-      state.optionalChainMember = optional = true;
-
-      if (noCalls && this.lookaheadCharCode() === 40) {
-        state.stop = true;
-        return base;
-      }
-
-      this.next();
-    }
-
-    if (!noCalls && this.match(_types.types.parenL)) {
-      return this.parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional);
-    } else if (optional || this.match(_types.types.bracketL) || this.eat(_types.types.dot)) {
-      return this.parseMember(base, startPos, startLoc, state, optional);
-    } else {
-      state.stop = true;
-      return base;
-    }
-  }
-
-  parseMember(base, startPos, startLoc, state, optional) {
-    const node = this.startNodeAt(startPos, startLoc);
-    const computed = this.eat(_types.types.bracketL);
-    node.object = base;
-    node.computed = computed;
-    const property = computed ? this.parseExpression() : this.parseMaybePrivateName(true);
-
-    if (property.type === "PrivateName") {
-      if (node.object.type === "Super") {
-        this.raise(startPos, _error.Errors.SuperPrivateField);
-      }
-
-      this.classScope.usePrivateName(property.id.name, property.start);
-    }
-
-    node.property = property;
-
-    if (computed) {
-      this.expect(_types.types.bracketR);
-    }
-
-    if (state.optionalChainMember) {
-      node.optional = optional;
-      return this.finishNode(node, "OptionalMemberExpression");
-    } else {
-      return this.finishNode(node, "MemberExpression");
-    }
-  }
-
-  parseBind(base, startPos, startLoc, noCalls, state) {
-    const node = this.startNodeAt(startPos, startLoc);
-    node.object = base;
-    node.callee = this.parseNoCallExpr();
-    state.stop = true;
-    return this.parseSubscripts(this.finishNode(node, "BindExpression"), startPos, startLoc, noCalls);
-  }
-
-  parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional) {
-    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
-    this.state.maybeInArrowParameters = true;
-    this.next();
-    let node = this.startNodeAt(startPos, startLoc);
-    node.callee = base;
-
-    if (state.maybeAsyncArrow) {
-      this.expressionScope.enter((0, _expressionScope.newAsyncArrowScope)());
-    }
-
-    if (state.optionalChainMember) {
-      node.optional = optional;
-    }
-
-    if (optional) {
-      node.arguments = this.parseCallExpressionArguments(_types.types.parenR, false);
-    } else {
-      node.arguments = this.parseCallExpressionArguments(_types.types.parenR, state.maybeAsyncArrow, base.type === "Import", base.type !== "Super", node);
-    }
-
-    this.finishCallExpression(node, state.optionalChainMember);
-
-    if (state.maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {
-      state.stop = true;
-      this.expressionScope.validateAsPattern();
-      this.expressionScope.exit();
-      node = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), node);
-    } else {
-      if (state.maybeAsyncArrow) {
-        this.expressionScope.exit();
-      }
-
-      this.toReferencedArguments(node);
-    }
-
-    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-    return node;
-  }
-
-  toReferencedArguments(node, isParenthesizedExpr) {
-    this.toReferencedListDeep(node.arguments, isParenthesizedExpr);
-  }
-
-  parseTaggedTemplateExpression(base, startPos, startLoc, state) {
-    const node = this.startNodeAt(startPos, startLoc);
-    node.tag = base;
-    node.quasi = this.parseTemplate(true);
-
-    if (state.optionalChainMember) {
-      this.raise(startPos, _error.Errors.OptionalChainingNoTemplate);
-    }
-
-    return this.finishNode(node, "TaggedTemplateExpression");
-  }
-
-  atPossibleAsyncArrow(base) {
-    return base.type === "Identifier" && base.name === "async" && this.state.lastTokEnd === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;
-  }
-
-  finishCallExpression(node, optional) {
-    if (node.callee.type === "Import") {
-      if (node.arguments.length === 2) {
-        if (!this.hasPlugin("moduleAttributes")) {
-          this.expectPlugin("importAssertions");
-        }
-      }
-
-      if (node.arguments.length === 0 || node.arguments.length > 2) {
-        this.raise(node.start, _error.Errors.ImportCallArity, this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? "one or two arguments" : "one argument");
-      } else {
-        for (let _i = 0, _node$arguments = node.arguments; _i < _node$arguments.length; _i++) {
-          const arg = _node$arguments[_i];
-
-          if (arg.type === "SpreadElement") {
-            this.raise(arg.start, _error.Errors.ImportCallSpreadArgument);
-          }
-        }
-      }
-    }
-
-    return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression");
-  }
-
-  parseCallExpressionArguments(close, possibleAsyncArrow, dynamicImport, allowPlaceholder, nodeForExtra) {
-    const elts = [];
-    let innerParenStart;
-    let first = true;
-    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-    this.state.inFSharpPipelineDirectBody = false;
-
-    while (!this.eat(close)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma);
-
-        if (this.match(close)) {
-          if (dynamicImport && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
-            this.raise(this.state.lastTokStart, _error.Errors.ImportCallArgumentTrailingComma);
-          }
-
-          if (nodeForExtra) {
-            this.addExtra(nodeForExtra, "trailingComma", this.state.lastTokStart);
-          }
-
-          this.next();
-          break;
-        }
-      }
-
-      if (this.match(_types.types.parenL) && !innerParenStart) {
-        innerParenStart = this.state.start;
-      }
-
-      elts.push(this.parseExprListItem(false, possibleAsyncArrow ? new _util.ExpressionErrors() : undefined, possibleAsyncArrow ? {
-        start: 0
-      } : undefined, allowPlaceholder));
-    }
-
-    if (possibleAsyncArrow && innerParenStart && this.shouldParseAsyncArrow()) {
-      this.unexpected();
-    }
-
-    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-    return elts;
-  }
-
-  shouldParseAsyncArrow() {
-    return this.match(_types.types.arrow) && !this.canInsertSemicolon();
-  }
-
-  parseAsyncArrowFromCallExpression(node, call) {
-    this.expect(_types.types.arrow);
-    this.parseArrowExpression(node, call.arguments, true, call.extra?.trailingComma);
-    return node;
-  }
-
-  parseNoCallExpr() {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    return this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
-  }
-
-  parseExprAtom(refExpressionErrors) {
-    if (this.state.type === _types.types.slash) this.readRegexp();
-    const canBeArrow = this.state.potentialArrowAt === this.state.start;
-    let node;
-
-    switch (this.state.type) {
-      case _types.types._super:
-        return this.parseSuper();
-
-      case _types.types._import:
-        node = this.startNode();
-        this.next();
-
-        if (this.match(_types.types.dot)) {
-          return this.parseImportMetaProperty(node);
-        }
-
-        if (!this.match(_types.types.parenL)) {
-          this.raise(this.state.lastTokStart, _error.Errors.UnsupportedImport);
-        }
-
-        return this.finishNode(node, "Import");
-
-      case _types.types._this:
-        node = this.startNode();
-        this.next();
-        return this.finishNode(node, "ThisExpression");
-
-      case _types.types.name:
-        {
-          const containsEsc = this.state.containsEsc;
-          const id = this.parseIdentifier();
-
-          if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) {
-            if (this.match(_types.types._function)) {
-              const last = this.state.context.length - 1;
-
-              if (this.state.context[last] !== _context.types.functionStatement) {
-                throw new Error("Internal error");
-              }
-
-              this.state.context[last] = _context.types.functionExpression;
-              this.next();
-              return this.parseFunction(this.startNodeAtNode(id), undefined, true);
-            } else if (this.match(_types.types.name)) {
-              return this.parseAsyncArrowUnaryFunction(id);
-            }
-          }
-
-          if (canBeArrow && this.match(_types.types.arrow) && !this.canInsertSemicolon()) {
-            this.next();
-            return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);
-          }
-
-          return id;
-        }
-
-      case _types.types._do:
-        {
-          return this.parseDo();
-        }
-
-      case _types.types.regexp:
-        {
-          const value = this.state.value;
-          node = this.parseLiteral(value.value, "RegExpLiteral");
-          node.pattern = value.pattern;
-          node.flags = value.flags;
-          return node;
-        }
-
-      case _types.types.num:
-        return this.parseLiteral(this.state.value, "NumericLiteral");
-
-      case _types.types.bigint:
-        return this.parseLiteral(this.state.value, "BigIntLiteral");
-
-      case _types.types.decimal:
-        return this.parseLiteral(this.state.value, "DecimalLiteral");
-
-      case _types.types.string:
-        return this.parseLiteral(this.state.value, "StringLiteral");
-
-      case _types.types._null:
-        node = this.startNode();
-        this.next();
-        return this.finishNode(node, "NullLiteral");
-
-      case _types.types._true:
-      case _types.types._false:
-        return this.parseBooleanLiteral();
-
-      case _types.types.parenL:
-        return this.parseParenAndDistinguishExpression(canBeArrow);
-
-      case _types.types.bracketBarL:
-      case _types.types.bracketHashL:
-        {
-          return this.parseArrayLike(this.state.type === _types.types.bracketBarL ? _types.types.bracketBarR : _types.types.bracketR, false, true, refExpressionErrors);
-        }
-
-      case _types.types.bracketL:
-        {
-          return this.parseArrayLike(_types.types.bracketR, true, false, refExpressionErrors);
-        }
-
-      case _types.types.braceBarL:
-      case _types.types.braceHashL:
-        {
-          return this.parseObjectLike(this.state.type === _types.types.braceBarL ? _types.types.braceBarR : _types.types.braceR, false, true, refExpressionErrors);
-        }
-
-      case _types.types.braceL:
-        {
-          return this.parseObjectLike(_types.types.braceR, false, false, refExpressionErrors);
-        }
-
-      case _types.types._function:
-        return this.parseFunctionOrFunctionSent();
-
-      case _types.types.at:
-        this.parseDecorators();
-
-      case _types.types._class:
-        node = this.startNode();
-        this.takeDecorators(node);
-        return this.parseClass(node, false);
-
-      case _types.types._new:
-        return this.parseNewOrNewTarget();
-
-      case _types.types.backQuote:
-        return this.parseTemplate(false);
-
-      case _types.types.doubleColon:
-        {
-          node = this.startNode();
-          this.next();
-          node.object = null;
-          const callee = node.callee = this.parseNoCallExpr();
-
-          if (callee.type === "MemberExpression") {
-            return this.finishNode(node, "BindExpression");
-          } else {
-            throw this.raise(callee.start, _error.Errors.UnsupportedBind);
-          }
-        }
-
-      case _types.types.hash:
-        {
-          if (this.state.inPipeline) {
-            node = this.startNode();
-
-            if (this.getPluginOption("pipelineOperator", "proposal") !== "smart") {
-              this.raise(node.start, _error.Errors.PrimaryTopicRequiresSmartPipeline);
-            }
-
-            this.next();
-
-            if (!this.primaryTopicReferenceIsAllowedInCurrentTopicContext()) {
-              this.raise(node.start, _error.Errors.PrimaryTopicNotAllowed);
-            }
-
-            this.registerTopicReference();
-            return this.finishNode(node, "PipelinePrimaryTopicReference");
-          }
-
-          const nextCh = this.input.codePointAt(this.state.end);
-
-          if ((0, _identifier.isIdentifierStart)(nextCh) || nextCh === 92) {
-            const start = this.state.start;
-            node = this.parseMaybePrivateName(true);
-
-            if (this.match(_types.types._in)) {
-              this.expectPlugin("privateIn");
-              this.classScope.usePrivateName(node.id.name, node.start);
-            } else if (this.hasPlugin("privateIn")) {
-              this.raise(this.state.start, _error.Errors.PrivateInExpectedIn, node.id.name);
-            } else {
-              throw this.unexpected(start);
-            }
-
-            return node;
-          }
-        }
-
-      case _types.types.relational:
-        {
-          if (this.state.value === "<") {
-            const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
-
-            if ((0, _identifier.isIdentifierStart)(lookaheadCh) || lookaheadCh === 62) {
-                this.expectOnePlugin(["jsx", "flow", "typescript"]);
-              }
-          }
-        }
-
-      default:
-        throw this.unexpected();
-    }
-  }
-
-  parseAsyncArrowUnaryFunction(id) {
-    const node = this.startNodeAtNode(id);
-    this.prodParam.enter((0, _productionParameter.functionFlags)(true, this.prodParam.hasYield));
-    const params = [this.parseIdentifier()];
-    this.prodParam.exit();
-
-    if (this.hasPrecedingLineBreak()) {
-      this.raise(this.state.pos, _error.Errors.LineTerminatorBeforeArrow);
-    }
-
-    this.expect(_types.types.arrow);
-    this.parseArrowExpression(node, params, true);
-    return node;
-  }
-
-  parseDo() {
-    this.expectPlugin("doExpressions");
-    const node = this.startNode();
-    this.next();
-    const oldLabels = this.state.labels;
-    this.state.labels = [];
-    node.body = this.parseBlock();
-    this.state.labels = oldLabels;
-    return this.finishNode(node, "DoExpression");
-  }
-
-  parseSuper() {
-    const node = this.startNode();
-    this.next();
-
-    if (this.match(_types.types.parenL) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
-      this.raise(node.start, _error.Errors.SuperNotAllowed);
-    } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
-      this.raise(node.start, _error.Errors.UnexpectedSuper);
-    }
-
-    if (!this.match(_types.types.parenL) && !this.match(_types.types.bracketL) && !this.match(_types.types.dot)) {
-      this.raise(node.start, _error.Errors.UnsupportedSuper);
-    }
-
-    return this.finishNode(node, "Super");
-  }
-
-  parseBooleanLiteral() {
-    const node = this.startNode();
-    node.value = this.match(_types.types._true);
-    this.next();
-    return this.finishNode(node, "BooleanLiteral");
-  }
-
-  parseMaybePrivateName(isPrivateNameAllowed) {
-    const isPrivate = this.match(_types.types.hash);
-
-    if (isPrivate) {
-      this.expectOnePlugin(["classPrivateProperties", "classPrivateMethods"]);
-
-      if (!isPrivateNameAllowed) {
-        this.raise(this.state.pos, _error.Errors.UnexpectedPrivateField);
-      }
-
-      const node = this.startNode();
-      this.next();
-      this.assertNoSpace("Unexpected space between # and identifier");
-      node.id = this.parseIdentifier(true);
-      return this.finishNode(node, "PrivateName");
-    } else {
-      return this.parseIdentifier(true);
-    }
-  }
-
-  parseFunctionOrFunctionSent() {
-    const node = this.startNode();
-    this.next();
-
-    if (this.prodParam.hasYield && this.match(_types.types.dot)) {
-      const meta = this.createIdentifier(this.startNodeAtNode(node), "function");
-      this.next();
-      return this.parseMetaProperty(node, meta, "sent");
-    }
-
-    return this.parseFunction(node);
-  }
-
-  parseMetaProperty(node, meta, propertyName) {
-    node.meta = meta;
-
-    if (meta.name === "function" && propertyName === "sent") {
-      if (this.isContextual(propertyName)) {
-        this.expectPlugin("functionSent");
-      } else if (!this.hasPlugin("functionSent")) {
-        this.unexpected();
-      }
-    }
-
-    const containsEsc = this.state.containsEsc;
-    node.property = this.parseIdentifier(true);
-
-    if (node.property.name !== propertyName || containsEsc) {
-      this.raise(node.property.start, _error.Errors.UnsupportedMetaProperty, meta.name, propertyName);
-    }
-
-    return this.finishNode(node, "MetaProperty");
-  }
-
-  parseImportMetaProperty(node) {
-    const id = this.createIdentifier(this.startNodeAtNode(node), "import");
-    this.next();
-
-    if (this.isContextual("meta")) {
-      if (!this.inModule) {
-        this.raiseWithData(id.start, {
-          code: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
-        }, _error.Errors.ImportMetaOutsideModule);
-      }
-
-      this.sawUnambiguousESM = true;
-    }
-
-    return this.parseMetaProperty(node, id, "meta");
-  }
-
-  parseLiteral(value, type, startPos, startLoc) {
-    startPos = startPos || this.state.start;
-    startLoc = startLoc || this.state.startLoc;
-    const node = this.startNodeAt(startPos, startLoc);
-    this.addExtra(node, "rawValue", value);
-    this.addExtra(node, "raw", this.input.slice(startPos, this.state.end));
-    node.value = value;
-    this.next();
-    return this.finishNode(node, type);
-  }
-
-  parseParenAndDistinguishExpression(canBeArrow) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    let val;
-    this.next();
-    this.expressionScope.enter((0, _expressionScope.newArrowHeadScope)());
-    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
-    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-    this.state.maybeInArrowParameters = true;
-    this.state.inFSharpPipelineDirectBody = false;
-    const innerStartPos = this.state.start;
-    const innerStartLoc = this.state.startLoc;
-    const exprList = [];
-    const refExpressionErrors = new _util.ExpressionErrors();
-    const refNeedsArrowPos = {
-      start: 0
-    };
-    let first = true;
-    let spreadStart;
-    let optionalCommaStart;
-
-    while (!this.match(_types.types.parenR)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma, refNeedsArrowPos.start || null);
-
-        if (this.match(_types.types.parenR)) {
-          optionalCommaStart = this.state.start;
-          break;
-        }
-      }
-
-      if (this.match(_types.types.ellipsis)) {
-        const spreadNodeStartPos = this.state.start;
-        const spreadNodeStartLoc = this.state.startLoc;
-        spreadStart = this.state.start;
-        exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartPos, spreadNodeStartLoc));
-        this.checkCommaAfterRest(41);
-        break;
-      } else {
-        exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem, refNeedsArrowPos));
-      }
-    }
-
-    const innerEndPos = this.state.lastTokEnd;
-    const innerEndLoc = this.state.lastTokEndLoc;
-    this.expect(_types.types.parenR);
-    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-    let arrowNode = this.startNodeAt(startPos, startLoc);
-
-    if (canBeArrow && this.shouldParseArrow() && (arrowNode = this.parseArrow(arrowNode))) {
-      this.expressionScope.validateAsPattern();
-      this.expressionScope.exit();
-
-      for (let _i2 = 0; _i2 < exprList.length; _i2++) {
-        const param = exprList[_i2];
-
-        if (param.extra && param.extra.parenthesized) {
-          this.unexpected(param.extra.parenStart);
-        }
-      }
-
-      this.parseArrowExpression(arrowNode, exprList, false);
-      return arrowNode;
-    }
-
-    this.expressionScope.exit();
-
-    if (!exprList.length) {
-      this.unexpected(this.state.lastTokStart);
-    }
-
-    if (optionalCommaStart) this.unexpected(optionalCommaStart);
-    if (spreadStart) this.unexpected(spreadStart);
-    this.checkExpressionErrors(refExpressionErrors, true);
-    if (refNeedsArrowPos.start) this.unexpected(refNeedsArrowPos.start);
-    this.toReferencedListDeep(exprList, true);
-
-    if (exprList.length > 1) {
-      val = this.startNodeAt(innerStartPos, innerStartLoc);
-      val.expressions = exprList;
-      this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
-    } else {
-      val = exprList[0];
-    }
-
-    if (!this.options.createParenthesizedExpressions) {
-      this.addExtra(val, "parenthesized", true);
-      this.addExtra(val, "parenStart", startPos);
-      return val;
-    }
-
-    const parenExpression = this.startNodeAt(startPos, startLoc);
-    parenExpression.expression = val;
-    this.finishNode(parenExpression, "ParenthesizedExpression");
-    return parenExpression;
-  }
-
-  shouldParseArrow() {
-    return !this.canInsertSemicolon();
-  }
-
-  parseArrow(node) {
-    if (this.eat(_types.types.arrow)) {
-      return node;
-    }
-  }
-
-  parseParenItem(node, startPos, startLoc) {
-    return node;
-  }
-
-  parseNewOrNewTarget() {
-    const node = this.startNode();
-    this.next();
-
-    if (this.match(_types.types.dot)) {
-      const meta = this.createIdentifier(this.startNodeAtNode(node), "new");
-      this.next();
-      const metaProp = this.parseMetaProperty(node, meta, "target");
-
-      if (!this.scope.inNonArrowFunction && !this.scope.inClass) {
-        let error = _error.Errors.UnexpectedNewTarget;
-
-        if (this.hasPlugin("classProperties")) {
-          error += " or class properties";
-        }
-
-        this.raise(metaProp.start, error);
-      }
-
-      return metaProp;
-    }
-
-    return this.parseNew(node);
-  }
-
-  parseNew(node) {
-    node.callee = this.parseNoCallExpr();
-
-    if (node.callee.type === "Import") {
-      this.raise(node.callee.start, _error.Errors.ImportCallNotNewExpression);
-    } else if (node.callee.type === "OptionalMemberExpression" || node.callee.type === "OptionalCallExpression") {
-      this.raise(this.state.lastTokEnd, _error.Errors.OptionalChainingNoNew);
-    } else if (this.eat(_types.types.questionDot)) {
-      this.raise(this.state.start, _error.Errors.OptionalChainingNoNew);
-    }
-
-    this.parseNewArguments(node);
-    return this.finishNode(node, "NewExpression");
-  }
-
-  parseNewArguments(node) {
-    if (this.eat(_types.types.parenL)) {
-      const args = this.parseExprList(_types.types.parenR);
-      this.toReferencedList(args);
-      node.arguments = args;
-    } else {
-      node.arguments = [];
-    }
-  }
-
-  parseTemplateElement(isTagged) {
-    const elem = this.startNode();
-
-    if (this.state.value === null) {
-      if (!isTagged) {
-        this.raise(this.state.start + 1, _error.Errors.InvalidEscapeSequenceTemplate);
-      }
-    }
-
-    elem.value = {
-      raw: this.input.slice(this.state.start, this.state.end).replace(/\r\n?/g, "\n"),
-      cooked: this.state.value
-    };
-    this.next();
-    elem.tail = this.match(_types.types.backQuote);
-    return this.finishNode(elem, "TemplateElement");
-  }
-
-  parseTemplate(isTagged) {
-    const node = this.startNode();
-    this.next();
-    node.expressions = [];
-    let curElt = this.parseTemplateElement(isTagged);
-    node.quasis = [curElt];
-
-    while (!curElt.tail) {
-      this.expect(_types.types.dollarBraceL);
-      node.expressions.push(this.parseTemplateSubstitution());
-      this.expect(_types.types.braceR);
-      node.quasis.push(curElt = this.parseTemplateElement(isTagged));
-    }
-
-    this.next();
-    return this.finishNode(node, "TemplateLiteral");
-  }
-
-  parseTemplateSubstitution() {
-    return this.parseExpression();
-  }
-
-  parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {
-    if (isRecord) {
-      this.expectPlugin("recordAndTuple");
-    }
-
-    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-    this.state.inFSharpPipelineDirectBody = false;
-    const propHash = Object.create(null);
-    let first = true;
-    const node = this.startNode();
-    node.properties = [];
-    this.next();
-
-    while (!this.match(close)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma);
-
-        if (this.match(close)) {
-          this.addExtra(node, "trailingComma", this.state.lastTokStart);
-          break;
-        }
-      }
-
-      const prop = this.parsePropertyDefinition(isPattern, refExpressionErrors);
-
-      if (!isPattern) {
-        this.checkProto(prop, isRecord, propHash, refExpressionErrors);
-      }
-
-      if (isRecord && prop.type !== "ObjectProperty" && prop.type !== "SpreadElement") {
-        this.raise(prop.start, _error.Errors.InvalidRecordProperty);
-      }
-
-      if (prop.shorthand) {
-        this.addExtra(prop, "shorthand", true);
-      }
-
-      node.properties.push(prop);
-    }
-
-    this.state.exprAllowed = false;
-    this.next();
-    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-    let type = "ObjectExpression";
-
-    if (isPattern) {
-      type = "ObjectPattern";
-    } else if (isRecord) {
-      type = "RecordExpression";
-    }
-
-    return this.finishNode(node, type);
-  }
-
-  maybeAsyncOrAccessorProp(prop) {
-    return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(_types.types.bracketL) || this.match(_types.types.star));
-  }
-
-  parsePropertyDefinition(isPattern, refExpressionErrors) {
-    let decorators = [];
-
-    if (this.match(_types.types.at)) {
-      if (this.hasPlugin("decorators")) {
-        this.raise(this.state.start, _error.Errors.UnsupportedPropertyDecorator);
-      }
-
-      while (this.match(_types.types.at)) {
-        decorators.push(this.parseDecorator());
-      }
-    }
-
-    const prop = this.startNode();
-    let isGenerator = false;
-    let isAsync = false;
-    let isAccessor = false;
-    let startPos;
-    let startLoc;
-
-    if (this.match(_types.types.ellipsis)) {
-      if (decorators.length) this.unexpected();
-
-      if (isPattern) {
-        this.next();
-        prop.argument = this.parseIdentifier();
-        this.checkCommaAfterRest(125);
-        return this.finishNode(prop, "RestElement");
-      }
-
-      return this.parseSpread();
-    }
-
-    if (decorators.length) {
-      prop.decorators = decorators;
-      decorators = [];
-    }
-
-    prop.method = false;
-
-    if (isPattern || refExpressionErrors) {
-      startPos = this.state.start;
-      startLoc = this.state.startLoc;
-    }
-
-    if (!isPattern) {
-      isGenerator = this.eat(_types.types.star);
-    }
-
-    const containsEsc = this.state.containsEsc;
-    const key = this.parsePropertyName(prop, false);
-
-    if (!isPattern && !isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {
-      const keyName = key.name;
-
-      if (keyName === "async" && !this.hasPrecedingLineBreak()) {
-        isAsync = true;
-        isGenerator = this.eat(_types.types.star);
-        this.parsePropertyName(prop, false);
-      }
-
-      if (keyName === "get" || keyName === "set") {
-        isAccessor = true;
-        prop.kind = keyName;
-
-        if (this.match(_types.types.star)) {
-          isGenerator = true;
-          this.raise(this.state.pos, _error.Errors.AccessorIsGenerator, keyName);
-          this.next();
-        }
-
-        this.parsePropertyName(prop, false);
-      }
-    }
-
-    this.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
-    return prop;
-  }
-
-  getGetterSetterExpectedParamCount(method) {
-    return method.kind === "get" ? 0 : 1;
-  }
-
-  getObjectOrClassMethodParams(method) {
-    return method.params;
-  }
-
-  checkGetterSetterParams(method) {
-    const paramCount = this.getGetterSetterExpectedParamCount(method);
-    const params = this.getObjectOrClassMethodParams(method);
-    const start = method.start;
-
-    if (params.length !== paramCount) {
-      if (method.kind === "get") {
-        this.raise(start, _error.Errors.BadGetterArity);
-      } else {
-        this.raise(start, _error.Errors.BadSetterArity);
-      }
-    }
-
-    if (method.kind === "set" && params[params.length - 1]?.type === "RestElement") {
-      this.raise(start, _error.Errors.BadSetterRestParameter);
-    }
-  }
-
-  parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
-    if (isAccessor) {
-      this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod");
-      this.checkGetterSetterParams(prop);
-      return prop;
-    }
-
-    if (isAsync || isGenerator || this.match(_types.types.parenL)) {
-      if (isPattern) this.unexpected();
-      prop.kind = "method";
-      prop.method = true;
-      return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod");
-    }
-  }
-
-  parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) {
-    prop.shorthand = false;
-
-    if (this.eat(_types.types.colon)) {
-      prop.value = isPattern ? this.parseMaybeDefault(this.state.start, this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors);
-      return this.finishNode(prop, "ObjectProperty");
-    }
-
-    if (!prop.computed && prop.key.type === "Identifier") {
-      this.checkReservedWord(prop.key.name, prop.key.start, true, false);
-
-      if (isPattern) {
-        prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());
-      } else if (this.match(_types.types.eq) && refExpressionErrors) {
-        if (refExpressionErrors.shorthandAssign === -1) {
-          refExpressionErrors.shorthandAssign = this.state.start;
-        }
-
-        prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());
-      } else {
-        prop.value = prop.key.__clone();
-      }
-
-      prop.shorthand = true;
-      return this.finishNode(prop, "ObjectProperty");
-    }
-  }
-
-  parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
-    const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors);
-    if (!node) this.unexpected();
-    return node;
-  }
-
-  parsePropertyName(prop, isPrivateNameAllowed) {
-    if (this.eat(_types.types.bracketL)) {
-      prop.computed = true;
-      prop.key = this.parseMaybeAssignAllowIn();
-      this.expect(_types.types.bracketR);
-    } else {
-      const oldInPropertyName = this.state.inPropertyName;
-      this.state.inPropertyName = true;
-      prop.key = this.match(_types.types.num) || this.match(_types.types.string) || this.match(_types.types.bigint) || this.match(_types.types.decimal) ? this.parseExprAtom() : this.parseMaybePrivateName(isPrivateNameAllowed);
-
-      if (prop.key.type !== "PrivateName") {
-        prop.computed = false;
-      }
-
-      this.state.inPropertyName = oldInPropertyName;
-    }
-
-    return prop.key;
-  }
-
-  initFunction(node, isAsync) {
-    node.id = null;
-    node.generator = false;
-    node.async = !!isAsync;
-  }
-
-  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
-    this.initFunction(node, isAsync);
-    node.generator = !!isGenerator;
-    const allowModifiers = isConstructor;
-    this.scope.enter(_scopeflags.SCOPE_FUNCTION | _scopeflags.SCOPE_SUPER | (inClassScope ? _scopeflags.SCOPE_CLASS : 0) | (allowDirectSuper ? _scopeflags.SCOPE_DIRECT_SUPER : 0));
-    this.prodParam.enter((0, _productionParameter.functionFlags)(isAsync, node.generator));
-    this.parseFunctionParams(node, allowModifiers);
-    this.parseFunctionBodyAndFinish(node, type, true);
-    this.prodParam.exit();
-    this.scope.exit();
-    return node;
-  }
-
-  parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
-    if (isTuple) {
-      this.expectPlugin("recordAndTuple");
-    }
-
-    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-    this.state.inFSharpPipelineDirectBody = false;
-    const node = this.startNode();
-    this.next();
-    node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node);
-    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-    return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression");
-  }
-
-  parseArrowExpression(node, params, isAsync, trailingCommaPos) {
-    this.scope.enter(_scopeflags.SCOPE_FUNCTION | _scopeflags.SCOPE_ARROW);
-    let flags = (0, _productionParameter.functionFlags)(isAsync, false);
-
-    if (!this.match(_types.types.bracketL) && this.prodParam.hasIn) {
-      flags |= _productionParameter.PARAM_IN;
-    }
-
-    this.prodParam.enter(flags);
-    this.initFunction(node, isAsync);
-    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
-
-    if (params) {
-      this.state.maybeInArrowParameters = true;
-      this.setArrowFunctionParameters(node, params, trailingCommaPos);
-    }
-
-    this.state.maybeInArrowParameters = false;
-    this.parseFunctionBody(node, true);
-    this.prodParam.exit();
-    this.scope.exit();
-    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-    return this.finishNode(node, "ArrowFunctionExpression");
-  }
-
-  setArrowFunctionParameters(node, params, trailingCommaPos) {
-    node.params = this.toAssignableList(params, trailingCommaPos);
-  }
-
-  parseFunctionBodyAndFinish(node, type, isMethod = false) {
-    this.parseFunctionBody(node, false, isMethod);
-    this.finishNode(node, type);
-  }
-
-  parseFunctionBody(node, allowExpression, isMethod = false) {
-    const isExpression = allowExpression && !this.match(_types.types.braceL);
-    this.expressionScope.enter((0, _expressionScope.newExpressionScope)());
-
-    if (isExpression) {
-      node.body = this.parseMaybeAssign();
-      this.checkParams(node, false, allowExpression, false);
-    } else {
-      const oldStrict = this.state.strict;
-      const oldLabels = this.state.labels;
-      this.state.labels = [];
-      this.prodParam.enter(this.prodParam.currentFlags() | _productionParameter.PARAM_RETURN);
-      node.body = this.parseBlock(true, false, hasStrictModeDirective => {
-        const nonSimple = !this.isSimpleParamList(node.params);
-
-        if (hasStrictModeDirective && nonSimple) {
-          const errorPos = (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.end : node.start;
-          this.raise(errorPos, _error.Errors.IllegalLanguageModeDirective);
-        }
-
-        const strictModeChanged = !oldStrict && this.state.strict;
-        this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
-
-        if (this.state.strict && node.id) {
-          this.checkLVal(node.id, _scopeflags.BIND_OUTSIDE, undefined, "function name", undefined, strictModeChanged);
-        }
-      });
-      this.prodParam.exit();
-      this.expressionScope.exit();
-      this.state.labels = oldLabels;
-    }
-  }
-
-  isSimpleParamList(params) {
-    for (let i = 0, len = params.length; i < len; i++) {
-      if (params[i].type !== "Identifier") return false;
-    }
-
-    return true;
-  }
-
-  checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
-    const nameHash = Object.create(null);
-
-    for (let i = 0; i < node.params.length; i++) {
-      this.checkLVal(node.params[i], _scopeflags.BIND_VAR, allowDuplicates ? null : nameHash, "function parameter list", undefined, strictModeChanged);
-    }
-  }
-
-  parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) {
-    const elts = [];
-    let first = true;
-
-    while (!this.eat(close)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma);
-
-        if (this.match(close)) {
-          if (nodeForExtra) {
-            this.addExtra(nodeForExtra, "trailingComma", this.state.lastTokStart);
-          }
-
-          this.next();
-          break;
-        }
-      }
-
-      elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));
-    }
-
-    return elts;
-  }
-
-  parseExprListItem(allowEmpty, refExpressionErrors, refNeedsArrowPos, allowPlaceholder) {
-    let elt;
-
-    if (this.match(_types.types.comma)) {
-      if (!allowEmpty) {
-        this.raise(this.state.pos, _error.Errors.UnexpectedToken, ",");
-      }
-
-      elt = null;
-    } else if (this.match(_types.types.ellipsis)) {
-      const spreadNodeStartPos = this.state.start;
-      const spreadNodeStartLoc = this.state.startLoc;
-      elt = this.parseParenItem(this.parseSpread(refExpressionErrors, refNeedsArrowPos), spreadNodeStartPos, spreadNodeStartLoc);
-    } else if (this.match(_types.types.question)) {
-      this.expectPlugin("partialApplication");
-
-      if (!allowPlaceholder) {
-        this.raise(this.state.start, _error.Errors.UnexpectedArgumentPlaceholder);
-      }
-
-      const node = this.startNode();
-      this.next();
-      elt = this.finishNode(node, "ArgumentPlaceholder");
-    } else {
-      elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem, refNeedsArrowPos);
-    }
-
-    return elt;
-  }
-
-  parseIdentifier(liberal) {
-    const node = this.startNode();
-    const name = this.parseIdentifierName(node.start, liberal);
-    return this.createIdentifier(node, name);
-  }
-
-  createIdentifier(node, name) {
-    node.name = name;
-    node.loc.identifierName = name;
-    return this.finishNode(node, "Identifier");
-  }
-
-  parseIdentifierName(pos, liberal) {
-    let name;
-    const {
-      start,
-      type
-    } = this.state;
-
-    if (type === _types.types.name) {
-      name = this.state.value;
-    } else if (type.keyword) {
-      name = type.keyword;
-      const curContext = this.curContext();
-
-      if ((type === _types.types._class || type === _types.types._function) && (curContext === _context.types.functionStatement || curContext === _context.types.functionExpression)) {
-        this.state.context.pop();
-      }
-    } else {
-      throw this.unexpected();
-    }
-
-    if (liberal) {
-      this.state.type = _types.types.name;
-    } else {
-      this.checkReservedWord(name, start, !!type.keyword, false);
-    }
-
-    this.next();
-    return name;
-  }
-
-  checkReservedWord(word, startLoc, checkKeywords, isBinding) {
-    if (this.prodParam.hasYield && word === "yield") {
-      this.raise(startLoc, _error.Errors.YieldBindingIdentifier);
-      return;
-    }
-
-    if (word === "await") {
-      if (this.prodParam.hasAwait) {
-        this.raise(startLoc, _error.Errors.AwaitBindingIdentifier);
-        return;
-      } else {
-        this.expressionScope.recordAsyncArrowParametersError(startLoc, _error.Errors.AwaitBindingIdentifier);
-      }
-    }
-
-    if (this.scope.inClass && !this.scope.inNonArrowFunction && word === "arguments") {
-      this.raise(startLoc, _error.Errors.ArgumentsInClass);
-      return;
-    }
-
-    if (checkKeywords && (0, _identifier.isKeyword)(word)) {
-      this.raise(startLoc, _error.Errors.UnexpectedKeyword, word);
-      return;
-    }
-
-    const reservedTest = !this.state.strict ? _identifier.isReservedWord : isBinding ? _identifier.isStrictBindReservedWord : _identifier.isStrictReservedWord;
-
-    if (reservedTest(word, this.inModule)) {
-      if (!this.prodParam.hasAwait && word === "await") {
-        this.raise(startLoc, this.hasPlugin("topLevelAwait") ? _error.Errors.AwaitNotInAsyncContext : _error.Errors.AwaitNotInAsyncFunction);
-      } else {
-        this.raise(startLoc, _error.Errors.UnexpectedReservedWord, word);
-      }
-    }
-  }
-
-  isAwaitAllowed() {
-    if (this.scope.inFunction) return this.prodParam.hasAwait;
-    if (this.options.allowAwaitOutsideFunction) return true;
-
-    if (this.hasPlugin("topLevelAwait")) {
-      return this.inModule && this.prodParam.hasAwait;
-    }
-
-    return false;
-  }
-
-  parseAwait() {
-    const node = this.startNode();
-    this.next();
-    this.expressionScope.recordParameterInitializerError(node.start, _error.Errors.AwaitExpressionFormalParameter);
-
-    if (this.eat(_types.types.star)) {
-      this.raise(node.start, _error.Errors.ObsoleteAwaitStar);
-    }
-
-    if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
-      if (this.hasPrecedingLineBreak() || this.match(_types.types.plusMin) || this.match(_types.types.parenL) || this.match(_types.types.bracketL) || this.match(_types.types.backQuote) || this.match(_types.types.regexp) || this.match(_types.types.slash) || this.hasPlugin("v8intrinsic") && this.match(_types.types.modulo)) {
-        this.ambiguousScriptDifferentAst = true;
-      } else {
-        this.sawUnambiguousESM = true;
-      }
-    }
-
-    if (!this.state.soloAwait) {
-      node.argument = this.parseMaybeUnary();
-    }
-
-    return this.finishNode(node, "AwaitExpression");
-  }
-
-  parseYield() {
-    const node = this.startNode();
-    this.expressionScope.recordParameterInitializerError(node.start, _error.Errors.YieldInParameter);
-    this.next();
-
-    if (this.match(_types.types.semi) || !this.match(_types.types.star) && !this.state.type.startsExpr || this.hasPrecedingLineBreak()) {
-      node.delegate = false;
-      node.argument = null;
-    } else {
-      node.delegate = this.eat(_types.types.star);
-      node.argument = this.parseMaybeAssign();
-    }
-
-    return this.finishNode(node, "YieldExpression");
-  }
-
-  checkPipelineAtInfixOperator(left, leftStartPos) {
-    if (this.getPluginOption("pipelineOperator", "proposal") === "smart") {
-      if (left.type === "SequenceExpression") {
-        this.raise(leftStartPos, _error.Errors.PipelineHeadSequenceExpression);
-      }
-    }
-  }
-
-  parseSmartPipelineBody(childExpression, startPos, startLoc) {
-    this.checkSmartPipelineBodyEarlyErrors(childExpression, startPos);
-    return this.parseSmartPipelineBodyInStyle(childExpression, startPos, startLoc);
-  }
-
-  checkSmartPipelineBodyEarlyErrors(childExpression, startPos) {
-    if (this.match(_types.types.arrow)) {
-      throw this.raise(this.state.start, _error.Errors.PipelineBodyNoArrow);
-    } else if (childExpression.type === "SequenceExpression") {
-      this.raise(startPos, _error.Errors.PipelineBodySequenceExpression);
-    }
-  }
-
-  parseSmartPipelineBodyInStyle(childExpression, startPos, startLoc) {
-    const bodyNode = this.startNodeAt(startPos, startLoc);
-    const isSimpleReference = this.isSimpleReference(childExpression);
-
-    if (isSimpleReference) {
-      bodyNode.callee = childExpression;
-    } else {
-      if (!this.topicReferenceWasUsedInCurrentTopicContext()) {
-        this.raise(startPos, _error.Errors.PipelineTopicUnused);
-      }
-
-      bodyNode.expression = childExpression;
-    }
-
-    return this.finishNode(bodyNode, isSimpleReference ? "PipelineBareFunction" : "PipelineTopicExpression");
-  }
-
-  isSimpleReference(expression) {
-    switch (expression.type) {
-      case "MemberExpression":
-        return !expression.computed && this.isSimpleReference(expression.object);
-
-      case "Identifier":
-        return true;
-
-      default:
-        return false;
-    }
-  }
-
-  withTopicPermittingContext(callback) {
-    const outerContextTopicState = this.state.topicContext;
-    this.state.topicContext = {
-      maxNumOfResolvableTopics: 1,
-      maxTopicIndex: null
-    };
-
-    try {
-      return callback();
-    } finally {
-      this.state.topicContext = outerContextTopicState;
-    }
-  }
-
-  withTopicForbiddingContext(callback) {
-    const outerContextTopicState = this.state.topicContext;
-    this.state.topicContext = {
-      maxNumOfResolvableTopics: 0,
-      maxTopicIndex: null
-    };
-
-    try {
-      return callback();
-    } finally {
-      this.state.topicContext = outerContextTopicState;
-    }
-  }
-
-  withSoloAwaitPermittingContext(callback) {
-    const outerContextSoloAwaitState = this.state.soloAwait;
-    this.state.soloAwait = true;
-
-    try {
-      return callback();
-    } finally {
-      this.state.soloAwait = outerContextSoloAwaitState;
-    }
-  }
-
-  allowInAnd(callback) {
-    const flags = this.prodParam.currentFlags();
-    const prodParamToSet = _productionParameter.PARAM_IN & ~flags;
-
-    if (prodParamToSet) {
-      this.prodParam.enter(flags | _productionParameter.PARAM_IN);
-
-      try {
-        return callback();
-      } finally {
-        this.prodParam.exit();
-      }
-    }
-
-    return callback();
-  }
-
-  disallowInAnd(callback) {
-    const flags = this.prodParam.currentFlags();
-    const prodParamToClear = _productionParameter.PARAM_IN & flags;
-
-    if (prodParamToClear) {
-      this.prodParam.enter(flags & ~_productionParameter.PARAM_IN);
-
-      try {
-        return callback();
-      } finally {
-        this.prodParam.exit();
-      }
-    }
-
-    return callback();
-  }
-
-  registerTopicReference() {
-    this.state.topicContext.maxTopicIndex = 0;
-  }
-
-  primaryTopicReferenceIsAllowedInCurrentTopicContext() {
-    return this.state.topicContext.maxNumOfResolvableTopics >= 1;
-  }
-
-  topicReferenceWasUsedInCurrentTopicContext() {
-    return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;
-  }
-
-  parseFSharpPipelineBody(prec) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    this.state.potentialArrowAt = this.state.start;
-    const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-    this.state.inFSharpPipelineDirectBody = true;
-    const ret = this.parseExprOp(this.parseMaybeUnary(), startPos, startLoc, prec);
-    this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
-    return ret;
-  }
-
-}
-
-exports.default = ExpressionParser;

node_modules/@babel/parser/lib/parser/index.js

@@ -1,79 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _options = require("../options");
-
-var _statement = _interopRequireDefault(require("./statement"));
-
-var _scopeflags = require("../util/scopeflags");
-
-var _scope = _interopRequireDefault(require("../util/scope"));
-
-var _classScope = _interopRequireDefault(require("../util/class-scope"));
-
-var _expressionScope = _interopRequireDefault(require("../util/expression-scope"));
-
-var _productionParameter = _interopRequireWildcard(require("../util/production-parameter"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class Parser extends _statement.default {
-  constructor(options, input) {
-    options = (0, _options.getOptions)(options);
-    super(options, input);
-    const ScopeHandler = this.getScopeHandler();
-    this.options = options;
-    this.inModule = this.options.sourceType === "module";
-    this.scope = new ScopeHandler(this.raise.bind(this), this.inModule);
-    this.prodParam = new _productionParameter.default();
-    this.classScope = new _classScope.default(this.raise.bind(this));
-    this.expressionScope = new _expressionScope.default(this.raise.bind(this));
-    this.plugins = pluginsMap(this.options.plugins);
-    this.filename = options.sourceFilename;
-  }
-
-  getScopeHandler() {
-    return _scope.default;
-  }
-
-  parse() {
-    let paramFlags = _productionParameter.PARAM;
-
-    if (this.hasPlugin("topLevelAwait") && this.inModule) {
-      paramFlags |= _productionParameter.PARAM_AWAIT;
-    }
-
-    this.scope.enter(_scopeflags.SCOPE_PROGRAM);
-    this.prodParam.enter(paramFlags);
-    const file = this.startNode();
-    const program = this.startNode();
-    this.nextToken();
-    file.errors = null;
-    this.parseTopLevel(file, program);
-    file.errors = this.state.errors;
-    return file;
-  }
-
-}
-
-exports.default = Parser;
-
-function pluginsMap(plugins) {
-  const pluginMap = new Map();
-
-  for (let _i = 0; _i < plugins.length; _i++) {
-    const plugin = plugins[_i];
-    const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
-    if (!pluginMap.has(name)) pluginMap.set(name, options || {});
-  }
-
-  return pluginMap;
-}

node_modules/@babel/parser/lib/parser/lval.js

@@ -1,358 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _types = require("../tokenizer/types");
-
-var _identifier = require("../util/identifier");
-
-var _node = require("./node");
-
-var _scopeflags = require("../util/scopeflags");
-
-var _util = require("./util");
-
-var _error = require("./error");
-
-const unwrapParenthesizedExpression = node => {
-  return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
-};
-
-class LValParser extends _node.NodeUtils {
-  toAssignable(node) {
-    let parenthesized = undefined;
-
-    if (node.type === "ParenthesizedExpression" || node.extra?.parenthesized) {
-      parenthesized = unwrapParenthesizedExpression(node);
-
-      if (parenthesized.type !== "Identifier" && parenthesized.type !== "MemberExpression") {
-        this.raise(node.start, _error.Errors.InvalidParenthesizedAssignment);
-      }
-    }
-
-    switch (node.type) {
-      case "Identifier":
-      case "ObjectPattern":
-      case "ArrayPattern":
-      case "AssignmentPattern":
-        break;
-
-      case "ObjectExpression":
-        node.type = "ObjectPattern";
-
-        for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {
-          const prop = node.properties[i];
-          const isLast = i === last;
-          this.toAssignableObjectExpressionProp(prop, isLast);
-
-          if (isLast && prop.type === "RestElement" && node.extra?.trailingComma) {
-            this.raiseRestNotLast(node.extra.trailingComma);
-          }
-        }
-
-        break;
-
-      case "ObjectProperty":
-        this.toAssignable(node.value);
-        break;
-
-      case "SpreadElement":
-        {
-          this.checkToRestConversion(node);
-          node.type = "RestElement";
-          const arg = node.argument;
-          this.toAssignable(arg);
-          break;
-        }
-
-      case "ArrayExpression":
-        node.type = "ArrayPattern";
-        this.toAssignableList(node.elements, node.extra?.trailingComma);
-        break;
-
-      case "AssignmentExpression":
-        if (node.operator !== "=") {
-          this.raise(node.left.end, _error.Errors.MissingEqInAssignment);
-        }
-
-        node.type = "AssignmentPattern";
-        delete node.operator;
-        this.toAssignable(node.left);
-        break;
-
-      case "ParenthesizedExpression":
-        this.toAssignable(parenthesized);
-        break;
-
-      default:
-    }
-
-    return node;
-  }
-
-  toAssignableObjectExpressionProp(prop, isLast) {
-    if (prop.type === "ObjectMethod") {
-      const error = prop.kind === "get" || prop.kind === "set" ? _error.Errors.PatternHasAccessor : _error.Errors.PatternHasMethod;
-      this.raise(prop.key.start, error);
-    } else if (prop.type === "SpreadElement" && !isLast) {
-      this.raiseRestNotLast(prop.start);
-    } else {
-      this.toAssignable(prop);
-    }
-  }
-
-  toAssignableList(exprList, trailingCommaPos) {
-    let end = exprList.length;
-
-    if (end) {
-      const last = exprList[end - 1];
-
-      if (last?.type === "RestElement") {
-        --end;
-      } else if (last?.type === "SpreadElement") {
-        last.type = "RestElement";
-        const arg = last.argument;
-        this.toAssignable(arg);
-
-        if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern" && arg.type !== "ObjectPattern") {
-          this.unexpected(arg.start);
-        }
-
-        if (trailingCommaPos) {
-          this.raiseTrailingCommaAfterRest(trailingCommaPos);
-        }
-
-        --end;
-      }
-    }
-
-    for (let i = 0; i < end; i++) {
-      const elt = exprList[i];
-
-      if (elt) {
-        this.toAssignable(elt);
-
-        if (elt.type === "RestElement") {
-          this.raiseRestNotLast(elt.start);
-        }
-      }
-    }
-
-    return exprList;
-  }
-
-  toReferencedList(exprList, isParenthesizedExpr) {
-    return exprList;
-  }
-
-  toReferencedListDeep(exprList, isParenthesizedExpr) {
-    this.toReferencedList(exprList, isParenthesizedExpr);
-
-    for (let _i = 0; _i < exprList.length; _i++) {
-      const expr = exprList[_i];
-
-      if (expr?.type === "ArrayExpression") {
-        this.toReferencedListDeep(expr.elements);
-      }
-    }
-  }
-
-  parseSpread(refExpressionErrors, refNeedsArrowPos) {
-    const node = this.startNode();
-    this.next();
-    node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined, refNeedsArrowPos);
-    return this.finishNode(node, "SpreadElement");
-  }
-
-  parseRestBinding() {
-    const node = this.startNode();
-    this.next();
-    node.argument = this.parseBindingAtom();
-    return this.finishNode(node, "RestElement");
-  }
-
-  parseBindingAtom() {
-    switch (this.state.type) {
-      case _types.types.bracketL:
-        {
-          const node = this.startNode();
-          this.next();
-          node.elements = this.parseBindingList(_types.types.bracketR, 93, true);
-          return this.finishNode(node, "ArrayPattern");
-        }
-
-      case _types.types.braceL:
-        return this.parseObjectLike(_types.types.braceR, true);
-    }
-
-    return this.parseIdentifier();
-  }
-
-  parseBindingList(close, closeCharCode, allowEmpty, allowModifiers) {
-    const elts = [];
-    let first = true;
-
-    while (!this.eat(close)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types.types.comma);
-      }
-
-      if (allowEmpty && this.match(_types.types.comma)) {
-        elts.push(null);
-      } else if (this.eat(close)) {
-        break;
-      } else if (this.match(_types.types.ellipsis)) {
-        elts.push(this.parseAssignableListItemTypes(this.parseRestBinding()));
-        this.checkCommaAfterRest(closeCharCode);
-        this.expect(close);
-        break;
-      } else {
-        const decorators = [];
-
-        if (this.match(_types.types.at) && this.hasPlugin("decorators")) {
-          this.raise(this.state.start, _error.Errors.UnsupportedParameterDecorator);
-        }
-
-        while (this.match(_types.types.at)) {
-          decorators.push(this.parseDecorator());
-        }
-
-        elts.push(this.parseAssignableListItem(allowModifiers, decorators));
-      }
-    }
-
-    return elts;
-  }
-
-  parseAssignableListItem(allowModifiers, decorators) {
-    const left = this.parseMaybeDefault();
-    this.parseAssignableListItemTypes(left);
-    const elt = this.parseMaybeDefault(left.start, left.loc.start, left);
-
-    if (decorators.length) {
-      left.decorators = decorators;
-    }
-
-    return elt;
-  }
-
-  parseAssignableListItemTypes(param) {
-    return param;
-  }
-
-  parseMaybeDefault(startPos, startLoc, left) {
-    startLoc = startLoc ?? this.state.startLoc;
-    startPos = startPos ?? this.state.start;
-    left = left ?? this.parseBindingAtom();
-    if (!this.eat(_types.types.eq)) return left;
-    const node = this.startNodeAt(startPos, startLoc);
-    node.left = left;
-    node.right = this.parseMaybeAssignAllowIn();
-    return this.finishNode(node, "AssignmentPattern");
-  }
-
-  checkLVal(expr, bindingType = _scopeflags.BIND_NONE, checkClashes, contextDescription, disallowLetBinding, strictModeChanged = false) {
-    switch (expr.type) {
-      case "Identifier":
-        if (this.state.strict && (strictModeChanged ? (0, _identifier.isStrictBindReservedWord)(expr.name, this.inModule) : (0, _identifier.isStrictBindOnlyReservedWord)(expr.name))) {
-          this.raise(expr.start, bindingType === _scopeflags.BIND_NONE ? _error.Errors.StrictEvalArguments : _error.Errors.StrictEvalArgumentsBinding, expr.name);
-        }
-
-        if (checkClashes) {
-          const key = `_${expr.name}`;
-
-          if (checkClashes[key]) {
-            this.raise(expr.start, _error.Errors.ParamDupe);
-          } else {
-            checkClashes[key] = true;
-          }
-        }
-
-        if (disallowLetBinding && expr.name === "let") {
-          this.raise(expr.start, _error.Errors.LetInLexicalBinding);
-        }
-
-        if (!(bindingType & _scopeflags.BIND_NONE)) {
-          this.scope.declareName(expr.name, bindingType, expr.start);
-        }
-
-        break;
-
-      case "MemberExpression":
-        if (bindingType !== _scopeflags.BIND_NONE) {
-          this.raise(expr.start, _error.Errors.InvalidPropertyBindingPattern);
-        }
-
-        break;
-
-      case "ObjectPattern":
-        for (let _i2 = 0, _expr$properties = expr.properties; _i2 < _expr$properties.length; _i2++) {
-          let prop = _expr$properties[_i2];
-          if (prop.type === "ObjectProperty") prop = prop.value;else if (prop.type === "ObjectMethod") continue;
-          this.checkLVal(prop, bindingType, checkClashes, "object destructuring pattern", disallowLetBinding);
-        }
-
-        break;
-
-      case "ArrayPattern":
-        for (let _i3 = 0, _expr$elements = expr.elements; _i3 < _expr$elements.length; _i3++) {
-          const elem = _expr$elements[_i3];
-
-          if (elem) {
-            this.checkLVal(elem, bindingType, checkClashes, "array destructuring pattern", disallowLetBinding);
-          }
-        }
-
-        break;
-
-      case "AssignmentPattern":
-        this.checkLVal(expr.left, bindingType, checkClashes, "assignment pattern");
-        break;
-
-      case "RestElement":
-        this.checkLVal(expr.argument, bindingType, checkClashes, "rest element");
-        break;
-
-      case "ParenthesizedExpression":
-        this.checkLVal(expr.expression, bindingType, checkClashes, "parenthesized expression");
-        break;
-
-      default:
-        {
-          this.raise(expr.start, bindingType === _scopeflags.BIND_NONE ? _error.Errors.InvalidLhs : _error.Errors.InvalidLhsBinding, contextDescription);
-        }
-    }
-  }
-
-  checkToRestConversion(node) {
-    if (node.argument.type !== "Identifier" && node.argument.type !== "MemberExpression") {
-      this.raise(node.argument.start, _error.Errors.InvalidRestAssignmentPattern);
-    }
-  }
-
-  checkCommaAfterRest(close) {
-    if (this.match(_types.types.comma)) {
-      if (this.lookaheadCharCode() === close) {
-        this.raiseTrailingCommaAfterRest(this.state.start);
-      } else {
-        this.raiseRestNotLast(this.state.start);
-      }
-    }
-  }
-
-  raiseRestNotLast(pos) {
-    throw this.raise(pos, _error.Errors.ElementAfterRest);
-  }
-
-  raiseTrailingCommaAfterRest(pos) {
-    this.raise(pos, _error.Errors.RestTrailingComma);
-  }
-
-}
-
-exports.default = LValParser;

node_modules/@babel/parser/lib/parser/node.js

@@ -1,98 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.NodeUtils = void 0;
-
-var _util = _interopRequireDefault(require("./util"));
-
-var _location = require("../util/location");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class Node {
-  constructor(parser, pos, loc) {
-    this.type = void 0;
-    this.start = void 0;
-    this.end = void 0;
-    this.loc = void 0;
-    this.range = void 0;
-    this.leadingComments = void 0;
-    this.trailingComments = void 0;
-    this.innerComments = void 0;
-    this.extra = void 0;
-    this.type = "";
-    this.start = pos;
-    this.end = 0;
-    this.loc = new _location.SourceLocation(loc);
-    if (parser?.options.ranges) this.range = [pos, 0];
-    if (parser?.filename) this.loc.filename = parser.filename;
-  }
-
-  __clone() {
-    const newNode = new Node();
-    const keys = Object.keys(this);
-
-    for (let i = 0, length = keys.length; i < length; i++) {
-      const key = keys[i];
-
-      if (key !== "leadingComments" && key !== "trailingComments" && key !== "innerComments") {
-        newNode[key] = this[key];
-      }
-    }
-
-    return newNode;
-  }
-
-}
-
-class NodeUtils extends _util.default {
-  startNode() {
-    return new Node(this, this.state.start, this.state.startLoc);
-  }
-
-  startNodeAt(pos, loc) {
-    return new Node(this, pos, loc);
-  }
-
-  startNodeAtNode(type) {
-    return this.startNodeAt(type.start, type.loc.start);
-  }
-
-  finishNode(node, type) {
-    return this.finishNodeAt(node, type, this.state.lastTokEnd, this.state.lastTokEndLoc);
-  }
-
-  finishNodeAt(node, type, pos, loc) {
-    if (process.env.NODE_ENV !== "production" && node.end > 0) {
-      throw new Error("Do not call finishNode*() twice on the same node." + " Instead use resetEndLocation() or change type directly.");
-    }
-
-    node.type = type;
-    node.end = pos;
-    node.loc.end = loc;
-    if (this.options.ranges) node.range[1] = pos;
-    this.processComment(node);
-    return node;
-  }
-
-  resetStartLocation(node, start, startLoc) {
-    node.start = start;
-    node.loc.start = startLoc;
-    if (this.options.ranges) node.range[0] = start;
-  }
-
-  resetEndLocation(node, end = this.state.lastTokEnd, endLoc = this.state.lastTokEndLoc) {
-    node.end = end;
-    node.loc.end = endLoc;
-    if (this.options.ranges) node.range[1] = end;
-  }
-
-  resetStartLocationFromNode(node, locationNode) {
-    this.resetStartLocation(node, locationNode.start, locationNode.loc.start);
-  }
-
-}
-
-exports.NodeUtils = NodeUtils;

node_modules/@babel/parser/lib/parser/statement.js

@@ -1,1741 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var N = _interopRequireWildcard(require("../types"));
-
-var _types2 = require("../tokenizer/types");
-
-var _expression = _interopRequireDefault(require("./expression"));
-
-var _error = require("./error");
-
-var _identifier = require("../util/identifier");
-
-var _whitespace = require("../util/whitespace");
-
-var _scopeflags = require("../util/scopeflags");
-
-var _util = require("./util");
-
-var _productionParameter = require("../util/production-parameter");
-
-var _expressionScope = require("../util/expression-scope");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const loopLabel = {
-  kind: "loop"
-},
-      switchLabel = {
-  kind: "switch"
-};
-const FUNC_NO_FLAGS = 0b000,
-      FUNC_STATEMENT = 0b001,
-      FUNC_HANGING_STATEMENT = 0b010,
-      FUNC_NULLABLE_ID = 0b100;
-const loneSurrogate = /[\uD800-\uDFFF]/u;
-
-class StatementParser extends _expression.default {
-  parseTopLevel(file, program) {
-    program.sourceType = this.options.sourceType;
-    program.interpreter = this.parseInterpreterDirective();
-    this.parseBlockBody(program, true, true, _types2.types.eof);
-
-    if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
-      for (let _i = 0, _Array$from = Array.from(this.scope.undefinedExports); _i < _Array$from.length; _i++) {
-        const [name] = _Array$from[_i];
-        const pos = this.scope.undefinedExports.get(name);
-        this.raise(pos, _error.Errors.ModuleExportUndefined, name);
-      }
-    }
-
-    file.program = this.finishNode(program, "Program");
-    file.comments = this.state.comments;
-    if (this.options.tokens) file.tokens = this.tokens;
-    return this.finishNode(file, "File");
-  }
-
-  stmtToDirective(stmt) {
-    const expr = stmt.expression;
-    const directiveLiteral = this.startNodeAt(expr.start, expr.loc.start);
-    const directive = this.startNodeAt(stmt.start, stmt.loc.start);
-    const raw = this.input.slice(expr.start, expr.end);
-    const val = directiveLiteral.value = raw.slice(1, -1);
-    this.addExtra(directiveLiteral, "raw", raw);
-    this.addExtra(directiveLiteral, "rawValue", val);
-    directive.value = this.finishNodeAt(directiveLiteral, "DirectiveLiteral", expr.end, expr.loc.end);
-    return this.finishNodeAt(directive, "Directive", stmt.end, stmt.loc.end);
-  }
-
-  parseInterpreterDirective() {
-    if (!this.match(_types2.types.interpreterDirective)) {
-      return null;
-    }
-
-    const node = this.startNode();
-    node.value = this.state.value;
-    this.next();
-    return this.finishNode(node, "InterpreterDirective");
-  }
-
-  isLet(context) {
-    if (!this.isContextual("let")) {
-      return false;
-    }
-
-    const next = this.nextTokenStart();
-    const nextCh = this.input.charCodeAt(next);
-    if (nextCh === 91) return true;
-    if (context) return false;
-    if (nextCh === 123) return true;
-
-    if ((0, _identifier.isIdentifierStart)(nextCh)) {
-      let pos = next + 1;
-
-      while ((0, _identifier.isIdentifierChar)(this.input.charCodeAt(pos))) {
-        ++pos;
-      }
-
-      const ident = this.input.slice(next, pos);
-      if (!_identifier.keywordRelationalOperator.test(ident)) return true;
-    }
-
-    return false;
-  }
-
-  parseStatement(context, topLevel) {
-    if (this.match(_types2.types.at)) {
-      this.parseDecorators(true);
-    }
-
-    return this.parseStatementContent(context, topLevel);
-  }
-
-  parseStatementContent(context, topLevel) {
-    let starttype = this.state.type;
-    const node = this.startNode();
-    let kind;
-
-    if (this.isLet(context)) {
-      starttype = _types2.types._var;
-      kind = "let";
-    }
-
-    switch (starttype) {
-      case _types2.types._break:
-      case _types2.types._continue:
-        return this.parseBreakContinueStatement(node, starttype.keyword);
-
-      case _types2.types._debugger:
-        return this.parseDebuggerStatement(node);
-
-      case _types2.types._do:
-        return this.parseDoStatement(node);
-
-      case _types2.types._for:
-        return this.parseForStatement(node);
-
-      case _types2.types._function:
-        if (this.lookaheadCharCode() === 46) break;
-
-        if (context) {
-          if (this.state.strict) {
-            this.raise(this.state.start, _error.Errors.StrictFunction);
-          } else if (context !== "if" && context !== "label") {
-            this.raise(this.state.start, _error.Errors.SloppyFunction);
-          }
-        }
-
-        return this.parseFunctionStatement(node, false, !context);
-
-      case _types2.types._class:
-        if (context) this.unexpected();
-        return this.parseClass(node, true);
-
-      case _types2.types._if:
-        return this.parseIfStatement(node);
-
-      case _types2.types._return:
-        return this.parseReturnStatement(node);
-
-      case _types2.types._switch:
-        return this.parseSwitchStatement(node);
-
-      case _types2.types._throw:
-        return this.parseThrowStatement(node);
-
-      case _types2.types._try:
-        return this.parseTryStatement(node);
-
-      case _types2.types._const:
-      case _types2.types._var:
-        kind = kind || this.state.value;
-
-        if (context && kind !== "var") {
-          this.raise(this.state.start, _error.Errors.UnexpectedLexicalDeclaration);
-        }
-
-        return this.parseVarStatement(node, kind);
-
-      case _types2.types._while:
-        return this.parseWhileStatement(node);
-
-      case _types2.types._with:
-        return this.parseWithStatement(node);
-
-      case _types2.types.braceL:
-        return this.parseBlock();
-
-      case _types2.types.semi:
-        return this.parseEmptyStatement(node);
-
-      case _types2.types._import:
-        {
-          const nextTokenCharCode = this.lookaheadCharCode();
-
-          if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {
-              break;
-            }
-        }
-
-      case _types2.types._export:
-        {
-          if (!this.options.allowImportExportEverywhere && !topLevel) {
-            this.raise(this.state.start, _error.Errors.UnexpectedImportExport);
-          }
-
-          this.next();
-          let result;
-
-          if (starttype === _types2.types._import) {
-            result = this.parseImport(node);
-
-            if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) {
-              this.sawUnambiguousESM = true;
-            }
-          } else {
-            result = this.parseExport(node);
-
-            if (result.type === "ExportNamedDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportAllDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportDefaultDeclaration") {
-              this.sawUnambiguousESM = true;
-            }
-          }
-
-          this.assertModuleNodeAllowed(node);
-          return result;
-        }
-
-      default:
-        {
-          if (this.isAsyncFunction()) {
-            if (context) {
-              this.raise(this.state.start, _error.Errors.AsyncFunctionInSingleStatementContext);
-            }
-
-            this.next();
-            return this.parseFunctionStatement(node, true, !context);
-          }
-        }
-    }
-
-    const maybeName = this.state.value;
-    const expr = this.parseExpression();
-
-    if (starttype === _types2.types.name && expr.type === "Identifier" && this.eat(_types2.types.colon)) {
-      return this.parseLabeledStatement(node, maybeName, expr, context);
-    } else {
-      return this.parseExpressionStatement(node, expr);
-    }
-  }
-
-  assertModuleNodeAllowed(node) {
-    if (!this.options.allowImportExportEverywhere && !this.inModule) {
-      this.raiseWithData(node.start, {
-        code: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
-      }, _error.Errors.ImportOutsideModule);
-    }
-  }
-
-  takeDecorators(node) {
-    const decorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
-
-    if (decorators.length) {
-      node.decorators = decorators;
-      this.resetStartLocationFromNode(node, decorators[0]);
-      this.state.decoratorStack[this.state.decoratorStack.length - 1] = [];
-    }
-  }
-
-  canHaveLeadingDecorator() {
-    return this.match(_types2.types._class);
-  }
-
-  parseDecorators(allowExport) {
-    const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
-
-    while (this.match(_types2.types.at)) {
-      const decorator = this.parseDecorator();
-      currentContextDecorators.push(decorator);
-    }
-
-    if (this.match(_types2.types._export)) {
-      if (!allowExport) {
-        this.unexpected();
-      }
-
-      if (this.hasPlugin("decorators") && !this.getPluginOption("decorators", "decoratorsBeforeExport")) {
-        this.raise(this.state.start, _error.Errors.DecoratorExportClass);
-      }
-    } else if (!this.canHaveLeadingDecorator()) {
-      throw this.raise(this.state.start, _error.Errors.UnexpectedLeadingDecorator);
-    }
-  }
-
-  parseDecorator() {
-    this.expectOnePlugin(["decorators-legacy", "decorators"]);
-    const node = this.startNode();
-    this.next();
-
-    if (this.hasPlugin("decorators")) {
-      this.state.decoratorStack.push([]);
-      const startPos = this.state.start;
-      const startLoc = this.state.startLoc;
-      let expr;
-
-      if (this.eat(_types2.types.parenL)) {
-        expr = this.parseExpression();
-        this.expect(_types2.types.parenR);
-      } else {
-        expr = this.parseIdentifier(false);
-
-        while (this.eat(_types2.types.dot)) {
-          const node = this.startNodeAt(startPos, startLoc);
-          node.object = expr;
-          node.property = this.parseIdentifier(true);
-          node.computed = false;
-          expr = this.finishNode(node, "MemberExpression");
-        }
-      }
-
-      node.expression = this.parseMaybeDecoratorArguments(expr);
-      this.state.decoratorStack.pop();
-    } else {
-      node.expression = this.parseExprSubscripts();
-    }
-
-    return this.finishNode(node, "Decorator");
-  }
-
-  parseMaybeDecoratorArguments(expr) {
-    if (this.eat(_types2.types.parenL)) {
-      const node = this.startNodeAtNode(expr);
-      node.callee = expr;
-      node.arguments = this.parseCallExpressionArguments(_types2.types.parenR, false);
-      this.toReferencedList(node.arguments);
-      return this.finishNode(node, "CallExpression");
-    }
-
-    return expr;
-  }
-
-  parseBreakContinueStatement(node, keyword) {
-    const isBreak = keyword === "break";
-    this.next();
-
-    if (this.isLineTerminator()) {
-      node.label = null;
-    } else {
-      node.label = this.parseIdentifier();
-      this.semicolon();
-    }
-
-    this.verifyBreakContinue(node, keyword);
-    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-  }
-
-  verifyBreakContinue(node, keyword) {
-    const isBreak = keyword === "break";
-    let i;
-
-    for (i = 0; i < this.state.labels.length; ++i) {
-      const lab = this.state.labels[i];
-
-      if (node.label == null || lab.name === node.label.name) {
-        if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-        if (node.label && isBreak) break;
-      }
-    }
-
-    if (i === this.state.labels.length) {
-      this.raise(node.start, _error.Errors.IllegalBreakContinue, keyword);
-    }
-  }
-
-  parseDebuggerStatement(node) {
-    this.next();
-    this.semicolon();
-    return this.finishNode(node, "DebuggerStatement");
-  }
-
-  parseHeaderExpression() {
-    this.expect(_types2.types.parenL);
-    const val = this.parseExpression();
-    this.expect(_types2.types.parenR);
-    return val;
-  }
-
-  parseDoStatement(node) {
-    this.next();
-    this.state.labels.push(loopLabel);
-    node.body = this.withTopicForbiddingContext(() => this.parseStatement("do"));
-    this.state.labels.pop();
-    this.expect(_types2.types._while);
-    node.test = this.parseHeaderExpression();
-    this.eat(_types2.types.semi);
-    return this.finishNode(node, "DoWhileStatement");
-  }
-
-  parseForStatement(node) {
-    this.next();
-    this.state.labels.push(loopLabel);
-    let awaitAt = -1;
-
-    if (this.isAwaitAllowed() && this.eatContextual("await")) {
-      awaitAt = this.state.lastTokStart;
-    }
-
-    this.scope.enter(_scopeflags.SCOPE_OTHER);
-    this.expect(_types2.types.parenL);
-
-    if (this.match(_types2.types.semi)) {
-      if (awaitAt > -1) {
-        this.unexpected(awaitAt);
-      }
-
-      return this.parseFor(node, null);
-    }
-
-    const isLet = this.isLet();
-
-    if (this.match(_types2.types._var) || this.match(_types2.types._const) || isLet) {
-      const init = this.startNode();
-      const kind = isLet ? "let" : this.state.value;
-      this.next();
-      this.parseVar(init, true, kind);
-      this.finishNode(init, "VariableDeclaration");
-
-      if ((this.match(_types2.types._in) || this.isContextual("of")) && init.declarations.length === 1) {
-        return this.parseForIn(node, init, awaitAt);
-      }
-
-      if (awaitAt > -1) {
-        this.unexpected(awaitAt);
-      }
-
-      return this.parseFor(node, init);
-    }
-
-    const refExpressionErrors = new _util.ExpressionErrors();
-    const init = this.parseExpression(true, refExpressionErrors);
-
-    if (this.match(_types2.types._in) || this.isContextual("of")) {
-      this.toAssignable(init);
-      const description = this.isContextual("of") ? "for-of statement" : "for-in statement";
-      this.checkLVal(init, undefined, undefined, description);
-      return this.parseForIn(node, init, awaitAt);
-    } else {
-      this.checkExpressionErrors(refExpressionErrors, true);
-    }
-
-    if (awaitAt > -1) {
-      this.unexpected(awaitAt);
-    }
-
-    return this.parseFor(node, init);
-  }
-
-  parseFunctionStatement(node, isAsync, declarationPosition) {
-    this.next();
-    return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), isAsync);
-  }
-
-  parseIfStatement(node) {
-    this.next();
-    node.test = this.parseHeaderExpression();
-    node.consequent = this.parseStatement("if");
-    node.alternate = this.eat(_types2.types._else) ? this.parseStatement("if") : null;
-    return this.finishNode(node, "IfStatement");
-  }
-
-  parseReturnStatement(node) {
-    if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
-      this.raise(this.state.start, _error.Errors.IllegalReturn);
-    }
-
-    this.next();
-
-    if (this.isLineTerminator()) {
-      node.argument = null;
-    } else {
-      node.argument = this.parseExpression();
-      this.semicolon();
-    }
-
-    return this.finishNode(node, "ReturnStatement");
-  }
-
-  parseSwitchStatement(node) {
-    this.next();
-    node.discriminant = this.parseHeaderExpression();
-    const cases = node.cases = [];
-    this.expect(_types2.types.braceL);
-    this.state.labels.push(switchLabel);
-    this.scope.enter(_scopeflags.SCOPE_OTHER);
-    let cur;
-
-    for (let sawDefault; !this.match(_types2.types.braceR);) {
-      if (this.match(_types2.types._case) || this.match(_types2.types._default)) {
-        const isCase = this.match(_types2.types._case);
-        if (cur) this.finishNode(cur, "SwitchCase");
-        cases.push(cur = this.startNode());
-        cur.consequent = [];
-        this.next();
-
-        if (isCase) {
-          cur.test = this.parseExpression();
-        } else {
-          if (sawDefault) {
-            this.raise(this.state.lastTokStart, _error.Errors.MultipleDefaultsInSwitch);
-          }
-
-          sawDefault = true;
-          cur.test = null;
-        }
-
-        this.expect(_types2.types.colon);
-      } else {
-        if (cur) {
-          cur.consequent.push(this.parseStatement(null));
-        } else {
-          this.unexpected();
-        }
-      }
-    }
-
-    this.scope.exit();
-    if (cur) this.finishNode(cur, "SwitchCase");
-    this.next();
-    this.state.labels.pop();
-    return this.finishNode(node, "SwitchStatement");
-  }
-
-  parseThrowStatement(node) {
-    this.next();
-
-    if (this.hasPrecedingLineBreak()) {
-      this.raise(this.state.lastTokEnd, _error.Errors.NewlineAfterThrow);
-    }
-
-    node.argument = this.parseExpression();
-    this.semicolon();
-    return this.finishNode(node, "ThrowStatement");
-  }
-
-  parseCatchClauseParam() {
-    const param = this.parseBindingAtom();
-    const simple = param.type === "Identifier";
-    this.scope.enter(simple ? _scopeflags.SCOPE_SIMPLE_CATCH : 0);
-    this.checkLVal(param, _scopeflags.BIND_LEXICAL, null, "catch clause");
-    return param;
-  }
-
-  parseTryStatement(node) {
-    this.next();
-    node.block = this.parseBlock();
-    node.handler = null;
-
-    if (this.match(_types2.types._catch)) {
-      const clause = this.startNode();
-      this.next();
-
-      if (this.match(_types2.types.parenL)) {
-        this.expect(_types2.types.parenL);
-        clause.param = this.parseCatchClauseParam();
-        this.expect(_types2.types.parenR);
-      } else {
-        clause.param = null;
-        this.scope.enter(_scopeflags.SCOPE_OTHER);
-      }
-
-      clause.body = this.withTopicForbiddingContext(() => this.parseBlock(false, false));
-      this.scope.exit();
-      node.handler = this.finishNode(clause, "CatchClause");
-    }
-
-    node.finalizer = this.eat(_types2.types._finally) ? this.parseBlock() : null;
-
-    if (!node.handler && !node.finalizer) {
-      this.raise(node.start, _error.Errors.NoCatchOrFinally);
-    }
-
-    return this.finishNode(node, "TryStatement");
-  }
-
-  parseVarStatement(node, kind) {
-    this.next();
-    this.parseVar(node, false, kind);
-    this.semicolon();
-    return this.finishNode(node, "VariableDeclaration");
-  }
-
-  parseWhileStatement(node) {
-    this.next();
-    node.test = this.parseHeaderExpression();
-    this.state.labels.push(loopLabel);
-    node.body = this.withTopicForbiddingContext(() => this.parseStatement("while"));
-    this.state.labels.pop();
-    return this.finishNode(node, "WhileStatement");
-  }
-
-  parseWithStatement(node) {
-    if (this.state.strict) {
-      this.raise(this.state.start, _error.Errors.StrictWith);
-    }
-
-    this.next();
-    node.object = this.parseHeaderExpression();
-    node.body = this.withTopicForbiddingContext(() => this.parseStatement("with"));
-    return this.finishNode(node, "WithStatement");
-  }
-
-  parseEmptyStatement(node) {
-    this.next();
-    return this.finishNode(node, "EmptyStatement");
-  }
-
-  parseLabeledStatement(node, maybeName, expr, context) {
-    for (let _i2 = 0, _this$state$labels = this.state.labels; _i2 < _this$state$labels.length; _i2++) {
-      const label = _this$state$labels[_i2];
-
-      if (label.name === maybeName) {
-        this.raise(expr.start, _error.Errors.LabelRedeclaration, maybeName);
-      }
-    }
-
-    const kind = this.state.type.isLoop ? "loop" : this.match(_types2.types._switch) ? "switch" : null;
-
-    for (let i = this.state.labels.length - 1; i >= 0; i--) {
-      const label = this.state.labels[i];
-
-      if (label.statementStart === node.start) {
-        label.statementStart = this.state.start;
-        label.kind = kind;
-      } else {
-        break;
-      }
-    }
-
-    this.state.labels.push({
-      name: maybeName,
-      kind: kind,
-      statementStart: this.state.start
-    });
-    node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
-    this.state.labels.pop();
-    node.label = expr;
-    return this.finishNode(node, "LabeledStatement");
-  }
-
-  parseExpressionStatement(node, expr) {
-    node.expression = expr;
-    this.semicolon();
-    return this.finishNode(node, "ExpressionStatement");
-  }
-
-  parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) {
-    const node = this.startNode();
-    this.expect(_types2.types.braceL);
-
-    if (createNewLexicalScope) {
-      this.scope.enter(_scopeflags.SCOPE_OTHER);
-    }
-
-    this.parseBlockBody(node, allowDirectives, false, _types2.types.braceR, afterBlockParse);
-
-    if (createNewLexicalScope) {
-      this.scope.exit();
-    }
-
-    return this.finishNode(node, "BlockStatement");
-  }
-
-  isValidDirective(stmt) {
-    return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized;
-  }
-
-  parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {
-    const body = node.body = [];
-    const directives = node.directives = [];
-    this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse);
-  }
-
-  parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) {
-    const octalPositions = [];
-    const oldStrict = this.state.strict;
-    let hasStrictModeDirective = false;
-    let parsedNonDirective = false;
-
-    while (!this.match(end)) {
-      if (!parsedNonDirective && this.state.octalPositions.length) {
-        octalPositions.push(...this.state.octalPositions);
-      }
-
-      const stmt = this.parseStatement(null, topLevel);
-
-      if (directives && !parsedNonDirective && this.isValidDirective(stmt)) {
-        const directive = this.stmtToDirective(stmt);
-        directives.push(directive);
-
-        if (!hasStrictModeDirective && directive.value.value === "use strict") {
-          hasStrictModeDirective = true;
-          this.setStrict(true);
-        }
-
-        continue;
-      }
-
-      parsedNonDirective = true;
-      body.push(stmt);
-    }
-
-    if (this.state.strict && octalPositions.length) {
-      for (let _i3 = 0; _i3 < octalPositions.length; _i3++) {
-        const pos = octalPositions[_i3];
-        this.raise(pos, _error.Errors.StrictOctalLiteral);
-      }
-    }
-
-    if (afterBlockParse) {
-      afterBlockParse.call(this, hasStrictModeDirective);
-    }
-
-    if (!oldStrict) {
-      this.setStrict(false);
-    }
-
-    this.next();
-  }
-
-  parseFor(node, init) {
-    node.init = init;
-    this.expect(_types2.types.semi);
-    node.test = this.match(_types2.types.semi) ? null : this.parseExpression();
-    this.expect(_types2.types.semi);
-    node.update = this.match(_types2.types.parenR) ? null : this.parseExpression();
-    this.expect(_types2.types.parenR);
-    node.body = this.withTopicForbiddingContext(() => this.parseStatement("for"));
-    this.scope.exit();
-    this.state.labels.pop();
-    return this.finishNode(node, "ForStatement");
-  }
-
-  parseForIn(node, init, awaitAt) {
-    const isForIn = this.match(_types2.types._in);
-    this.next();
-
-    if (isForIn) {
-      if (awaitAt > -1) this.unexpected(awaitAt);
-    } else {
-      node.await = awaitAt > -1;
-    }
-
-    if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
-      this.raise(init.start, _error.Errors.ForInOfLoopInitializer, isForIn ? "for-in" : "for-of");
-    } else if (init.type === "AssignmentPattern") {
-      this.raise(init.start, _error.Errors.InvalidLhs, "for-loop");
-    }
-
-    node.left = init;
-    node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
-    this.expect(_types2.types.parenR);
-    node.body = this.withTopicForbiddingContext(() => this.parseStatement("for"));
-    this.scope.exit();
-    this.state.labels.pop();
-    return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
-  }
-
-  parseVar(node, isFor, kind) {
-    const declarations = node.declarations = [];
-    const isTypescript = this.hasPlugin("typescript");
-    node.kind = kind;
-
-    for (;;) {
-      const decl = this.startNode();
-      this.parseVarId(decl, kind);
-
-      if (this.eat(_types2.types.eq)) {
-        decl.init = isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
-      } else {
-        if (kind === "const" && !(this.match(_types2.types._in) || this.isContextual("of"))) {
-          if (!isTypescript) {
-            this.raise(this.state.lastTokEnd, _error.Errors.DeclarationMissingInitializer, "Const declarations");
-          }
-        } else if (decl.id.type !== "Identifier" && !(isFor && (this.match(_types2.types._in) || this.isContextual("of")))) {
-          this.raise(this.state.lastTokEnd, _error.Errors.DeclarationMissingInitializer, "Complex binding patterns");
-        }
-
-        decl.init = null;
-      }
-
-      declarations.push(this.finishNode(decl, "VariableDeclarator"));
-      if (!this.eat(_types2.types.comma)) break;
-    }
-
-    return node;
-  }
-
-  parseVarId(decl, kind) {
-    decl.id = this.parseBindingAtom();
-    this.checkLVal(decl.id, kind === "var" ? _scopeflags.BIND_VAR : _scopeflags.BIND_LEXICAL, undefined, "variable declaration", kind !== "var");
-  }
-
-  parseFunction(node, statement = FUNC_NO_FLAGS, isAsync = false) {
-    const isStatement = statement & FUNC_STATEMENT;
-    const isHangingStatement = statement & FUNC_HANGING_STATEMENT;
-    const requireId = !!isStatement && !(statement & FUNC_NULLABLE_ID);
-    this.initFunction(node, isAsync);
-
-    if (this.match(_types2.types.star) && isHangingStatement) {
-      this.raise(this.state.start, _error.Errors.GeneratorInSingleStatementContext);
-    }
-
-    node.generator = this.eat(_types2.types.star);
-
-    if (isStatement) {
-      node.id = this.parseFunctionId(requireId);
-    }
-
-    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
-    this.state.maybeInArrowParameters = false;
-    this.scope.enter(_scopeflags.SCOPE_FUNCTION);
-    this.prodParam.enter((0, _productionParameter.functionFlags)(isAsync, node.generator));
-
-    if (!isStatement) {
-      node.id = this.parseFunctionId();
-    }
-
-    this.parseFunctionParams(node, false);
-    this.withTopicForbiddingContext(() => {
-      this.parseFunctionBodyAndFinish(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-    });
-    this.prodParam.exit();
-    this.scope.exit();
-
-    if (isStatement && !isHangingStatement) {
-      this.registerFunctionStatementId(node);
-    }
-
-    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-    return node;
-  }
-
-  parseFunctionId(requireId) {
-    return requireId || this.match(_types2.types.name) ? this.parseIdentifier() : null;
-  }
-
-  parseFunctionParams(node, allowModifiers) {
-    this.expect(_types2.types.parenL);
-    this.expressionScope.enter((0, _expressionScope.newParameterDeclarationScope)());
-    node.params = this.parseBindingList(_types2.types.parenR, 41, false, allowModifiers);
-    this.expressionScope.exit();
-  }
-
-  registerFunctionStatementId(node) {
-    if (!node.id) return;
-    this.scope.declareName(node.id.name, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? _scopeflags.BIND_VAR : _scopeflags.BIND_LEXICAL : _scopeflags.BIND_FUNCTION, node.id.start);
-  }
-
-  parseClass(node, isStatement, optionalId) {
-    this.next();
-    this.takeDecorators(node);
-    const oldStrict = this.state.strict;
-    this.state.strict = true;
-    this.parseClassId(node, isStatement, optionalId);
-    this.parseClassSuper(node);
-    node.body = this.parseClassBody(!!node.superClass, oldStrict);
-    return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
-  }
-
-  isClassProperty() {
-    return this.match(_types2.types.eq) || this.match(_types2.types.semi) || this.match(_types2.types.braceR);
-  }
-
-  isClassMethod() {
-    return this.match(_types2.types.parenL);
-  }
-
-  isNonstaticConstructor(method) {
-    return !method.computed && !method.static && (method.key.name === "constructor" || method.key.value === "constructor");
-  }
-
-  parseClassBody(constructorAllowsSuper, oldStrict) {
-    this.classScope.enter();
-    const state = {
-      constructorAllowsSuper,
-      hadConstructor: false,
-      hadStaticBlock: false
-    };
-    let decorators = [];
-    const classBody = this.startNode();
-    classBody.body = [];
-    this.expect(_types2.types.braceL);
-    this.withTopicForbiddingContext(() => {
-      while (!this.match(_types2.types.braceR)) {
-        if (this.eat(_types2.types.semi)) {
-          if (decorators.length > 0) {
-            throw this.raise(this.state.lastTokEnd, _error.Errors.DecoratorSemicolon);
-          }
-
-          continue;
-        }
-
-        if (this.match(_types2.types.at)) {
-          decorators.push(this.parseDecorator());
-          continue;
-        }
-
-        const member = this.startNode();
-
-        if (decorators.length) {
-          member.decorators = decorators;
-          this.resetStartLocationFromNode(member, decorators[0]);
-          decorators = [];
-        }
-
-        this.parseClassMember(classBody, member, state);
-
-        if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) {
-          this.raise(member.start, _error.Errors.DecoratorConstructor);
-        }
-      }
-    });
-    this.state.strict = oldStrict;
-    this.next();
-
-    if (decorators.length) {
-      throw this.raise(this.state.start, _error.Errors.TrailingDecorator);
-    }
-
-    this.classScope.exit();
-    return this.finishNode(classBody, "ClassBody");
-  }
-
-  parseClassMemberFromModifier(classBody, member) {
-    const key = this.parseIdentifier(true);
-
-    if (this.isClassMethod()) {
-      const method = member;
-      method.kind = "method";
-      method.computed = false;
-      method.key = key;
-      method.static = false;
-      this.pushClassMethod(classBody, method, false, false, false, false);
-      return true;
-    } else if (this.isClassProperty()) {
-      const prop = member;
-      prop.computed = false;
-      prop.key = key;
-      prop.static = false;
-      classBody.body.push(this.parseClassProperty(prop));
-      return true;
-    }
-
-    return false;
-  }
-
-  parseClassMember(classBody, member, state) {
-    const isStatic = this.isContextual("static");
-
-    if (isStatic) {
-      if (this.parseClassMemberFromModifier(classBody, member)) {
-        return;
-      }
-
-      if (this.eat(_types2.types.braceL)) {
-        this.parseClassStaticBlock(classBody, member, state);
-        return;
-      }
-    }
-
-    this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
-  }
-
-  parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
-    const publicMethod = member;
-    const privateMethod = member;
-    const publicProp = member;
-    const privateProp = member;
-    const method = publicMethod;
-    const publicMember = publicMethod;
-    member.static = isStatic;
-
-    if (this.eat(_types2.types.star)) {
-      method.kind = "method";
-      this.parseClassElementName(method);
-
-      if (method.key.type === "PrivateName") {
-        this.pushClassPrivateMethod(classBody, privateMethod, true, false);
-        return;
-      }
-
-      if (this.isNonstaticConstructor(publicMethod)) {
-        this.raise(publicMethod.key.start, _error.Errors.ConstructorIsGenerator);
-      }
-
-      this.pushClassMethod(classBody, publicMethod, true, false, false, false);
-      return;
-    }
-
-    const containsEsc = this.state.containsEsc;
-    const key = this.parseClassElementName(member);
-    const isPrivate = key.type === "PrivateName";
-    const isSimple = key.type === "Identifier";
-    const maybeQuestionTokenStart = this.state.start;
-    this.parsePostMemberNameModifiers(publicMember);
-
-    if (this.isClassMethod()) {
-      method.kind = "method";
-
-      if (isPrivate) {
-        this.pushClassPrivateMethod(classBody, privateMethod, false, false);
-        return;
-      }
-
-      const isConstructor = this.isNonstaticConstructor(publicMethod);
-      let allowsDirectSuper = false;
-
-      if (isConstructor) {
-        publicMethod.kind = "constructor";
-
-        if (state.hadConstructor && !this.hasPlugin("typescript")) {
-          this.raise(key.start, _error.Errors.DuplicateConstructor);
-        }
-
-        state.hadConstructor = true;
-        allowsDirectSuper = state.constructorAllowsSuper;
-      }
-
-      this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper);
-    } else if (this.isClassProperty()) {
-      if (isPrivate) {
-        this.pushClassPrivateProperty(classBody, privateProp);
-      } else {
-        this.pushClassProperty(classBody, publicProp);
-      }
-    } else if (isSimple && key.name === "async" && !containsEsc && !this.isLineTerminator()) {
-      const isGenerator = this.eat(_types2.types.star);
-
-      if (publicMember.optional) {
-        this.unexpected(maybeQuestionTokenStart);
-      }
-
-      method.kind = "method";
-      this.parseClassElementName(method);
-      this.parsePostMemberNameModifiers(publicMember);
-
-      if (method.key.type === "PrivateName") {
-        this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
-      } else {
-        if (this.isNonstaticConstructor(publicMethod)) {
-          this.raise(publicMethod.key.start, _error.Errors.ConstructorIsAsync);
-        }
-
-        this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
-      }
-    } else if (isSimple && (key.name === "get" || key.name === "set") && !containsEsc && !(this.match(_types2.types.star) && this.isLineTerminator())) {
-      method.kind = key.name;
-      this.parseClassElementName(publicMethod);
-
-      if (method.key.type === "PrivateName") {
-        this.pushClassPrivateMethod(classBody, privateMethod, false, false);
-      } else {
-        if (this.isNonstaticConstructor(publicMethod)) {
-          this.raise(publicMethod.key.start, _error.Errors.ConstructorIsAccessor);
-        }
-
-        this.pushClassMethod(classBody, publicMethod, false, false, false, false);
-      }
-
-      this.checkGetterSetterParams(publicMethod);
-    } else if (this.isLineTerminator()) {
-      if (isPrivate) {
-        this.pushClassPrivateProperty(classBody, privateProp);
-      } else {
-        this.pushClassProperty(classBody, publicProp);
-      }
-    } else {
-      this.unexpected();
-    }
-  }
-
-  parseClassElementName(member) {
-    const key = this.parsePropertyName(member, true);
-
-    if (!member.computed && member.static && (key.name === "prototype" || key.value === "prototype")) {
-      this.raise(key.start, _error.Errors.StaticPrototype);
-    }
-
-    if (key.type === "PrivateName" && key.id.name === "constructor") {
-      this.raise(key.start, _error.Errors.ConstructorClassPrivateField);
-    }
-
-    return key;
-  }
-
-  parseClassStaticBlock(classBody, member, state) {
-    this.expectPlugin("classStaticBlock", member.start);
-    this.scope.enter(_scopeflags.SCOPE_CLASS | _scopeflags.SCOPE_SUPER);
-    this.expressionScope.enter((0, _expressionScope.newExpressionScope)());
-    const oldLabels = this.state.labels;
-    this.state.labels = [];
-    this.prodParam.enter(_productionParameter.PARAM);
-    const body = member.body = [];
-    this.parseBlockOrModuleBlockBody(body, undefined, false, _types2.types.braceR);
-    this.prodParam.exit();
-    this.expressionScope.exit();
-    this.scope.exit();
-    this.state.labels = oldLabels;
-    classBody.body.push(this.finishNode(member, "StaticBlock"));
-
-    if (state.hadStaticBlock) {
-      this.raise(member.start, _error.Errors.DuplicateStaticBlock);
-    }
-
-    if (member.decorators?.length) {
-      this.raise(member.start, _error.Errors.DecoratorStaticBlock);
-    }
-
-    state.hadStaticBlock = true;
-  }
-
-  pushClassProperty(classBody, prop) {
-    if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
-      this.raise(prop.key.start, _error.Errors.ConstructorClassField);
-    }
-
-    classBody.body.push(this.parseClassProperty(prop));
-  }
-
-  pushClassPrivateProperty(classBody, prop) {
-    this.expectPlugin("classPrivateProperties", prop.key.start);
-    const node = this.parseClassPrivateProperty(prop);
-    classBody.body.push(node);
-    this.classScope.declarePrivateName(node.key.id.name, _scopeflags.CLASS_ELEMENT_OTHER, node.key.start);
-  }
-
-  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-    classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true));
-  }
-
-  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
-    this.expectPlugin("classPrivateMethods", method.key.start);
-    const node = this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true);
-    classBody.body.push(node);
-    const kind = node.kind === "get" ? node.static ? _scopeflags.CLASS_ELEMENT_STATIC_GETTER : _scopeflags.CLASS_ELEMENT_INSTANCE_GETTER : node.kind === "set" ? node.static ? _scopeflags.CLASS_ELEMENT_STATIC_SETTER : _scopeflags.CLASS_ELEMENT_INSTANCE_SETTER : _scopeflags.CLASS_ELEMENT_OTHER;
-    this.classScope.declarePrivateName(node.key.id.name, kind, node.key.start);
-  }
-
-  parsePostMemberNameModifiers(methodOrProp) {}
-
-  parseClassPrivateProperty(node) {
-    this.parseInitializer(node);
-    this.semicolon();
-    return this.finishNode(node, "ClassPrivateProperty");
-  }
-
-  parseClassProperty(node) {
-    if (!node.typeAnnotation || this.match(_types2.types.eq)) {
-      this.expectPlugin("classProperties");
-    }
-
-    this.parseInitializer(node);
-    this.semicolon();
-    return this.finishNode(node, "ClassProperty");
-  }
-
-  parseInitializer(node) {
-    this.scope.enter(_scopeflags.SCOPE_CLASS | _scopeflags.SCOPE_SUPER);
-    this.expressionScope.enter((0, _expressionScope.newExpressionScope)());
-    this.prodParam.enter(_productionParameter.PARAM);
-    node.value = this.eat(_types2.types.eq) ? this.parseMaybeAssignAllowIn() : null;
-    this.expressionScope.exit();
-    this.prodParam.exit();
-    this.scope.exit();
-  }
-
-  parseClassId(node, isStatement, optionalId, bindingType = _scopeflags.BIND_CLASS) {
-    if (this.match(_types2.types.name)) {
-      node.id = this.parseIdentifier();
-
-      if (isStatement) {
-        this.checkLVal(node.id, bindingType, undefined, "class name");
-      }
-    } else {
-      if (optionalId || !isStatement) {
-        node.id = null;
-      } else {
-        this.unexpected(null, _error.Errors.MissingClassName);
-      }
-    }
-  }
-
-  parseClassSuper(node) {
-    node.superClass = this.eat(_types2.types._extends) ? this.parseExprSubscripts() : null;
-  }
-
-  parseExport(node) {
-    const hasDefault = this.maybeParseExportDefaultSpecifier(node);
-    const parseAfterDefault = !hasDefault || this.eat(_types2.types.comma);
-    const hasStar = parseAfterDefault && this.eatExportStar(node);
-    const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
-    const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(_types2.types.comma));
-    const isFromRequired = hasDefault || hasStar;
-
-    if (hasStar && !hasNamespace) {
-      if (hasDefault) this.unexpected();
-      this.parseExportFrom(node, true);
-      return this.finishNode(node, "ExportAllDeclaration");
-    }
-
-    const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
-
-    if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers || hasNamespace && parseAfterNamespace && !hasSpecifiers) {
-      throw this.unexpected(null, _types2.types.braceL);
-    }
-
-    let hasDeclaration;
-
-    if (isFromRequired || hasSpecifiers) {
-      hasDeclaration = false;
-      this.parseExportFrom(node, isFromRequired);
-    } else {
-      hasDeclaration = this.maybeParseExportDeclaration(node);
-    }
-
-    if (isFromRequired || hasSpecifiers || hasDeclaration) {
-      this.checkExport(node, true, false, !!node.source);
-      return this.finishNode(node, "ExportNamedDeclaration");
-    }
-
-    if (this.eat(_types2.types._default)) {
-      node.declaration = this.parseExportDefaultExpression();
-      this.checkExport(node, true, true);
-      return this.finishNode(node, "ExportDefaultDeclaration");
-    }
-
-    throw this.unexpected(null, _types2.types.braceL);
-  }
-
-  eatExportStar(node) {
-    return this.eat(_types2.types.star);
-  }
-
-  maybeParseExportDefaultSpecifier(node) {
-    if (this.isExportDefaultSpecifier()) {
-      this.expectPlugin("exportDefaultFrom");
-      const specifier = this.startNode();
-      specifier.exported = this.parseIdentifier(true);
-      node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
-      return true;
-    }
-
-    return false;
-  }
-
-  maybeParseExportNamespaceSpecifier(node) {
-    if (this.isContextual("as")) {
-      if (!node.specifiers) node.specifiers = [];
-      const specifier = this.startNodeAt(this.state.lastTokStart, this.state.lastTokStartLoc);
-      this.next();
-      specifier.exported = this.parseModuleExportName();
-      node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier"));
-      return true;
-    }
-
-    return false;
-  }
-
-  maybeParseExportNamedSpecifiers(node) {
-    if (this.match(_types2.types.braceL)) {
-      if (!node.specifiers) node.specifiers = [];
-      node.specifiers.push(...this.parseExportSpecifiers());
-      node.source = null;
-      node.declaration = null;
-      return true;
-    }
-
-    return false;
-  }
-
-  maybeParseExportDeclaration(node) {
-    if (this.shouldParseExportDeclaration()) {
-      node.specifiers = [];
-      node.source = null;
-      node.declaration = this.parseExportDeclaration(node);
-      return true;
-    }
-
-    return false;
-  }
-
-  isAsyncFunction() {
-    if (!this.isContextual("async")) return false;
-    const next = this.nextTokenStart();
-    return !_whitespace.lineBreak.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, "function");
-  }
-
-  parseExportDefaultExpression() {
-    const expr = this.startNode();
-    const isAsync = this.isAsyncFunction();
-
-    if (this.match(_types2.types._function) || isAsync) {
-      this.next();
-
-      if (isAsync) {
-        this.next();
-      }
-
-      return this.parseFunction(expr, FUNC_STATEMENT | FUNC_NULLABLE_ID, isAsync);
-    } else if (this.match(_types2.types._class)) {
-      return this.parseClass(expr, true, true);
-    } else if (this.match(_types2.types.at)) {
-      if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport")) {
-        this.raise(this.state.start, _error.Errors.DecoratorBeforeExport);
-      }
-
-      this.parseDecorators(false);
-      return this.parseClass(expr, true, true);
-    } else if (this.match(_types2.types._const) || this.match(_types2.types._var) || this.isLet()) {
-      throw this.raise(this.state.start, _error.Errors.UnsupportedDefaultExport);
-    } else {
-      const res = this.parseMaybeAssignAllowIn();
-      this.semicolon();
-      return res;
-    }
-  }
-
-  parseExportDeclaration(node) {
-    return this.parseStatement(null);
-  }
-
-  isExportDefaultSpecifier() {
-    if (this.match(_types2.types.name)) {
-      const value = this.state.value;
-
-      if (value === "async" && !this.state.containsEsc || value === "let") {
-        return false;
-      }
-
-      if ((value === "type" || value === "interface") && !this.state.containsEsc) {
-        const l = this.lookahead();
-
-        if (l.type === _types2.types.name && l.value !== "from" || l.type === _types2.types.braceL) {
-          this.expectOnePlugin(["flow", "typescript"]);
-          return false;
-        }
-      }
-    } else if (!this.match(_types2.types._default)) {
-      return false;
-    }
-
-    const next = this.nextTokenStart();
-    const hasFrom = this.isUnparsedContextual(next, "from");
-
-    if (this.input.charCodeAt(next) === 44 || this.match(_types2.types.name) && hasFrom) {
-      return true;
-    }
-
-    if (this.match(_types2.types._default) && hasFrom) {
-      const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));
-      return nextAfterFrom === 34 || nextAfterFrom === 39;
-    }
-
-    return false;
-  }
-
-  parseExportFrom(node, expect) {
-    if (this.eatContextual("from")) {
-      node.source = this.parseImportSource();
-      this.checkExport(node);
-      const assertions = this.maybeParseImportAssertions();
-
-      if (assertions) {
-        node.assertions = assertions;
-      }
-    } else {
-      if (expect) {
-        this.unexpected();
-      } else {
-        node.source = null;
-      }
-    }
-
-    this.semicolon();
-  }
-
-  shouldParseExportDeclaration() {
-    if (this.match(_types2.types.at)) {
-      this.expectOnePlugin(["decorators", "decorators-legacy"]);
-
-      if (this.hasPlugin("decorators")) {
-        if (this.getPluginOption("decorators", "decoratorsBeforeExport")) {
-          this.unexpected(this.state.start, _error.Errors.DecoratorBeforeExport);
-        } else {
-          return true;
-        }
-      }
-    }
-
-    return this.state.type.keyword === "var" || this.state.type.keyword === "const" || this.state.type.keyword === "function" || this.state.type.keyword === "class" || this.isLet() || this.isAsyncFunction();
-  }
-
-  checkExport(node, checkNames, isDefault, isFrom) {
-    if (checkNames) {
-      if (isDefault) {
-        this.checkDuplicateExports(node, "default");
-
-        if (this.hasPlugin("exportDefaultFrom")) {
-          const declaration = node.declaration;
-
-          if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !declaration.extra?.parenthesized) {
-            this.raise(declaration.start, _error.Errors.ExportDefaultFromAsIdentifier);
-          }
-        }
-      } else if (node.specifiers && node.specifiers.length) {
-        for (let _i4 = 0, _node$specifiers = node.specifiers; _i4 < _node$specifiers.length; _i4++) {
-          const specifier = _node$specifiers[_i4];
-          const {
-            exported
-          } = specifier;
-          const exportedName = exported.type === "Identifier" ? exported.name : exported.value;
-          this.checkDuplicateExports(specifier, exportedName);
-
-          if (!isFrom && specifier.local) {
-            const {
-              local
-            } = specifier;
-
-            if (local.type === "StringLiteral") {
-              this.raise(specifier.start, _error.Errors.ExportBindingIsString, local.extra.raw, exportedName);
-            } else {
-              this.checkReservedWord(local.name, local.start, true, false);
-              this.scope.checkLocalExport(local);
-            }
-          }
-        }
-      } else if (node.declaration) {
-        if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
-          const id = node.declaration.id;
-          if (!id) throw new Error("Assertion failure");
-          this.checkDuplicateExports(node, id.name);
-        } else if (node.declaration.type === "VariableDeclaration") {
-          for (let _i5 = 0, _node$declaration$dec = node.declaration.declarations; _i5 < _node$declaration$dec.length; _i5++) {
-            const declaration = _node$declaration$dec[_i5];
-            this.checkDeclaration(declaration.id);
-          }
-        }
-      }
-    }
-
-    const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1];
-
-    if (currentContextDecorators.length) {
-      throw this.raise(node.start, _error.Errors.UnsupportedDecoratorExport);
-    }
-  }
-
-  checkDeclaration(node) {
-    if (node.type === "Identifier") {
-      this.checkDuplicateExports(node, node.name);
-    } else if (node.type === "ObjectPattern") {
-      for (let _i6 = 0, _node$properties = node.properties; _i6 < _node$properties.length; _i6++) {
-        const prop = _node$properties[_i6];
-        this.checkDeclaration(prop);
-      }
-    } else if (node.type === "ArrayPattern") {
-      for (let _i7 = 0, _node$elements = node.elements; _i7 < _node$elements.length; _i7++) {
-        const elem = _node$elements[_i7];
-
-        if (elem) {
-          this.checkDeclaration(elem);
-        }
-      }
-    } else if (node.type === "ObjectProperty") {
-      this.checkDeclaration(node.value);
-    } else if (node.type === "RestElement") {
-      this.checkDeclaration(node.argument);
-    } else if (node.type === "AssignmentPattern") {
-      this.checkDeclaration(node.left);
-    }
-  }
-
-  checkDuplicateExports(node, name) {
-    if (this.state.exportedIdentifiers.indexOf(name) > -1) {
-      this.raise(node.start, name === "default" ? _error.Errors.DuplicateDefaultExport : _error.Errors.DuplicateExport, name);
-    }
-
-    this.state.exportedIdentifiers.push(name);
-  }
-
-  parseExportSpecifiers() {
-    const nodes = [];
-    let first = true;
-    this.expect(_types2.types.braceL);
-
-    while (!this.eat(_types2.types.braceR)) {
-      if (first) {
-        first = false;
-      } else {
-        this.expect(_types2.types.comma);
-        if (this.eat(_types2.types.braceR)) break;
-      }
-
-      const node = this.startNode();
-      node.local = this.parseModuleExportName();
-      node.exported = this.eatContextual("as") ? this.parseModuleExportName() : node.local.__clone();
-      nodes.push(this.finishNode(node, "ExportSpecifier"));
-    }
-
-    return nodes;
-  }
-
-  parseModuleExportName() {
-    if (this.match(_types2.types.string)) {
-      this.expectPlugin("moduleStringNames");
-      const result = this.parseLiteral(this.state.value, "StringLiteral");
-      const surrogate = result.value.match(loneSurrogate);
-
-      if (surrogate) {
-        this.raise(result.start, _error.Errors.ModuleExportNameHasLoneSurrogate, surrogate[0].charCodeAt(0).toString(16));
-      }
-
-      return result;
-    }
-
-    return this.parseIdentifier(true);
-  }
-
-  parseImport(node) {
-    node.specifiers = [];
-
-    if (!this.match(_types2.types.string)) {
-      const hasDefault = this.maybeParseDefaultImportSpecifier(node);
-      const parseNext = !hasDefault || this.eat(_types2.types.comma);
-      const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
-      if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
-      this.expectContextual("from");
-    }
-
-    node.source = this.parseImportSource();
-    const assertions = this.maybeParseImportAssertions();
-
-    if (assertions) {
-      node.assertions = assertions;
-    } else {
-        const attributes = this.maybeParseModuleAttributes();
-
-        if (attributes) {
-          node.attributes = attributes;
-        }
-      }
-
-    this.semicolon();
-    return this.finishNode(node, "ImportDeclaration");
-  }
-
-  parseImportSource() {
-    if (!this.match(_types2.types.string)) this.unexpected();
-    return this.parseExprAtom();
-  }
-
-  shouldParseDefaultImport(node) {
-    return this.match(_types2.types.name);
-  }
-
-  parseImportSpecifierLocal(node, specifier, type, contextDescription) {
-    specifier.local = this.parseIdentifier();
-    this.checkLVal(specifier.local, _scopeflags.BIND_LEXICAL, undefined, contextDescription);
-    node.specifiers.push(this.finishNode(specifier, type));
-  }
-
-  parseAssertEntries() {
-    const attrs = [];
-    const attrNames = new Set();
-
-    do {
-      if (this.match(_types2.types.braceR)) {
-        break;
-      }
-
-      const node = this.startNode();
-      const keyName = this.state.value;
-
-      if (this.match(_types2.types.string)) {
-        node.key = this.parseLiteral(keyName, "StringLiteral");
-      } else {
-        node.key = this.parseIdentifier(true);
-      }
-
-      this.expect(_types2.types.colon);
-
-      if (keyName !== "type") {
-        this.raise(node.key.start, _error.Errors.ModuleAttributeDifferentFromType, keyName);
-      }
-
-      if (attrNames.has(keyName)) {
-        this.raise(node.key.start, _error.Errors.ModuleAttributesWithDuplicateKeys, keyName);
-      }
-
-      attrNames.add(keyName);
-
-      if (!this.match(_types2.types.string)) {
-        throw this.unexpected(this.state.start, _error.Errors.ModuleAttributeInvalidValue);
-      }
-
-      node.value = this.parseLiteral(this.state.value, "StringLiteral");
-      this.finishNode(node, "ImportAttribute");
-      attrs.push(node);
-    } while (this.eat(_types2.types.comma));
-
-    return attrs;
-  }
-
-  maybeParseModuleAttributes() {
-    if (this.match(_types2.types._with) && !this.hasPrecedingLineBreak()) {
-      this.expectPlugin("moduleAttributes");
-      this.next();
-    } else {
-      if (this.hasPlugin("moduleAttributes")) return [];
-      return null;
-    }
-
-    const attrs = [];
-    const attributes = new Set();
-
-    do {
-      const node = this.startNode();
-      node.key = this.parseIdentifier(true);
-
-      if (node.key.name !== "type") {
-        this.raise(node.key.start, _error.Errors.ModuleAttributeDifferentFromType, node.key.name);
-      }
-
-      if (attributes.has(node.key.name)) {
-        this.raise(node.key.start, _error.Errors.ModuleAttributesWithDuplicateKeys, node.key.name);
-      }
-
-      attributes.add(node.key.name);
-      this.expect(_types2.types.colon);
-
-      if (!this.match(_types2.types.string)) {
-        throw this.unexpected(this.state.start, _error.Errors.ModuleAttributeInvalidValue);
-      }
-
-      node.value = this.parseLiteral(this.state.value, "StringLiteral");
-      this.finishNode(node, "ImportAttribute");
-      attrs.push(node);
-    } while (this.eat(_types2.types.comma));
-
-    return attrs;
-  }
-
-  maybeParseImportAssertions() {
-    if (this.isContextual("assert") && !this.hasPrecedingLineBreak()) {
-      this.expectPlugin("importAssertions");
-      this.next();
-    } else {
-      if (this.hasPlugin("importAssertions")) return [];
-      return null;
-    }
-
-    this.eat(_types2.types.braceL);
-    const attrs = this.parseAssertEntries();
-    this.eat(_types2.types.braceR);
-    return attrs;
-  }
-
-  maybeParseDefaultImportSpecifier(node) {
-    if (this.shouldParseDefaultImport(node)) {
-      this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier", "default import specifier");
-      return true;
-    }
-
-    return false;
-  }
-
-  maybeParseStarImportSpecifier(node) {
-    if (this.match(_types2.types.star)) {
-      const specifier = this.startNode();
-      this.next();
-      this.expectContextual("as");
-      this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier", "import namespace specifier");
-      return true;
-    }
-
-    return false;
-  }
-
-  parseNamedImportSpecifiers(node) {
-    let first = true;
-    this.expect(_types2.types.braceL);
-
-    while (!this.eat(_types2.types.braceR)) {
-      if (first) {
-        first = false;
-      } else {
-        if (this.eat(_types2.types.colon)) {
-          throw this.raise(this.state.start, _error.Errors.DestructureNamedImport);
-        }
-
-        this.expect(_types2.types.comma);
-        if (this.eat(_types2.types.braceR)) break;
-      }
-
-      this.parseImportSpecifier(node);
-    }
-  }
-
-  parseImportSpecifier(node) {
-    const specifier = this.startNode();
-    specifier.imported = this.parseModuleExportName();
-
-    if (this.eatContextual("as")) {
-      specifier.local = this.parseIdentifier();
-    } else {
-      const {
-        imported
-      } = specifier;
-
-      if (imported.type === "StringLiteral") {
-        throw this.raise(specifier.start, _error.Errors.ImportBindingIsString, imported.value);
-      }
-
-      this.checkReservedWord(imported.name, specifier.start, true, true);
-      specifier.local = imported.__clone();
-    }
-
-    this.checkLVal(specifier.local, _scopeflags.BIND_LEXICAL, undefined, "import specifier");
-    node.specifiers.push(this.finishNode(specifier, "ImportSpecifier"));
-  }
-
-}
-
-exports.default = StatementParser;

node_modules/@babel/parser/lib/parser/util.js

@@ -1,206 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ExpressionErrors = exports.default = void 0;
-
-var _types = require("../tokenizer/types");
-
-var _tokenizer = _interopRequireDefault(require("../tokenizer"));
-
-var _state = _interopRequireDefault(require("../tokenizer/state"));
-
-var _whitespace = require("../util/whitespace");
-
-var _identifier = require("../util/identifier");
-
-var _error = require("./error");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class UtilParser extends _tokenizer.default {
-  addExtra(node, key, val) {
-    if (!node) return;
-    const extra = node.extra = node.extra || {};
-    extra[key] = val;
-  }
-
-  isRelational(op) {
-    return this.match(_types.types.relational) && this.state.value === op;
-  }
-
-  expectRelational(op) {
-    if (this.isRelational(op)) {
-      this.next();
-    } else {
-      this.unexpected(null, _types.types.relational);
-    }
-  }
-
-  isContextual(name) {
-    return this.match(_types.types.name) && this.state.value === name && !this.state.containsEsc;
-  }
-
-  isUnparsedContextual(nameStart, name) {
-    const nameEnd = nameStart + name.length;
-    return this.input.slice(nameStart, nameEnd) === name && (nameEnd === this.input.length || !(0, _identifier.isIdentifierChar)(this.input.charCodeAt(nameEnd)));
-  }
-
-  isLookaheadContextual(name) {
-    const next = this.nextTokenStart();
-    return this.isUnparsedContextual(next, name);
-  }
-
-  eatContextual(name) {
-    return this.isContextual(name) && this.eat(_types.types.name);
-  }
-
-  expectContextual(name, message) {
-    if (!this.eatContextual(name)) this.unexpected(null, message);
-  }
-
-  canInsertSemicolon() {
-    return this.match(_types.types.eof) || this.match(_types.types.braceR) || this.hasPrecedingLineBreak();
-  }
-
-  hasPrecedingLineBreak() {
-    return _whitespace.lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.start));
-  }
-
-  isLineTerminator() {
-    return this.eat(_types.types.semi) || this.canInsertSemicolon();
-  }
-
-  semicolon() {
-    if (!this.isLineTerminator()) this.unexpected(null, _types.types.semi);
-  }
-
-  expect(type, pos) {
-    this.eat(type) || this.unexpected(pos, type);
-  }
-
-  assertNoSpace(message = "Unexpected space.") {
-    if (this.state.start > this.state.lastTokEnd) {
-      this.raise(this.state.lastTokEnd, message);
-    }
-  }
-
-  unexpected(pos, messageOrType = "Unexpected token") {
-    if (typeof messageOrType !== "string") {
-      messageOrType = `Unexpected token, expected "${messageOrType.label}"`;
-    }
-
-    throw this.raise(pos != null ? pos : this.state.start, messageOrType);
-  }
-
-  expectPlugin(name, pos) {
-    if (!this.hasPlugin(name)) {
-      throw this.raiseWithData(pos != null ? pos : this.state.start, {
-        missingPlugin: [name]
-      }, `This experimental syntax requires enabling the parser plugin: '${name}'`);
-    }
-
-    return true;
-  }
-
-  expectOnePlugin(names, pos) {
-    if (!names.some(n => this.hasPlugin(n))) {
-      throw this.raiseWithData(pos != null ? pos : this.state.start, {
-        missingPlugin: names
-      }, `This experimental syntax requires enabling one of the following parser plugin(s): '${names.join(", ")}'`);
-    }
-  }
-
-  tryParse(fn, oldState = this.state.clone()) {
-    const abortSignal = {
-      node: null
-    };
-
-    try {
-      const node = fn((node = null) => {
-        abortSignal.node = node;
-        throw abortSignal;
-      });
-
-      if (this.state.errors.length > oldState.errors.length) {
-        const failState = this.state;
-        this.state = oldState;
-        return {
-          node,
-          error: failState.errors[oldState.errors.length],
-          thrown: false,
-          aborted: false,
-          failState
-        };
-      }
-
-      return {
-        node,
-        error: null,
-        thrown: false,
-        aborted: false,
-        failState: null
-      };
-    } catch (error) {
-      const failState = this.state;
-      this.state = oldState;
-
-      if (error instanceof SyntaxError) {
-        return {
-          node: null,
-          error,
-          thrown: true,
-          aborted: false,
-          failState
-        };
-      }
-
-      if (error === abortSignal) {
-        return {
-          node: abortSignal.node,
-          error: null,
-          thrown: false,
-          aborted: true,
-          failState
-        };
-      }
-
-      throw error;
-    }
-  }
-
-  checkExpressionErrors(refExpressionErrors, andThrow) {
-    if (!refExpressionErrors) return false;
-    const {
-      shorthandAssign,
-      doubleProto
-    } = refExpressionErrors;
-    if (!andThrow) return shorthandAssign >= 0 || doubleProto >= 0;
-
-    if (shorthandAssign >= 0) {
-      this.unexpected(shorthandAssign);
-    }
-
-    if (doubleProto >= 0) {
-      this.raise(doubleProto, _error.Errors.DuplicateProto);
-    }
-  }
-
-  isLiteralPropertyName() {
-    return this.match(_types.types.name) || !!this.state.type.keyword || this.match(_types.types.string) || this.match(_types.types.num) || this.match(_types.types.bigint) || this.match(_types.types.decimal);
-  }
-
-}
-
-exports.default = UtilParser;
-
-class ExpressionErrors {
-  constructor() {
-    this.shorthandAssign = -1;
-    this.doubleProto = -1;
-  }
-
-}
-
-exports.ExpressionErrors = ExpressionErrors;

node_modules/@babel/parser/lib/plugin-utils.js

@@ -1,108 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.hasPlugin = hasPlugin;
-exports.getPluginOption = getPluginOption;
-exports.validatePlugins = validatePlugins;
-exports.mixinPluginNames = exports.mixinPlugins = void 0;
-
-var _estree = _interopRequireDefault(require("./plugins/estree"));
-
-var _flow = _interopRequireDefault(require("./plugins/flow"));
-
-var _jsx = _interopRequireDefault(require("./plugins/jsx"));
-
-var _typescript = _interopRequireDefault(require("./plugins/typescript"));
-
-var _placeholders = _interopRequireDefault(require("./plugins/placeholders"));
-
-var _v8intrinsic = _interopRequireDefault(require("./plugins/v8intrinsic"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function hasPlugin(plugins, name) {
-  return plugins.some(plugin => {
-    if (Array.isArray(plugin)) {
-      return plugin[0] === name;
-    } else {
-      return plugin === name;
-    }
-  });
-}
-
-function getPluginOption(plugins, name, option) {
-  const plugin = plugins.find(plugin => {
-    if (Array.isArray(plugin)) {
-      return plugin[0] === name;
-    } else {
-      return plugin === name;
-    }
-  });
-
-  if (plugin && Array.isArray(plugin)) {
-    return plugin[1][option];
-  }
-
-  return null;
-}
-
-const PIPELINE_PROPOSALS = ["minimal", "smart", "fsharp"];
-const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
-
-function validatePlugins(plugins) {
-  if (hasPlugin(plugins, "decorators")) {
-    if (hasPlugin(plugins, "decorators-legacy")) {
-      throw new Error("Cannot use the decorators and decorators-legacy plugin together");
-    }
-
-    const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport");
-
-    if (decoratorsBeforeExport == null) {
-      throw new Error("The 'decorators' plugin requires a 'decoratorsBeforeExport' option," + " whose value must be a boolean. If you are migrating from" + " Babylon/Babel 6 or want to use the old decorators proposal, you" + " should use the 'decorators-legacy' plugin instead of 'decorators'.");
-    } else if (typeof decoratorsBeforeExport !== "boolean") {
-      throw new Error("'decoratorsBeforeExport' must be a boolean.");
-    }
-  }
-
-  if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) {
-    throw new Error("Cannot combine flow and typescript plugins.");
-  }
-
-  if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) {
-    throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
-  }
-
-  if (hasPlugin(plugins, "pipelineOperator") && !PIPELINE_PROPOSALS.includes(getPluginOption(plugins, "pipelineOperator", "proposal"))) {
-    throw new Error("'pipelineOperator' requires 'proposal' option whose value should be one of: " + PIPELINE_PROPOSALS.map(p => `'${p}'`).join(", "));
-  }
-
-  if (hasPlugin(plugins, "moduleAttributes")) {
-    if (hasPlugin(plugins, "importAssertions")) {
-      throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
-    }
-
-    const moduleAttributesVerionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
-
-    if (moduleAttributesVerionPluginOption !== "may-2020") {
-      throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'.");
-    }
-  }
-
-  if (hasPlugin(plugins, "recordAndTuple") && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
-    throw new Error("'recordAndTuple' requires 'syntaxType' option whose value should be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", "));
-  }
-}
-
-const mixinPlugins = {
-  estree: _estree.default,
-  jsx: _jsx.default,
-  flow: _flow.default,
-  typescript: _typescript.default,
-  v8intrinsic: _v8intrinsic.default,
-  placeholders: _placeholders.default
-};
-exports.mixinPlugins = mixinPlugins;
-const mixinPluginNames = Object.keys(mixinPlugins);
-exports.mixinPluginNames = mixinPluginNames;

node_modules/@babel/parser/lib/plugins/estree.js

@@ -1,297 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _types = require("../tokenizer/types");
-
-var N = _interopRequireWildcard(require("../types"));
-
-var _scopeflags = require("../util/scopeflags");
-
-var _error = require("../parser/error");
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function isSimpleProperty(node) {
-  return node != null && node.type === "Property" && node.kind === "init" && node.method === false;
-}
-
-var _default = superClass => class extends superClass {
-  estreeParseRegExpLiteral({
-    pattern,
-    flags
-  }) {
-    let regex = null;
-
-    try {
-      regex = new RegExp(pattern, flags);
-    } catch (e) {}
-
-    const node = this.estreeParseLiteral(regex);
-    node.regex = {
-      pattern,
-      flags
-    };
-    return node;
-  }
-
-  estreeParseBigIntLiteral(value) {
-    const bigInt = typeof BigInt !== "undefined" ? BigInt(value) : null;
-    const node = this.estreeParseLiteral(bigInt);
-    node.bigint = String(node.value || value);
-    return node;
-  }
-
-  estreeParseDecimalLiteral(value) {
-    const decimal = null;
-    const node = this.estreeParseLiteral(decimal);
-    node.decimal = String(node.value || value);
-    return node;
-  }
-
-  estreeParseLiteral(value) {
-    return this.parseLiteral(value, "Literal");
-  }
-
-  directiveToStmt(directive) {
-    const directiveLiteral = directive.value;
-    const stmt = this.startNodeAt(directive.start, directive.loc.start);
-    const expression = this.startNodeAt(directiveLiteral.start, directiveLiteral.loc.start);
-    expression.value = directiveLiteral.value;
-    expression.raw = directiveLiteral.extra.raw;
-    stmt.expression = this.finishNodeAt(expression, "Literal", directiveLiteral.end, directiveLiteral.loc.end);
-    stmt.directive = directiveLiteral.extra.raw.slice(1, -1);
-    return this.finishNodeAt(stmt, "ExpressionStatement", directive.end, directive.loc.end);
-  }
-
-  initFunction(node, isAsync) {
-    super.initFunction(node, isAsync);
-    node.expression = false;
-  }
-
-  checkDeclaration(node) {
-    if (isSimpleProperty(node)) {
-      this.checkDeclaration(node.value);
-    } else {
-      super.checkDeclaration(node);
-    }
-  }
-
-  getObjectOrClassMethodParams(method) {
-    return method.value.params;
-  }
-
-  checkLVal(expr, bindingType = _scopeflags.BIND_NONE, checkClashes, contextDescription, disallowLetBinding) {
-    switch (expr.type) {
-      case "ObjectPattern":
-        expr.properties.forEach(prop => {
-          this.checkLVal(prop.type === "Property" ? prop.value : prop, bindingType, checkClashes, "object destructuring pattern", disallowLetBinding);
-        });
-        break;
-
-      default:
-        super.checkLVal(expr, bindingType, checkClashes, contextDescription, disallowLetBinding);
-    }
-  }
-
-  checkProto(prop, isRecord, protoRef, refExpressionErrors) {
-    if (prop.method) {
-      return;
-    }
-
-    super.checkProto(prop, isRecord, protoRef, refExpressionErrors);
-  }
-
-  isValidDirective(stmt) {
-    return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !stmt.expression.extra?.parenthesized;
-  }
-
-  stmtToDirective(stmt) {
-    const directive = super.stmtToDirective(stmt);
-    const value = stmt.expression.value;
-    directive.value.value = value;
-    return directive;
-  }
-
-  parseBlockBody(node, allowDirectives, topLevel, end) {
-    super.parseBlockBody(node, allowDirectives, topLevel, end);
-    const directiveStatements = node.directives.map(d => this.directiveToStmt(d));
-    node.body = directiveStatements.concat(node.body);
-    delete node.directives;
-  }
-
-  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-    this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true);
-
-    if (method.typeParameters) {
-      method.value.typeParameters = method.typeParameters;
-      delete method.typeParameters;
-    }
-
-    classBody.body.push(method);
-  }
-
-  parseExprAtom(refExpressionErrors) {
-    switch (this.state.type) {
-      case _types.types.num:
-      case _types.types.string:
-        return this.estreeParseLiteral(this.state.value);
-
-      case _types.types.regexp:
-        return this.estreeParseRegExpLiteral(this.state.value);
-
-      case _types.types.bigint:
-        return this.estreeParseBigIntLiteral(this.state.value);
-
-      case _types.types.decimal:
-        return this.estreeParseDecimalLiteral(this.state.value);
-
-      case _types.types._null:
-        return this.estreeParseLiteral(null);
-
-      case _types.types._true:
-        return this.estreeParseLiteral(true);
-
-      case _types.types._false:
-        return this.estreeParseLiteral(false);
-
-      default:
-        return super.parseExprAtom(refExpressionErrors);
-    }
-  }
-
-  parseLiteral(value, type, startPos, startLoc) {
-    const node = super.parseLiteral(value, type, startPos, startLoc);
-    node.raw = node.extra.raw;
-    delete node.extra;
-    return node;
-  }
-
-  parseFunctionBody(node, allowExpression, isMethod = false) {
-    super.parseFunctionBody(node, allowExpression, isMethod);
-    node.expression = node.body.type !== "BlockStatement";
-  }
-
-  parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
-    let funcNode = this.startNode();
-    funcNode.kind = node.kind;
-    funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
-    funcNode.type = "FunctionExpression";
-    delete funcNode.kind;
-    node.value = funcNode;
-    type = type === "ClassMethod" ? "MethodDefinition" : type;
-    return this.finishNode(node, type);
-  }
-
-  parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
-    const node = super.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor);
-
-    if (node) {
-      node.type = "Property";
-      if (node.kind === "method") node.kind = "init";
-      node.shorthand = false;
-    }
-
-    return node;
-  }
-
-  parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) {
-    const node = super.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors);
-
-    if (node) {
-      node.kind = "init";
-      node.type = "Property";
-    }
-
-    return node;
-  }
-
-  toAssignable(node) {
-    if (isSimpleProperty(node)) {
-      this.toAssignable(node.value);
-      return node;
-    }
-
-    return super.toAssignable(node);
-  }
-
-  toAssignableObjectExpressionProp(prop, isLast) {
-    if (prop.kind === "get" || prop.kind === "set") {
-      throw this.raise(prop.key.start, _error.Errors.PatternHasAccessor);
-    } else if (prop.method) {
-      throw this.raise(prop.key.start, _error.Errors.PatternHasMethod);
-    } else {
-      super.toAssignableObjectExpressionProp(prop, isLast);
-    }
-  }
-
-  finishCallExpression(node, optional) {
-    super.finishCallExpression(node, optional);
-
-    if (node.callee.type === "Import") {
-      node.type = "ImportExpression";
-      node.source = node.arguments[0];
-      delete node.arguments;
-      delete node.callee;
-    }
-
-    return node;
-  }
-
-  toReferencedArguments(node) {
-    if (node.type === "ImportExpression") {
-      return;
-    }
-
-    super.toReferencedArguments(node);
-  }
-
-  parseExport(node) {
-    super.parseExport(node);
-
-    switch (node.type) {
-      case "ExportAllDeclaration":
-        node.exported = null;
-        break;
-
-      case "ExportNamedDeclaration":
-        if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
-          node.type = "ExportAllDeclaration";
-          node.exported = node.specifiers[0].exported;
-          delete node.specifiers;
-        }
-
-        break;
-    }
-
-    return node;
-  }
-
-  parseSubscript(base, startPos, startLoc, noCalls, state) {
-    const node = super.parseSubscript(base, startPos, startLoc, noCalls, state);
-
-    if (state.optionalChainMember) {
-      if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") {
-        node.type = node.type.substring(8);
-      }
-
-      if (state.stop) {
-        const chain = this.startNodeAtNode(node);
-        chain.expression = node;
-        return this.finishNode(chain, "ChainExpression");
-      }
-    } else if (node.type === "MemberExpression" || node.type === "CallExpression") {
-      node.optional = false;
-    }
-
-    return node;
-  }
-
-};
-
-exports.default = _default;

node_modules/@babel/parser/lib/plugins/flow.js

@@ -1,2821 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _types = require("../tokenizer/types");
-
-var N = _interopRequireWildcard(require("../types"));
-
-var _context = require("../tokenizer/context");
-
-var _identifier = require("../util/identifier");
-
-var _scopeflags = require("../util/scopeflags");
-
-var _error = require("../parser/error");
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]);
-const FlowErrors = Object.freeze({
-  AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
-  AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module",
-  AssignReservedType: "Cannot overwrite reserved type %0",
-  DeclareClassElement: "The `declare` modifier can only appear on class fields.",
-  DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
-  DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement",
-  EnumBooleanMemberNotInitialized: "Boolean enum members need to be initialized. Use either `%0 = true,` or `%0 = false,` in enum `%1`.",
-  EnumDuplicateMemberName: "Enum member names need to be unique, but the name `%0` has already been used before in enum `%1`.",
-  EnumInconsistentMemberValues: "Enum `%0` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.",
-  EnumInvalidExplicitType: "Enum type `%1` is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `%0`.",
-  EnumInvalidExplicitTypeUnknownSupplied: "Supplied enum type is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `%0`.",
-  EnumInvalidMemberInitializerPrimaryType: "Enum `%0` has type `%2`, so the initializer of `%1` needs to be a %2 literal.",
-  EnumInvalidMemberInitializerSymbolType: "Symbol enum members cannot be initialized. Use `%1,` in enum `%0`.",
-  EnumInvalidMemberInitializerUnknownType: "The enum member initializer for `%1` needs to be a literal (either a boolean, number, or string) in enum `%0`.",
-  EnumInvalidMemberName: "Enum member names cannot start with lowercase 'a' through 'z'. Instead of using `%0`, consider using `%1`, in enum `%2`.",
-  EnumNumberMemberNotInitialized: "Number enum members need to be initialized, e.g. `%1 = 1` in enum `%0`.",
-  EnumStringMemberInconsistentlyInitailized: "String enum members need to consistently either all use initializers, or use no initializers, in enum `%0`.",
-  ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements",
-  InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type",
-  InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions",
-  InexactVariance: "Explicit inexact syntax cannot have variance",
-  InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`",
-  MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
-  NestedDeclareModule: "`declare module` cannot be used inside another `declare module`",
-  NestedFlowComment: "Cannot have a flow comment inside another flow comment",
-  OptionalBindingPattern: "A binding pattern parameter cannot be optional in an implementation signature.",
-  SpreadVariance: "Spread properties cannot have variance",
-  TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`",
-  TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis",
-  UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object",
-  UnexpectedReservedType: "Unexpected reserved type %0",
-  UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new",
-  UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
-  UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions",
-  UnexpectedSubtractionOperand: 'Unexpected token, expected "number" or "bigint"',
-  UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration",
-  UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`",
-  UnsupportedDeclareExportKind: "`declare export %0` is not supported. Use `%1` instead",
-  UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module",
-  UnterminatedFlowComment: "Unterminated flow-comment"
-});
-
-function isEsModuleType(bodyElement) {
-  return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration");
-}
-
-function hasTypeImportKind(node) {
-  return node.importKind === "type" || node.importKind === "typeof";
-}
-
-function isMaybeDefaultImport(state) {
-  return (state.type === _types.types.name || !!state.type.keyword) && state.value !== "from";
-}
-
-const exportSuggestions = {
-  const: "declare export var",
-  let: "declare export var",
-  type: "export type",
-  interface: "export interface"
-};
-
-function partition(list, test) {
-  const list1 = [];
-  const list2 = [];
-
-  for (let i = 0; i < list.length; i++) {
-    (test(list[i], i, list) ? list1 : list2).push(list[i]);
-  }
-
-  return [list1, list2];
-}
-
-const FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
-
-var _default = superClass => {
-  var _temp;
-
-  return _temp = class extends superClass {
-    constructor(options, input) {
-      super(options, input);
-      this.flowPragma = void 0;
-      this.flowPragma = undefined;
-    }
-
-    shouldParseTypes() {
-      return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
-    }
-
-    shouldParseEnums() {
-      return !!this.getPluginOption("flow", "enums");
-    }
-
-    finishToken(type, val) {
-      if (type !== _types.types.string && type !== _types.types.semi && type !== _types.types.interpreterDirective) {
-        if (this.flowPragma === undefined) {
-          this.flowPragma = null;
-        }
-      }
-
-      return super.finishToken(type, val);
-    }
-
-    addComment(comment) {
-      if (this.flowPragma === undefined) {
-        const matches = FLOW_PRAGMA_REGEX.exec(comment.value);
-
-        if (!matches) {} else if (matches[1] === "flow") {
-          this.flowPragma = "flow";
-        } else if (matches[1] === "noflow") {
-          this.flowPragma = "noflow";
-        } else {
-          throw new Error("Unexpected flow pragma");
-        }
-      }
-
-      return super.addComment(comment);
-    }
-
-    flowParseTypeInitialiser(tok) {
-      const oldInType = this.state.inType;
-      this.state.inType = true;
-      this.expect(tok || _types.types.colon);
-      const type = this.flowParseType();
-      this.state.inType = oldInType;
-      return type;
-    }
-
-    flowParsePredicate() {
-      const node = this.startNode();
-      const moduloLoc = this.state.startLoc;
-      const moduloPos = this.state.start;
-      this.expect(_types.types.modulo);
-      const checksLoc = this.state.startLoc;
-      this.expectContextual("checks");
-
-      if (moduloLoc.line !== checksLoc.line || moduloLoc.column !== checksLoc.column - 1) {
-        this.raise(moduloPos, FlowErrors.UnexpectedSpaceBetweenModuloChecks);
-      }
-
-      if (this.eat(_types.types.parenL)) {
-        node.value = this.parseExpression();
-        this.expect(_types.types.parenR);
-        return this.finishNode(node, "DeclaredPredicate");
-      } else {
-        return this.finishNode(node, "InferredPredicate");
-      }
-    }
-
-    flowParseTypeAndPredicateInitialiser() {
-      const oldInType = this.state.inType;
-      this.state.inType = true;
-      this.expect(_types.types.colon);
-      let type = null;
-      let predicate = null;
-
-      if (this.match(_types.types.modulo)) {
-        this.state.inType = oldInType;
-        predicate = this.flowParsePredicate();
-      } else {
-        type = this.flowParseType();
-        this.state.inType = oldInType;
-
-        if (this.match(_types.types.modulo)) {
-          predicate = this.flowParsePredicate();
-        }
-      }
-
-      return [type, predicate];
-    }
-
-    flowParseDeclareClass(node) {
-      this.next();
-      this.flowParseInterfaceish(node, true);
-      return this.finishNode(node, "DeclareClass");
-    }
-
-    flowParseDeclareFunction(node) {
-      this.next();
-      const id = node.id = this.parseIdentifier();
-      const typeNode = this.startNode();
-      const typeContainer = this.startNode();
-
-      if (this.isRelational("<")) {
-        typeNode.typeParameters = this.flowParseTypeParameterDeclaration();
-      } else {
-        typeNode.typeParameters = null;
-      }
-
-      this.expect(_types.types.parenL);
-      const tmp = this.flowParseFunctionTypeParams();
-      typeNode.params = tmp.params;
-      typeNode.rest = tmp.rest;
-      this.expect(_types.types.parenR);
-      [typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
-      typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation");
-      id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
-      this.resetEndLocation(id);
-      this.semicolon();
-      return this.finishNode(node, "DeclareFunction");
-    }
-
-    flowParseDeclare(node, insideModule) {
-      if (this.match(_types.types._class)) {
-        return this.flowParseDeclareClass(node);
-      } else if (this.match(_types.types._function)) {
-        return this.flowParseDeclareFunction(node);
-      } else if (this.match(_types.types._var)) {
-        return this.flowParseDeclareVariable(node);
-      } else if (this.eatContextual("module")) {
-        if (this.match(_types.types.dot)) {
-          return this.flowParseDeclareModuleExports(node);
-        } else {
-          if (insideModule) {
-            this.raise(this.state.lastTokStart, FlowErrors.NestedDeclareModule);
-          }
-
-          return this.flowParseDeclareModule(node);
-        }
-      } else if (this.isContextual("type")) {
-        return this.flowParseDeclareTypeAlias(node);
-      } else if (this.isContextual("opaque")) {
-        return this.flowParseDeclareOpaqueType(node);
-      } else if (this.isContextual("interface")) {
-        return this.flowParseDeclareInterface(node);
-      } else if (this.match(_types.types._export)) {
-        return this.flowParseDeclareExportDeclaration(node, insideModule);
-      } else {
-        throw this.unexpected();
-      }
-    }
-
-    flowParseDeclareVariable(node) {
-      this.next();
-      node.id = this.flowParseTypeAnnotatableIdentifier(true);
-      this.scope.declareName(node.id.name, _scopeflags.BIND_VAR, node.id.start);
-      this.semicolon();
-      return this.finishNode(node, "DeclareVariable");
-    }
-
-    flowParseDeclareModule(node) {
-      this.scope.enter(_scopeflags.SCOPE_OTHER);
-
-      if (this.match(_types.types.string)) {
-        node.id = this.parseExprAtom();
-      } else {
-        node.id = this.parseIdentifier();
-      }
-
-      const bodyNode = node.body = this.startNode();
-      const body = bodyNode.body = [];
-      this.expect(_types.types.braceL);
-
-      while (!this.match(_types.types.braceR)) {
-        let bodyNode = this.startNode();
-
-        if (this.match(_types.types._import)) {
-          this.next();
-
-          if (!this.isContextual("type") && !this.match(_types.types._typeof)) {
-            this.raise(this.state.lastTokStart, FlowErrors.InvalidNonTypeImportInDeclareModule);
-          }
-
-          this.parseImport(bodyNode);
-        } else {
-          this.expectContextual("declare", FlowErrors.UnsupportedStatementInDeclareModule);
-          bodyNode = this.flowParseDeclare(bodyNode, true);
-        }
-
-        body.push(bodyNode);
-      }
-
-      this.scope.exit();
-      this.expect(_types.types.braceR);
-      this.finishNode(bodyNode, "BlockStatement");
-      let kind = null;
-      let hasModuleExport = false;
-      body.forEach(bodyElement => {
-        if (isEsModuleType(bodyElement)) {
-          if (kind === "CommonJS") {
-            this.raise(bodyElement.start, FlowErrors.AmbiguousDeclareModuleKind);
-          }
-
-          kind = "ES";
-        } else if (bodyElement.type === "DeclareModuleExports") {
-          if (hasModuleExport) {
-            this.raise(bodyElement.start, FlowErrors.DuplicateDeclareModuleExports);
-          }
-
-          if (kind === "ES") {
-            this.raise(bodyElement.start, FlowErrors.AmbiguousDeclareModuleKind);
-          }
-
-          kind = "CommonJS";
-          hasModuleExport = true;
-        }
-      });
-      node.kind = kind || "CommonJS";
-      return this.finishNode(node, "DeclareModule");
-    }
-
-    flowParseDeclareExportDeclaration(node, insideModule) {
-      this.expect(_types.types._export);
-
-      if (this.eat(_types.types._default)) {
-        if (this.match(_types.types._function) || this.match(_types.types._class)) {
-          node.declaration = this.flowParseDeclare(this.startNode());
-        } else {
-          node.declaration = this.flowParseType();
-          this.semicolon();
-        }
-
-        node.default = true;
-        return this.finishNode(node, "DeclareExportDeclaration");
-      } else {
-        if (this.match(_types.types._const) || this.isLet() || (this.isContextual("type") || this.isContextual("interface")) && !insideModule) {
-          const label = this.state.value;
-          const suggestion = exportSuggestions[label];
-          throw this.raise(this.state.start, FlowErrors.UnsupportedDeclareExportKind, label, suggestion);
-        }
-
-        if (this.match(_types.types._var) || this.match(_types.types._function) || this.match(_types.types._class) || this.isContextual("opaque")) {
-            node.declaration = this.flowParseDeclare(this.startNode());
-            node.default = false;
-            return this.finishNode(node, "DeclareExportDeclaration");
-          } else if (this.match(_types.types.star) || this.match(_types.types.braceL) || this.isContextual("interface") || this.isContextual("type") || this.isContextual("opaque")) {
-            node = this.parseExport(node);
-
-            if (node.type === "ExportNamedDeclaration") {
-              node.type = "ExportDeclaration";
-              node.default = false;
-              delete node.exportKind;
-            }
-
-            node.type = "Declare" + node.type;
-            return node;
-          }
-      }
-
-      throw this.unexpected();
-    }
-
-    flowParseDeclareModuleExports(node) {
-      this.next();
-      this.expectContextual("exports");
-      node.typeAnnotation = this.flowParseTypeAnnotation();
-      this.semicolon();
-      return this.finishNode(node, "DeclareModuleExports");
-    }
-
-    flowParseDeclareTypeAlias(node) {
-      this.next();
-      this.flowParseTypeAlias(node);
-      node.type = "DeclareTypeAlias";
-      return node;
-    }
-
-    flowParseDeclareOpaqueType(node) {
-      this.next();
-      this.flowParseOpaqueType(node, true);
-      node.type = "DeclareOpaqueType";
-      return node;
-    }
-
-    flowParseDeclareInterface(node) {
-      this.next();
-      this.flowParseInterfaceish(node);
-      return this.finishNode(node, "DeclareInterface");
-    }
-
-    flowParseInterfaceish(node, isClass = false) {
-      node.id = this.flowParseRestrictedIdentifier(!isClass, true);
-      this.scope.declareName(node.id.name, isClass ? _scopeflags.BIND_FUNCTION : _scopeflags.BIND_LEXICAL, node.id.start);
-
-      if (this.isRelational("<")) {
-        node.typeParameters = this.flowParseTypeParameterDeclaration();
-      } else {
-        node.typeParameters = null;
-      }
-
-      node.extends = [];
-      node.implements = [];
-      node.mixins = [];
-
-      if (this.eat(_types.types._extends)) {
-        do {
-          node.extends.push(this.flowParseInterfaceExtends());
-        } while (!isClass && this.eat(_types.types.comma));
-      }
-
-      if (this.isContextual("mixins")) {
-        this.next();
-
-        do {
-          node.mixins.push(this.flowParseInterfaceExtends());
-        } while (this.eat(_types.types.comma));
-      }
-
-      if (this.isContextual("implements")) {
-        this.next();
-
-        do {
-          node.implements.push(this.flowParseInterfaceExtends());
-        } while (this.eat(_types.types.comma));
-      }
-
-      node.body = this.flowParseObjectType({
-        allowStatic: isClass,
-        allowExact: false,
-        allowSpread: false,
-        allowProto: isClass,
-        allowInexact: false
-      });
-    }
-
-    flowParseInterfaceExtends() {
-      const node = this.startNode();
-      node.id = this.flowParseQualifiedTypeIdentifier();
-
-      if (this.isRelational("<")) {
-        node.typeParameters = this.flowParseTypeParameterInstantiation();
-      } else {
-        node.typeParameters = null;
-      }
-
-      return this.finishNode(node, "InterfaceExtends");
-    }
-
-    flowParseInterface(node) {
-      this.flowParseInterfaceish(node);
-      return this.finishNode(node, "InterfaceDeclaration");
-    }
-
-    checkNotUnderscore(word) {
-      if (word === "_") {
-        this.raise(this.state.start, FlowErrors.UnexpectedReservedUnderscore);
-      }
-    }
-
-    checkReservedType(word, startLoc, declaration) {
-      if (!reservedTypes.has(word)) return;
-      this.raise(startLoc, declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, word);
-    }
-
-    flowParseRestrictedIdentifier(liberal, declaration) {
-      this.checkReservedType(this.state.value, this.state.start, declaration);
-      return this.parseIdentifier(liberal);
-    }
-
-    flowParseTypeAlias(node) {
-      node.id = this.flowParseRestrictedIdentifier(false, true);
-      this.scope.declareName(node.id.name, _scopeflags.BIND_LEXICAL, node.id.start);
-
-      if (this.isRelational("<")) {
-        node.typeParameters = this.flowParseTypeParameterDeclaration();
-      } else {
-        node.typeParameters = null;
-      }
-
-      node.right = this.flowParseTypeInitialiser(_types.types.eq);
-      this.semicolon();
-      return this.finishNode(node, "TypeAlias");
-    }
-
-    flowParseOpaqueType(node, declare) {
-      this.expectContextual("type");
-      node.id = this.flowParseRestrictedIdentifier(true, true);
-      this.scope.declareName(node.id.name, _scopeflags.BIND_LEXICAL, node.id.start);
-
-      if (this.isRelational("<")) {
-        node.typeParameters = this.flowParseTypeParameterDeclaration();
-      } else {
-        node.typeParameters = null;
-      }
-
-      node.supertype = null;
-
-      if (this.match(_types.types.colon)) {
-        node.supertype = this.flowParseTypeInitialiser(_types.types.colon);
-      }
-
-      node.impltype = null;
-
-      if (!declare) {
-        node.impltype = this.flowParseTypeInitialiser(_types.types.eq);
-      }
-
-      this.semicolon();
-      return this.finishNode(node, "OpaqueType");
-    }
-
-    flowParseTypeParameter(requireDefault = false) {
-      const nodeStart = this.state.start;
-      const node = this.startNode();
-      const variance = this.flowParseVariance();
-      const ident = this.flowParseTypeAnnotatableIdentifier();
-      node.name = ident.name;
-      node.variance = variance;
-      node.bound = ident.typeAnnotation;
-
-      if (this.match(_types.types.eq)) {
-        this.eat(_types.types.eq);
-        node.default = this.flowParseType();
-      } else {
-        if (requireDefault) {
-          this.raise(nodeStart, FlowErrors.MissingTypeParamDefault);
-        }
-      }
-
-      return this.finishNode(node, "TypeParameter");
-    }
-
-    flowParseTypeParameterDeclaration() {
-      const oldInType = this.state.inType;
-      const node = this.startNode();
-      node.params = [];
-      this.state.inType = true;
-
-      if (this.isRelational("<") || this.match(_types.types.jsxTagStart)) {
-        this.next();
-      } else {
-        this.unexpected();
-      }
-
-      let defaultRequired = false;
-
-      do {
-        const typeParameter = this.flowParseTypeParameter(defaultRequired);
-        node.params.push(typeParameter);
-
-        if (typeParameter.default) {
-          defaultRequired = true;
-        }
-
-        if (!this.isRelational(">")) {
-          this.expect(_types.types.comma);
-        }
-      } while (!this.isRelational(">"));
-
-      this.expectRelational(">");
-      this.state.inType = oldInType;
-      return this.finishNode(node, "TypeParameterDeclaration");
-    }
-
-    flowParseTypeParameterInstantiation() {
-      const node = this.startNode();
-      const oldInType = this.state.inType;
-      node.params = [];
-      this.state.inType = true;
-      this.expectRelational("<");
-      const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-      this.state.noAnonFunctionType = false;
-
-      while (!this.isRelational(">")) {
-        node.params.push(this.flowParseType());
-
-        if (!this.isRelational(">")) {
-          this.expect(_types.types.comma);
-        }
-      }
-
-      this.state.noAnonFunctionType = oldNoAnonFunctionType;
-      this.expectRelational(">");
-      this.state.inType = oldInType;
-      return this.finishNode(node, "TypeParameterInstantiation");
-    }
-
-    flowParseTypeParameterInstantiationCallOrNew() {
-      const node = this.startNode();
-      const oldInType = this.state.inType;
-      node.params = [];
-      this.state.inType = true;
-      this.expectRelational("<");
-
-      while (!this.isRelational(">")) {
-        node.params.push(this.flowParseTypeOrImplicitInstantiation());
-
-        if (!this.isRelational(">")) {
-          this.expect(_types.types.comma);
-        }
-      }
-
-      this.expectRelational(">");
-      this.state.inType = oldInType;
-      return this.finishNode(node, "TypeParameterInstantiation");
-    }
-
-    flowParseInterfaceType() {
-      const node = this.startNode();
-      this.expectContextual("interface");
-      node.extends = [];
-
-      if (this.eat(_types.types._extends)) {
-        do {
-          node.extends.push(this.flowParseInterfaceExtends());
-        } while (this.eat(_types.types.comma));
-      }
-
-      node.body = this.flowParseObjectType({
-        allowStatic: false,
-        allowExact: false,
-        allowSpread: false,
-        allowProto: false,
-        allowInexact: false
-      });
-      return this.finishNode(node, "InterfaceTypeAnnotation");
-    }
-
-    flowParseObjectPropertyKey() {
-      return this.match(_types.types.num) || this.match(_types.types.string) ? this.parseExprAtom() : this.parseIdentifier(true);
-    }
-
-    flowParseObjectTypeIndexer(node, isStatic, variance) {
-      node.static = isStatic;
-
-      if (this.lookahead().type === _types.types.colon) {
-        node.id = this.flowParseObjectPropertyKey();
-        node.key = this.flowParseTypeInitialiser();
-      } else {
-        node.id = null;
-        node.key = this.flowParseType();
-      }
-
-      this.expect(_types.types.bracketR);
-      node.value = this.flowParseTypeInitialiser();
-      node.variance = variance;
-      return this.finishNode(node, "ObjectTypeIndexer");
-    }
-
-    flowParseObjectTypeInternalSlot(node, isStatic) {
-      node.static = isStatic;
-      node.id = this.flowParseObjectPropertyKey();
-      this.expect(_types.types.bracketR);
-      this.expect(_types.types.bracketR);
-
-      if (this.isRelational("<") || this.match(_types.types.parenL)) {
-        node.method = true;
-        node.optional = false;
-        node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start));
-      } else {
-        node.method = false;
-
-        if (this.eat(_types.types.question)) {
-          node.optional = true;
-        }
-
-        node.value = this.flowParseTypeInitialiser();
-      }
-
-      return this.finishNode(node, "ObjectTypeInternalSlot");
-    }
-
-    flowParseObjectTypeMethodish(node) {
-      node.params = [];
-      node.rest = null;
-      node.typeParameters = null;
-
-      if (this.isRelational("<")) {
-        node.typeParameters = this.flowParseTypeParameterDeclaration();
-      }
-
-      this.expect(_types.types.parenL);
-
-      while (!this.match(_types.types.parenR) && !this.match(_types.types.ellipsis)) {
-        node.params.push(this.flowParseFunctionTypeParam());
-
-        if (!this.match(_types.types.parenR)) {
-          this.expect(_types.types.comma);
-        }
-      }
-
-      if (this.eat(_types.types.ellipsis)) {
-        node.rest = this.flowParseFunctionTypeParam();
-      }
-
-      this.expect(_types.types.parenR);
-      node.returnType = this.flowParseTypeInitialiser();
-      return this.finishNode(node, "FunctionTypeAnnotation");
-    }
-
-    flowParseObjectTypeCallProperty(node, isStatic) {
-      const valueNode = this.startNode();
-      node.static = isStatic;
-      node.value = this.flowParseObjectTypeMethodish(valueNode);
-      return this.finishNode(node, "ObjectTypeCallProperty");
-    }
-
-    flowParseObjectType({
-      allowStatic,
-      allowExact,
-      allowSpread,
-      allowProto,
-      allowInexact
-    }) {
-      const oldInType = this.state.inType;
-      this.state.inType = true;
-      const nodeStart = this.startNode();
-      nodeStart.callProperties = [];
-      nodeStart.properties = [];
-      nodeStart.indexers = [];
-      nodeStart.internalSlots = [];
-      let endDelim;
-      let exact;
-      let inexact = false;
-
-      if (allowExact && this.match(_types.types.braceBarL)) {
-        this.expect(_types.types.braceBarL);
-        endDelim = _types.types.braceBarR;
-        exact = true;
-      } else {
-        this.expect(_types.types.braceL);
-        endDelim = _types.types.braceR;
-        exact = false;
-      }
-
-      nodeStart.exact = exact;
-
-      while (!this.match(endDelim)) {
-        let isStatic = false;
-        let protoStart = null;
-        let inexactStart = null;
-        const node = this.startNode();
-
-        if (allowProto && this.isContextual("proto")) {
-          const lookahead = this.lookahead();
-
-          if (lookahead.type !== _types.types.colon && lookahead.type !== _types.types.question) {
-            this.next();
-            protoStart = this.state.start;
-            allowStatic = false;
-          }
-        }
-
-        if (allowStatic && this.isContextual("static")) {
-          const lookahead = this.lookahead();
-
-          if (lookahead.type !== _types.types.colon && lookahead.type !== _types.types.question) {
-            this.next();
-            isStatic = true;
-          }
-        }
-
-        const variance = this.flowParseVariance();
-
-        if (this.eat(_types.types.bracketL)) {
-          if (protoStart != null) {
-            this.unexpected(protoStart);
-          }
-
-          if (this.eat(_types.types.bracketL)) {
-            if (variance) {
-              this.unexpected(variance.start);
-            }
-
-            nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic));
-          } else {
-            nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance));
-          }
-        } else if (this.match(_types.types.parenL) || this.isRelational("<")) {
-          if (protoStart != null) {
-            this.unexpected(protoStart);
-          }
-
-          if (variance) {
-            this.unexpected(variance.start);
-          }
-
-          nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));
-        } else {
-          let kind = "init";
-
-          if (this.isContextual("get") || this.isContextual("set")) {
-            const lookahead = this.lookahead();
-
-            if (lookahead.type === _types.types.name || lookahead.type === _types.types.string || lookahead.type === _types.types.num) {
-              kind = this.state.value;
-              this.next();
-            }
-          }
-
-          const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStart, variance, kind, allowSpread, allowInexact ?? !exact);
-
-          if (propOrInexact === null) {
-            inexact = true;
-            inexactStart = this.state.lastTokStart;
-          } else {
-            nodeStart.properties.push(propOrInexact);
-          }
-        }
-
-        this.flowObjectTypeSemicolon();
-
-        if (inexactStart && !this.match(_types.types.braceR) && !this.match(_types.types.braceBarR)) {
-          this.raise(inexactStart, FlowErrors.UnexpectedExplicitInexactInObject);
-        }
-      }
-
-      this.expect(endDelim);
-
-      if (allowSpread) {
-        nodeStart.inexact = inexact;
-      }
-
-      const out = this.finishNode(nodeStart, "ObjectTypeAnnotation");
-      this.state.inType = oldInType;
-      return out;
-    }
-
-    flowParseObjectTypeProperty(node, isStatic, protoStart, variance, kind, allowSpread, allowInexact) {
-      if (this.eat(_types.types.ellipsis)) {
-        const isInexactToken = this.match(_types.types.comma) || this.match(_types.types.semi) || this.match(_types.types.braceR) || this.match(_types.types.braceBarR);
-
-        if (isInexactToken) {
-          if (!allowSpread) {
-            this.raise(this.state.lastTokStart, FlowErrors.InexactInsideNonObject);
-          } else if (!allowInexact) {
-            this.raise(this.state.lastTokStart, FlowErrors.InexactInsideExact);
-          }
-
-          if (variance) {
-            this.raise(variance.start, FlowErrors.InexactVariance);
-          }
-
-          return null;
-        }
-
-        if (!allowSpread) {
-          this.raise(this.state.lastTokStart, FlowErrors.UnexpectedSpreadType);
-        }
-
-        if (protoStart != null) {
-          this.unexpected(protoStart);
-        }
-
-        if (variance) {
-          this.raise(variance.start, FlowErrors.SpreadVariance);
-        }
-
-        node.argument = this.flowParseType();
-        return this.finishNode(node, "ObjectTypeSpreadProperty");
-      } else {
-        node.key = this.flowParseObjectPropertyKey();
-        node.static = isStatic;
-        node.proto = protoStart != null;
-        node.kind = kind;
-        let optional = false;
-
-        if (this.isRelational("<") || this.match(_types.types.parenL)) {
-          node.method = true;
-
-          if (protoStart != null) {
-            this.unexpected(protoStart);
-          }
-
-          if (variance) {
-            this.unexpected(variance.start);
-          }
-
-          node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start));
-
-          if (kind === "get" || kind === "set") {
-            this.flowCheckGetterSetterParams(node);
-          }
-        } else {
-          if (kind !== "init") this.unexpected();
-          node.method = false;
-
-          if (this.eat(_types.types.question)) {
-            optional = true;
-          }
-
-          node.value = this.flowParseTypeInitialiser();
-          node.variance = variance;
-        }
-
-        node.optional = optional;
-        return this.finishNode(node, "ObjectTypeProperty");
-      }
-    }
-
-    flowCheckGetterSetterParams(property) {
-      const paramCount = property.kind === "get" ? 0 : 1;
-      const start = property.start;
-      const length = property.value.params.length + (property.value.rest ? 1 : 0);
-
-      if (length !== paramCount) {
-        if (property.kind === "get") {
-          this.raise(start, _error.Errors.BadGetterArity);
-        } else {
-          this.raise(start, _error.Errors.BadSetterArity);
-        }
-      }
-
-      if (property.kind === "set" && property.value.rest) {
-        this.raise(start, _error.Errors.BadSetterRestParameter);
-      }
-    }
-
-    flowObjectTypeSemicolon() {
-      if (!this.eat(_types.types.semi) && !this.eat(_types.types.comma) && !this.match(_types.types.braceR) && !this.match(_types.types.braceBarR)) {
-        this.unexpected();
-      }
-    }
-
-    flowParseQualifiedTypeIdentifier(startPos, startLoc, id) {
-      startPos = startPos || this.state.start;
-      startLoc = startLoc || this.state.startLoc;
-      let node = id || this.flowParseRestrictedIdentifier(true);
-
-      while (this.eat(_types.types.dot)) {
-        const node2 = this.startNodeAt(startPos, startLoc);
-        node2.qualification = node;
-        node2.id = this.flowParseRestrictedIdentifier(true);
-        node = this.finishNode(node2, "QualifiedTypeIdentifier");
-      }
-
-      return node;
-    }
-
-    flowParseGenericType(startPos, startLoc, id) {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.typeParameters = null;
-      node.id = this.flowParseQualifiedTypeIdentifier(startPos, startLoc, id);
-
-      if (this.isRelational("<")) {
-        node.typeParameters = this.flowParseTypeParameterInstantiation();
-      }
-
-      return this.finishNode(node, "GenericTypeAnnotation");
-    }
-
-    flowParseTypeofType() {
-      const node = this.startNode();
-      this.expect(_types.types._typeof);
-      node.argument = this.flowParsePrimaryType();
-      return this.finishNode(node, "TypeofTypeAnnotation");
-    }
-
-    flowParseTupleType() {
-      const node = this.startNode();
-      node.types = [];
-      this.expect(_types.types.bracketL);
-
-      while (this.state.pos < this.length && !this.match(_types.types.bracketR)) {
-        node.types.push(this.flowParseType());
-        if (this.match(_types.types.bracketR)) break;
-        this.expect(_types.types.comma);
-      }
-
-      this.expect(_types.types.bracketR);
-      return this.finishNode(node, "TupleTypeAnnotation");
-    }
-
-    flowParseFunctionTypeParam() {
-      let name = null;
-      let optional = false;
-      let typeAnnotation = null;
-      const node = this.startNode();
-      const lh = this.lookahead();
-
-      if (lh.type === _types.types.colon || lh.type === _types.types.question) {
-        name = this.parseIdentifier();
-
-        if (this.eat(_types.types.question)) {
-          optional = true;
-        }
-
-        typeAnnotation = this.flowParseTypeInitialiser();
-      } else {
-        typeAnnotation = this.flowParseType();
-      }
-
-      node.name = name;
-      node.optional = optional;
-      node.typeAnnotation = typeAnnotation;
-      return this.finishNode(node, "FunctionTypeParam");
-    }
-
-    reinterpretTypeAsFunctionTypeParam(type) {
-      const node = this.startNodeAt(type.start, type.loc.start);
-      node.name = null;
-      node.optional = false;
-      node.typeAnnotation = type;
-      return this.finishNode(node, "FunctionTypeParam");
-    }
-
-    flowParseFunctionTypeParams(params = []) {
-      let rest = null;
-
-      while (!this.match(_types.types.parenR) && !this.match(_types.types.ellipsis)) {
-        params.push(this.flowParseFunctionTypeParam());
-
-        if (!this.match(_types.types.parenR)) {
-          this.expect(_types.types.comma);
-        }
-      }
-
-      if (this.eat(_types.types.ellipsis)) {
-        rest = this.flowParseFunctionTypeParam();
-      }
-
-      return {
-        params,
-        rest
-      };
-    }
-
-    flowIdentToTypeAnnotation(startPos, startLoc, node, id) {
-      switch (id.name) {
-        case "any":
-          return this.finishNode(node, "AnyTypeAnnotation");
-
-        case "bool":
-        case "boolean":
-          return this.finishNode(node, "BooleanTypeAnnotation");
-
-        case "mixed":
-          return this.finishNode(node, "MixedTypeAnnotation");
-
-        case "empty":
-          return this.finishNode(node, "EmptyTypeAnnotation");
-
-        case "number":
-          return this.finishNode(node, "NumberTypeAnnotation");
-
-        case "string":
-          return this.finishNode(node, "StringTypeAnnotation");
-
-        case "symbol":
-          return this.finishNode(node, "SymbolTypeAnnotation");
-
-        default:
-          this.checkNotUnderscore(id.name);
-          return this.flowParseGenericType(startPos, startLoc, id);
-      }
-    }
-
-    flowParsePrimaryType() {
-      const startPos = this.state.start;
-      const startLoc = this.state.startLoc;
-      const node = this.startNode();
-      let tmp;
-      let type;
-      let isGroupedType = false;
-      const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-
-      switch (this.state.type) {
-        case _types.types.name:
-          if (this.isContextual("interface")) {
-            return this.flowParseInterfaceType();
-          }
-
-          return this.flowIdentToTypeAnnotation(startPos, startLoc, node, this.parseIdentifier());
-
-        case _types.types.braceL:
-          return this.flowParseObjectType({
-            allowStatic: false,
-            allowExact: false,
-            allowSpread: true,
-            allowProto: false,
-            allowInexact: true
-          });
-
-        case _types.types.braceBarL:
-          return this.flowParseObjectType({
-            allowStatic: false,
-            allowExact: true,
-            allowSpread: true,
-            allowProto: false,
-            allowInexact: false
-          });
-
-        case _types.types.bracketL:
-          this.state.noAnonFunctionType = false;
-          type = this.flowParseTupleType();
-          this.state.noAnonFunctionType = oldNoAnonFunctionType;
-          return type;
-
-        case _types.types.relational:
-          if (this.state.value === "<") {
-            node.typeParameters = this.flowParseTypeParameterDeclaration();
-            this.expect(_types.types.parenL);
-            tmp = this.flowParseFunctionTypeParams();
-            node.params = tmp.params;
-            node.rest = tmp.rest;
-            this.expect(_types.types.parenR);
-            this.expect(_types.types.arrow);
-            node.returnType = this.flowParseType();
-            return this.finishNode(node, "FunctionTypeAnnotation");
-          }
-
-          break;
-
-        case _types.types.parenL:
-          this.next();
-
-          if (!this.match(_types.types.parenR) && !this.match(_types.types.ellipsis)) {
-            if (this.match(_types.types.name)) {
-              const token = this.lookahead().type;
-              isGroupedType = token !== _types.types.question && token !== _types.types.colon;
-            } else {
-              isGroupedType = true;
-            }
-          }
-
-          if (isGroupedType) {
-            this.state.noAnonFunctionType = false;
-            type = this.flowParseType();
-            this.state.noAnonFunctionType = oldNoAnonFunctionType;
-
-            if (this.state.noAnonFunctionType || !(this.match(_types.types.comma) || this.match(_types.types.parenR) && this.lookahead().type === _types.types.arrow)) {
-              this.expect(_types.types.parenR);
-              return type;
-            } else {
-              this.eat(_types.types.comma);
-            }
-          }
-
-          if (type) {
-            tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
-          } else {
-            tmp = this.flowParseFunctionTypeParams();
-          }
-
-          node.params = tmp.params;
-          node.rest = tmp.rest;
-          this.expect(_types.types.parenR);
-          this.expect(_types.types.arrow);
-          node.returnType = this.flowParseType();
-          node.typeParameters = null;
-          return this.finishNode(node, "FunctionTypeAnnotation");
-
-        case _types.types.string:
-          return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
-
-        case _types.types._true:
-        case _types.types._false:
-          node.value = this.match(_types.types._true);
-          this.next();
-          return this.finishNode(node, "BooleanLiteralTypeAnnotation");
-
-        case _types.types.plusMin:
-          if (this.state.value === "-") {
-            this.next();
-
-            if (this.match(_types.types.num)) {
-              return this.parseLiteral(-this.state.value, "NumberLiteralTypeAnnotation", node.start, node.loc.start);
-            }
-
-            if (this.match(_types.types.bigint)) {
-              return this.parseLiteral(-this.state.value, "BigIntLiteralTypeAnnotation", node.start, node.loc.start);
-            }
-
-            throw this.raise(this.state.start, FlowErrors.UnexpectedSubtractionOperand);
-          }
-
-          throw this.unexpected();
-
-        case _types.types.num:
-          return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
-
-        case _types.types.bigint:
-          return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation");
-
-        case _types.types._void:
-          this.next();
-          return this.finishNode(node, "VoidTypeAnnotation");
-
-        case _types.types._null:
-          this.next();
-          return this.finishNode(node, "NullLiteralTypeAnnotation");
-
-        case _types.types._this:
-          this.next();
-          return this.finishNode(node, "ThisTypeAnnotation");
-
-        case _types.types.star:
-          this.next();
-          return this.finishNode(node, "ExistsTypeAnnotation");
-
-        default:
-          if (this.state.type.keyword === "typeof") {
-            return this.flowParseTypeofType();
-          } else if (this.state.type.keyword) {
-            const label = this.state.type.label;
-            this.next();
-            return super.createIdentifier(node, label);
-          }
-
-      }
-
-      throw this.unexpected();
-    }
-
-    flowParsePostfixType() {
-      const startPos = this.state.start,
-            startLoc = this.state.startLoc;
-      let type = this.flowParsePrimaryType();
-
-      while (this.match(_types.types.bracketL) && !this.canInsertSemicolon()) {
-        const node = this.startNodeAt(startPos, startLoc);
-        node.elementType = type;
-        this.expect(_types.types.bracketL);
-        this.expect(_types.types.bracketR);
-        type = this.finishNode(node, "ArrayTypeAnnotation");
-      }
-
-      return type;
-    }
-
-    flowParsePrefixType() {
-      const node = this.startNode();
-
-      if (this.eat(_types.types.question)) {
-        node.typeAnnotation = this.flowParsePrefixType();
-        return this.finishNode(node, "NullableTypeAnnotation");
-      } else {
-        return this.flowParsePostfixType();
-      }
-    }
-
-    flowParseAnonFunctionWithoutParens() {
-      const param = this.flowParsePrefixType();
-
-      if (!this.state.noAnonFunctionType && this.eat(_types.types.arrow)) {
-        const node = this.startNodeAt(param.start, param.loc.start);
-        node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];
-        node.rest = null;
-        node.returnType = this.flowParseType();
-        node.typeParameters = null;
-        return this.finishNode(node, "FunctionTypeAnnotation");
-      }
-
-      return param;
-    }
-
-    flowParseIntersectionType() {
-      const node = this.startNode();
-      this.eat(_types.types.bitwiseAND);
-      const type = this.flowParseAnonFunctionWithoutParens();
-      node.types = [type];
-
-      while (this.eat(_types.types.bitwiseAND)) {
-        node.types.push(this.flowParseAnonFunctionWithoutParens());
-      }
-
-      return node.types.length === 1 ? type : this.finishNode(node, "IntersectionTypeAnnotation");
-    }
-
-    flowParseUnionType() {
-      const node = this.startNode();
-      this.eat(_types.types.bitwiseOR);
-      const type = this.flowParseIntersectionType();
-      node.types = [type];
-
-      while (this.eat(_types.types.bitwiseOR)) {
-        node.types.push(this.flowParseIntersectionType());
-      }
-
-      return node.types.length === 1 ? type : this.finishNode(node, "UnionTypeAnnotation");
-    }
-
-    flowParseType() {
-      const oldInType = this.state.inType;
-      this.state.inType = true;
-      const type = this.flowParseUnionType();
-      this.state.inType = oldInType;
-      this.state.exprAllowed = this.state.exprAllowed || this.state.noAnonFunctionType;
-      return type;
-    }
-
-    flowParseTypeOrImplicitInstantiation() {
-      if (this.state.type === _types.types.name && this.state.value === "_") {
-        const startPos = this.state.start;
-        const startLoc = this.state.startLoc;
-        const node = this.parseIdentifier();
-        return this.flowParseGenericType(startPos, startLoc, node);
-      } else {
-        return this.flowParseType();
-      }
-    }
-
-    flowParseTypeAnnotation() {
-      const node = this.startNode();
-      node.typeAnnotation = this.flowParseTypeInitialiser();
-      return this.finishNode(node, "TypeAnnotation");
-    }
-
-    flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {
-      const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();
-
-      if (this.match(_types.types.colon)) {
-        ident.typeAnnotation = this.flowParseTypeAnnotation();
-        this.resetEndLocation(ident);
-      }
-
-      return ident;
-    }
-
-    typeCastToParameter(node) {
-      node.expression.typeAnnotation = node.typeAnnotation;
-      this.resetEndLocation(node.expression, node.typeAnnotation.end, node.typeAnnotation.loc.end);
-      return node.expression;
-    }
-
-    flowParseVariance() {
-      let variance = null;
-
-      if (this.match(_types.types.plusMin)) {
-        variance = this.startNode();
-
-        if (this.state.value === "+") {
-          variance.kind = "plus";
-        } else {
-          variance.kind = "minus";
-        }
-
-        this.next();
-        this.finishNode(variance, "Variance");
-      }
-
-      return variance;
-    }
-
-    parseFunctionBody(node, allowExpressionBody, isMethod = false) {
-      if (allowExpressionBody) {
-        return this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod));
-      }
-
-      return super.parseFunctionBody(node, false, isMethod);
-    }
-
-    parseFunctionBodyAndFinish(node, type, isMethod = false) {
-      if (this.match(_types.types.colon)) {
-        const typeNode = this.startNode();
-        [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
-        node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null;
-      }
-
-      super.parseFunctionBodyAndFinish(node, type, isMethod);
-    }
-
-    parseStatement(context, topLevel) {
-      if (this.state.strict && this.match(_types.types.name) && this.state.value === "interface") {
-        const lookahead = this.lookahead();
-
-        if (lookahead.type === _types.types.name || (0, _identifier.isKeyword)(lookahead.value)) {
-          const node = this.startNode();
-          this.next();
-          return this.flowParseInterface(node);
-        }
-      } else if (this.shouldParseEnums() && this.isContextual("enum")) {
-        const node = this.startNode();
-        this.next();
-        return this.flowParseEnumDeclaration(node);
-      }
-
-      const stmt = super.parseStatement(context, topLevel);
-
-      if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {
-        this.flowPragma = null;
-      }
-
-      return stmt;
-    }
-
-    parseExpressionStatement(node, expr) {
-      if (expr.type === "Identifier") {
-        if (expr.name === "declare") {
-          if (this.match(_types.types._class) || this.match(_types.types.name) || this.match(_types.types._function) || this.match(_types.types._var) || this.match(_types.types._export)) {
-            return this.flowParseDeclare(node);
-          }
-        } else if (this.match(_types.types.name)) {
-          if (expr.name === "interface") {
-            return this.flowParseInterface(node);
-          } else if (expr.name === "type") {
-            return this.flowParseTypeAlias(node);
-          } else if (expr.name === "opaque") {
-            return this.flowParseOpaqueType(node, false);
-          }
-        }
-      }
-
-      return super.parseExpressionStatement(node, expr);
-    }
-
-    shouldParseExportDeclaration() {
-      return this.isContextual("type") || this.isContextual("interface") || this.isContextual("opaque") || this.shouldParseEnums() && this.isContextual("enum") || super.shouldParseExportDeclaration();
-    }
-
-    isExportDefaultSpecifier() {
-      if (this.match(_types.types.name) && (this.state.value === "type" || this.state.value === "interface" || this.state.value === "opaque" || this.shouldParseEnums() && this.state.value === "enum")) {
-        return false;
-      }
-
-      return super.isExportDefaultSpecifier();
-    }
-
-    parseExportDefaultExpression() {
-      if (this.shouldParseEnums() && this.isContextual("enum")) {
-        const node = this.startNode();
-        this.next();
-        return this.flowParseEnumDeclaration(node);
-      }
-
-      return super.parseExportDefaultExpression();
-    }
-
-    parseConditional(expr, startPos, startLoc, refNeedsArrowPos) {
-      if (!this.match(_types.types.question)) return expr;
-
-      if (refNeedsArrowPos) {
-        const result = this.tryParse(() => super.parseConditional(expr, startPos, startLoc));
-
-        if (!result.node) {
-          refNeedsArrowPos.start = result.error.pos || this.state.start;
-          return expr;
-        }
-
-        if (result.error) this.state = result.failState;
-        return result.node;
-      }
-
-      this.expect(_types.types.question);
-      const state = this.state.clone();
-      const originalNoArrowAt = this.state.noArrowAt;
-      const node = this.startNodeAt(startPos, startLoc);
-      let {
-        consequent,
-        failed
-      } = this.tryParseConditionalConsequent();
-      let [valid, invalid] = this.getArrowLikeExpressions(consequent);
-
-      if (failed || invalid.length > 0) {
-        const noArrowAt = [...originalNoArrowAt];
-
-        if (invalid.length > 0) {
-          this.state = state;
-          this.state.noArrowAt = noArrowAt;
-
-          for (let i = 0; i < invalid.length; i++) {
-            noArrowAt.push(invalid[i].start);
-          }
-
-          ({
-            consequent,
-            failed
-          } = this.tryParseConditionalConsequent());
-          [valid, invalid] = this.getArrowLikeExpressions(consequent);
-        }
-
-        if (failed && valid.length > 1) {
-          this.raise(state.start, FlowErrors.AmbiguousConditionalArrow);
-        }
-
-        if (failed && valid.length === 1) {
-          this.state = state;
-          this.state.noArrowAt = noArrowAt.concat(valid[0].start);
-          ({
-            consequent,
-            failed
-          } = this.tryParseConditionalConsequent());
-        }
-      }
-
-      this.getArrowLikeExpressions(consequent, true);
-      this.state.noArrowAt = originalNoArrowAt;
-      this.expect(_types.types.colon);
-      node.test = expr;
-      node.consequent = consequent;
-      node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(undefined, undefined, undefined));
-      return this.finishNode(node, "ConditionalExpression");
-    }
-
-    tryParseConditionalConsequent() {
-      this.state.noArrowParamsConversionAt.push(this.state.start);
-      const consequent = this.parseMaybeAssignAllowIn();
-      const failed = !this.match(_types.types.colon);
-      this.state.noArrowParamsConversionAt.pop();
-      return {
-        consequent,
-        failed
-      };
-    }
-
-    getArrowLikeExpressions(node, disallowInvalid) {
-      const stack = [node];
-      const arrows = [];
-
-      while (stack.length !== 0) {
-        const node = stack.pop();
-
-        if (node.type === "ArrowFunctionExpression") {
-          if (node.typeParameters || !node.returnType) {
-            this.finishArrowValidation(node);
-          } else {
-            arrows.push(node);
-          }
-
-          stack.push(node.body);
-        } else if (node.type === "ConditionalExpression") {
-          stack.push(node.consequent);
-          stack.push(node.alternate);
-        }
-      }
-
-      if (disallowInvalid) {
-        arrows.forEach(node => this.finishArrowValidation(node));
-        return [arrows, []];
-      }
-
-      return partition(arrows, node => node.params.every(param => this.isAssignable(param, true)));
-    }
-
-    finishArrowValidation(node) {
-      this.toAssignableList(node.params, node.extra?.trailingComma);
-      this.scope.enter(_scopeflags.SCOPE_FUNCTION | _scopeflags.SCOPE_ARROW);
-      super.checkParams(node, false, true);
-      this.scope.exit();
-    }
-
-    forwardNoArrowParamsConversionAt(node, parse) {
-      let result;
-
-      if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
-        this.state.noArrowParamsConversionAt.push(this.state.start);
-        result = parse();
-        this.state.noArrowParamsConversionAt.pop();
-      } else {
-        result = parse();
-      }
-
-      return result;
-    }
-
-    parseParenItem(node, startPos, startLoc) {
-      node = super.parseParenItem(node, startPos, startLoc);
-
-      if (this.eat(_types.types.question)) {
-        node.optional = true;
-        this.resetEndLocation(node);
-      }
-
-      if (this.match(_types.types.colon)) {
-        const typeCastNode = this.startNodeAt(startPos, startLoc);
-        typeCastNode.expression = node;
-        typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
-        return this.finishNode(typeCastNode, "TypeCastExpression");
-      }
-
-      return node;
-    }
-
-    assertModuleNodeAllowed(node) {
-      if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") {
-        return;
-      }
-
-      super.assertModuleNodeAllowed(node);
-    }
-
-    parseExport(node) {
-      const decl = super.parseExport(node);
-
-      if (decl.type === "ExportNamedDeclaration" || decl.type === "ExportAllDeclaration") {
-        decl.exportKind = decl.exportKind || "value";
-      }
-
-      return decl;
-    }
-
-    parseExportDeclaration(node) {
-      if (this.isContextual("type")) {
-        node.exportKind = "type";
-        const declarationNode = this.startNode();
-        this.next();
-
-        if (this.match(_types.types.braceL)) {
-          node.specifiers = this.parseExportSpecifiers();
-          this.parseExportFrom(node);
-          return null;
-        } else {
-          return this.flowParseTypeAlias(declarationNode);
-        }
-      } else if (this.isContextual("opaque")) {
-        node.exportKind = "type";
-        const declarationNode = this.startNode();
-        this.next();
-        return this.flowParseOpaqueType(declarationNode, false);
-      } else if (this.isContextual("interface")) {
-        node.exportKind = "type";
-        const declarationNode = this.startNode();
-        this.next();
-        return this.flowParseInterface(declarationNode);
-      } else if (this.shouldParseEnums() && this.isContextual("enum")) {
-        node.exportKind = "value";
-        const declarationNode = this.startNode();
-        this.next();
-        return this.flowParseEnumDeclaration(declarationNode);
-      } else {
-        return super.parseExportDeclaration(node);
-      }
-    }
-
-    eatExportStar(node) {
-      if (super.eatExportStar(...arguments)) return true;
-
-      if (this.isContextual("type") && this.lookahead().type === _types.types.star) {
-        node.exportKind = "type";
-        this.next();
-        this.next();
-        return true;
-      }
-
-      return false;
-    }
-
-    maybeParseExportNamespaceSpecifier(node) {
-      const pos = this.state.start;
-      const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);
-
-      if (hasNamespace && node.exportKind === "type") {
-        this.unexpected(pos);
-      }
-
-      return hasNamespace;
-    }
-
-    parseClassId(node, isStatement, optionalId) {
-      super.parseClassId(node, isStatement, optionalId);
-
-      if (this.isRelational("<")) {
-        node.typeParameters = this.flowParseTypeParameterDeclaration();
-      }
-    }
-
-    parseClassMember(classBody, member, state) {
-      const pos = this.state.start;
-
-      if (this.isContextual("declare")) {
-        if (this.parseClassMemberFromModifier(classBody, member)) {
-          return;
-        }
-
-        member.declare = true;
-      }
-
-      super.parseClassMember(classBody, member, state);
-
-      if (member.declare) {
-        if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty") {
-          this.raise(pos, FlowErrors.DeclareClassElement);
-        } else if (member.value) {
-          this.raise(member.value.start, FlowErrors.DeclareClassFieldInitializer);
-        }
-      }
-    }
-
-    getTokenFromCode(code) {
-      const next = this.input.charCodeAt(this.state.pos + 1);
-
-      if (code === 123 && next === 124) {
-        return this.finishOp(_types.types.braceBarL, 2);
-      } else if (this.state.inType && (code === 62 || code === 60)) {
-        return this.finishOp(_types.types.relational, 1);
-      } else if (this.state.inType && code === 63) {
-        return this.finishOp(_types.types.question, 1);
-      } else if ((0, _identifier.isIteratorStart)(code, next)) {
-        this.state.isIterator = true;
-        return super.readWord();
-      } else {
-        return super.getTokenFromCode(code);
-      }
-    }
-
-    isAssignable(node, isBinding) {
-      switch (node.type) {
-        case "Identifier":
-        case "ObjectPattern":
-        case "ArrayPattern":
-        case "AssignmentPattern":
-          return true;
-
-        case "ObjectExpression":
-          {
-            const last = node.properties.length - 1;
-            return node.properties.every((prop, i) => {
-              return prop.type !== "ObjectMethod" && (i === last || prop.type === "SpreadElement") && this.isAssignable(prop);
-            });
-          }
-
-        case "ObjectProperty":
-          return this.isAssignable(node.value);
-
-        case "SpreadElement":
-          return this.isAssignable(node.argument);
-
-        case "ArrayExpression":
-          return node.elements.every(element => this.isAssignable(element));
-
-        case "AssignmentExpression":
-          return node.operator === "=";
-
-        case "ParenthesizedExpression":
-        case "TypeCastExpression":
-          return this.isAssignable(node.expression);
-
-        case "MemberExpression":
-        case "OptionalMemberExpression":
-          return !isBinding;
-
-        default:
-          return false;
-      }
-    }
-
-    toAssignable(node) {
-      if (node.type === "TypeCastExpression") {
-        return super.toAssignable(this.typeCastToParameter(node));
-      } else {
-        return super.toAssignable(node);
-      }
-    }
-
-    toAssignableList(exprList, trailingCommaPos) {
-      for (let i = 0; i < exprList.length; i++) {
-        const expr = exprList[i];
-
-        if (expr?.type === "TypeCastExpression") {
-          exprList[i] = this.typeCastToParameter(expr);
-        }
-      }
-
-      return super.toAssignableList(exprList, trailingCommaPos);
-    }
-
-    toReferencedList(exprList, isParenthesizedExpr) {
-      for (let i = 0; i < exprList.length; i++) {
-        const expr = exprList[i];
-
-        if (expr && expr.type === "TypeCastExpression" && !expr.extra?.parenthesized && (exprList.length > 1 || !isParenthesizedExpr)) {
-          this.raise(expr.typeAnnotation.start, FlowErrors.TypeCastInPattern);
-        }
-      }
-
-      return exprList;
-    }
-
-    parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
-      const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
-
-      if (canBePattern && !this.state.maybeInArrowParameters) {
-        this.toReferencedList(node.elements);
-      }
-
-      return node;
-    }
-
-    checkLVal(expr, bindingType = _scopeflags.BIND_NONE, checkClashes, contextDescription) {
-      if (expr.type !== "TypeCastExpression") {
-        return super.checkLVal(expr, bindingType, checkClashes, contextDescription);
-      }
-    }
-
-    parseClassProperty(node) {
-      if (this.match(_types.types.colon)) {
-        node.typeAnnotation = this.flowParseTypeAnnotation();
-      }
-
-      return super.parseClassProperty(node);
-    }
-
-    parseClassPrivateProperty(node) {
-      if (this.match(_types.types.colon)) {
-        node.typeAnnotation = this.flowParseTypeAnnotation();
-      }
-
-      return super.parseClassPrivateProperty(node);
-    }
-
-    isClassMethod() {
-      return this.isRelational("<") || super.isClassMethod();
-    }
-
-    isClassProperty() {
-      return this.match(_types.types.colon) || super.isClassProperty();
-    }
-
-    isNonstaticConstructor(method) {
-      return !this.match(_types.types.colon) && super.isNonstaticConstructor(method);
-    }
-
-    pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-      if (method.variance) {
-        this.unexpected(method.variance.start);
-      }
-
-      delete method.variance;
-
-      if (this.isRelational("<")) {
-        method.typeParameters = this.flowParseTypeParameterDeclaration();
-      }
-
-      super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
-    }
-
-    pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
-      if (method.variance) {
-        this.unexpected(method.variance.start);
-      }
-
-      delete method.variance;
-
-      if (this.isRelational("<")) {
-        method.typeParameters = this.flowParseTypeParameterDeclaration();
-      }
-
-      super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
-    }
-
-    parseClassSuper(node) {
-      super.parseClassSuper(node);
-
-      if (node.superClass && this.isRelational("<")) {
-        node.superTypeParameters = this.flowParseTypeParameterInstantiation();
-      }
-
-      if (this.isContextual("implements")) {
-        this.next();
-        const implemented = node.implements = [];
-
-        do {
-          const node = this.startNode();
-          node.id = this.flowParseRestrictedIdentifier(true);
-
-          if (this.isRelational("<")) {
-            node.typeParameters = this.flowParseTypeParameterInstantiation();
-          } else {
-            node.typeParameters = null;
-          }
-
-          implemented.push(this.finishNode(node, "ClassImplements"));
-        } while (this.eat(_types.types.comma));
-      }
-    }
-
-    parsePropertyName(node, isPrivateNameAllowed) {
-      const variance = this.flowParseVariance();
-      const key = super.parsePropertyName(node, isPrivateNameAllowed);
-      node.variance = variance;
-      return key;
-    }
-
-    parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
-      if (prop.variance) {
-        this.unexpected(prop.variance.start);
-      }
-
-      delete prop.variance;
-      let typeParameters;
-
-      if (this.isRelational("<") && !isAccessor) {
-        typeParameters = this.flowParseTypeParameterDeclaration();
-        if (!this.match(_types.types.parenL)) this.unexpected();
-      }
-
-      super.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
-
-      if (typeParameters) {
-        (prop.value || prop).typeParameters = typeParameters;
-      }
-    }
-
-    parseAssignableListItemTypes(param) {
-      if (this.eat(_types.types.question)) {
-        if (param.type !== "Identifier") {
-          this.raise(param.start, FlowErrors.OptionalBindingPattern);
-        }
-
-        param.optional = true;
-      }
-
-      if (this.match(_types.types.colon)) {
-        param.typeAnnotation = this.flowParseTypeAnnotation();
-      }
-
-      this.resetEndLocation(param);
-      return param;
-    }
-
-    parseMaybeDefault(startPos, startLoc, left) {
-      const node = super.parseMaybeDefault(startPos, startLoc, left);
-
-      if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
-        this.raise(node.typeAnnotation.start, FlowErrors.TypeBeforeInitializer);
-      }
-
-      return node;
-    }
-
-    shouldParseDefaultImport(node) {
-      if (!hasTypeImportKind(node)) {
-        return super.shouldParseDefaultImport(node);
-      }
-
-      return isMaybeDefaultImport(this.state);
-    }
-
-    parseImportSpecifierLocal(node, specifier, type, contextDescription) {
-      specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
-      this.checkLVal(specifier.local, _scopeflags.BIND_LEXICAL, undefined, contextDescription);
-      node.specifiers.push(this.finishNode(specifier, type));
-    }
-
-    maybeParseDefaultImportSpecifier(node) {
-      node.importKind = "value";
-      let kind = null;
-
-      if (this.match(_types.types._typeof)) {
-        kind = "typeof";
-      } else if (this.isContextual("type")) {
-        kind = "type";
-      }
-
-      if (kind) {
-        const lh = this.lookahead();
-
-        if (kind === "type" && lh.type === _types.types.star) {
-          this.unexpected(lh.start);
-        }
-
-        if (isMaybeDefaultImport(lh) || lh.type === _types.types.braceL || lh.type === _types.types.star) {
-          this.next();
-          node.importKind = kind;
-        }
-      }
-
-      return super.maybeParseDefaultImportSpecifier(node);
-    }
-
-    parseImportSpecifier(node) {
-      const specifier = this.startNode();
-      const firstIdentLoc = this.state.start;
-      const firstIdent = this.parseModuleExportName();
-      let specifierTypeKind = null;
-
-      if (firstIdent.type === "Identifier") {
-        if (firstIdent.name === "type") {
-          specifierTypeKind = "type";
-        } else if (firstIdent.name === "typeof") {
-          specifierTypeKind = "typeof";
-        }
-      }
-
-      let isBinding = false;
-
-      if (this.isContextual("as") && !this.isLookaheadContextual("as")) {
-        const as_ident = this.parseIdentifier(true);
-
-        if (specifierTypeKind !== null && !this.match(_types.types.name) && !this.state.type.keyword) {
-          specifier.imported = as_ident;
-          specifier.importKind = specifierTypeKind;
-          specifier.local = as_ident.__clone();
-        } else {
-          specifier.imported = firstIdent;
-          specifier.importKind = null;
-          specifier.local = this.parseIdentifier();
-        }
-      } else if (specifierTypeKind !== null && (this.match(_types.types.name) || this.state.type.keyword)) {
-        specifier.imported = this.parseIdentifier(true);
-        specifier.importKind = specifierTypeKind;
-
-        if (this.eatContextual("as")) {
-          specifier.local = this.parseIdentifier();
-        } else {
-          isBinding = true;
-          specifier.local = specifier.imported.__clone();
-        }
-      } else {
-        if (firstIdent.type === "StringLiteral") {
-          throw this.raise(specifier.start, _error.Errors.ImportBindingIsString, firstIdent.value);
-        }
-
-        isBinding = true;
-        specifier.imported = firstIdent;
-        specifier.importKind = null;
-        specifier.local = specifier.imported.__clone();
-      }
-
-      const nodeIsTypeImport = hasTypeImportKind(node);
-      const specifierIsTypeImport = hasTypeImportKind(specifier);
-
-      if (nodeIsTypeImport && specifierIsTypeImport) {
-        this.raise(firstIdentLoc, FlowErrors.ImportTypeShorthandOnlyInPureImport);
-      }
-
-      if (nodeIsTypeImport || specifierIsTypeImport) {
-        this.checkReservedType(specifier.local.name, specifier.local.start, true);
-      }
-
-      if (isBinding && !nodeIsTypeImport && !specifierIsTypeImport) {
-        this.checkReservedWord(specifier.local.name, specifier.start, true, true);
-      }
-
-      this.checkLVal(specifier.local, _scopeflags.BIND_LEXICAL, undefined, "import specifier");
-      node.specifiers.push(this.finishNode(specifier, "ImportSpecifier"));
-    }
-
-    parseFunctionParams(node, allowModifiers) {
-      const kind = node.kind;
-
-      if (kind !== "get" && kind !== "set" && this.isRelational("<")) {
-        node.typeParameters = this.flowParseTypeParameterDeclaration();
-      }
-
-      super.parseFunctionParams(node, allowModifiers);
-    }
-
-    parseVarId(decl, kind) {
-      super.parseVarId(decl, kind);
-
-      if (this.match(_types.types.colon)) {
-        decl.id.typeAnnotation = this.flowParseTypeAnnotation();
-        this.resetEndLocation(decl.id);
-      }
-    }
-
-    parseAsyncArrowFromCallExpression(node, call) {
-      if (this.match(_types.types.colon)) {
-        const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-        this.state.noAnonFunctionType = true;
-        node.returnType = this.flowParseTypeAnnotation();
-        this.state.noAnonFunctionType = oldNoAnonFunctionType;
-      }
-
-      return super.parseAsyncArrowFromCallExpression(node, call);
-    }
-
-    shouldParseAsyncArrow() {
-      return this.match(_types.types.colon) || super.shouldParseAsyncArrow();
-    }
-
-    parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos) {
-      let state = null;
-      let jsx;
-
-      if (this.hasPlugin("jsx") && (this.match(_types.types.jsxTagStart) || this.isRelational("<"))) {
-        state = this.state.clone();
-        jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos), state);
-        if (!jsx.error) return jsx.node;
-        const {
-          context
-        } = this.state;
-
-        if (context[context.length - 1] === _context.types.j_oTag) {
-          context.length -= 2;
-        } else if (context[context.length - 1] === _context.types.j_expr) {
-          context.length -= 1;
-        }
-      }
-
-      if (jsx?.error || this.isRelational("<")) {
-        state = state || this.state.clone();
-        let typeParameters;
-        const arrow = this.tryParse(abort => {
-          typeParameters = this.flowParseTypeParameterDeclaration();
-          const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => {
-            const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos);
-            this.resetStartLocationFromNode(result, typeParameters);
-            return result;
-          });
-
-          if (arrowExpression.type !== "ArrowFunctionExpression" && arrowExpression.extra?.parenthesized) {
-            abort();
-          }
-
-          const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);
-          expr.typeParameters = typeParameters;
-          this.resetStartLocationFromNode(expr, typeParameters);
-          return arrowExpression;
-        }, state);
-        let arrowExpression = null;
-
-        if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
-          if (!arrow.error && !arrow.aborted) {
-            if (arrow.node.async) {
-              this.raise(typeParameters.start, FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction);
-            }
-
-            return arrow.node;
-          }
-
-          arrowExpression = arrow.node;
-        }
-
-        if (jsx?.node) {
-          this.state = jsx.failState;
-          return jsx.node;
-        }
-
-        if (arrowExpression) {
-          this.state = arrow.failState;
-          return arrowExpression;
-        }
-
-        if (jsx?.thrown) throw jsx.error;
-        if (arrow.thrown) throw arrow.error;
-        throw this.raise(typeParameters.start, FlowErrors.UnexpectedTokenAfterTypeParameter);
-      }
-
-      return super.parseMaybeAssign(refExpressionErrors, afterLeftParse, refNeedsArrowPos);
-    }
-
-    parseArrow(node) {
-      if (this.match(_types.types.colon)) {
-        const result = this.tryParse(() => {
-          const oldNoAnonFunctionType = this.state.noAnonFunctionType;
-          this.state.noAnonFunctionType = true;
-          const typeNode = this.startNode();
-          [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
-          this.state.noAnonFunctionType = oldNoAnonFunctionType;
-          if (this.canInsertSemicolon()) this.unexpected();
-          if (!this.match(_types.types.arrow)) this.unexpected();
-          return typeNode;
-        });
-        if (result.thrown) return null;
-        if (result.error) this.state = result.failState;
-        node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null;
-      }
-
-      return super.parseArrow(node);
-    }
-
-    shouldParseArrow() {
-      return this.match(_types.types.colon) || super.shouldParseArrow();
-    }
-
-    setArrowFunctionParameters(node, params) {
-      if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
-        node.params = params;
-      } else {
-        super.setArrowFunctionParameters(node, params);
-      }
-    }
-
-    checkParams(node, allowDuplicates, isArrowFunction) {
-      if (isArrowFunction && this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
-        return;
-      }
-
-      return super.checkParams(...arguments);
-    }
-
-    parseParenAndDistinguishExpression(canBeArrow) {
-      return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1);
-    }
-
-    parseSubscripts(base, startPos, startLoc, noCalls) {
-      if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.indexOf(startPos) !== -1) {
-        this.next();
-        const node = this.startNodeAt(startPos, startLoc);
-        node.callee = base;
-        node.arguments = this.parseCallExpressionArguments(_types.types.parenR, false);
-        base = this.finishNode(node, "CallExpression");
-      } else if (base.type === "Identifier" && base.name === "async" && this.isRelational("<")) {
-        const state = this.state.clone();
-        const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startPos, startLoc) || abort(), state);
-        if (!arrow.error && !arrow.aborted) return arrow.node;
-        const result = this.tryParse(() => super.parseSubscripts(base, startPos, startLoc, noCalls), state);
-        if (result.node && !result.error) return result.node;
-
-        if (arrow.node) {
-          this.state = arrow.failState;
-          return arrow.node;
-        }
-
-        if (result.node) {
-          this.state = result.failState;
-          return result.node;
-        }
-
-        throw arrow.error || result.error;
-      }
-
-      return super.parseSubscripts(base, startPos, startLoc, noCalls);
-    }
-
-    parseSubscript(base, startPos, startLoc, noCalls, subscriptState) {
-      if (this.match(_types.types.questionDot) && this.isLookaheadToken_lt()) {
-        subscriptState.optionalChainMember = true;
-
-        if (noCalls) {
-          subscriptState.stop = true;
-          return base;
-        }
-
-        this.next();
-        const node = this.startNodeAt(startPos, startLoc);
-        node.callee = base;
-        node.typeArguments = this.flowParseTypeParameterInstantiation();
-        this.expect(_types.types.parenL);
-        node.arguments = this.parseCallExpressionArguments(_types.types.parenR, false);
-        node.optional = true;
-        return this.finishCallExpression(node, true);
-      } else if (!noCalls && this.shouldParseTypes() && this.isRelational("<")) {
-        const node = this.startNodeAt(startPos, startLoc);
-        node.callee = base;
-        const result = this.tryParse(() => {
-          node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
-          this.expect(_types.types.parenL);
-          node.arguments = this.parseCallExpressionArguments(_types.types.parenR, false);
-          if (subscriptState.optionalChainMember) node.optional = false;
-          return this.finishCallExpression(node, subscriptState.optionalChainMember);
-        });
-
-        if (result.node) {
-          if (result.error) this.state = result.failState;
-          return result.node;
-        }
-      }
-
-      return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState);
-    }
-
-    parseNewArguments(node) {
-      let targs = null;
-
-      if (this.shouldParseTypes() && this.isRelational("<")) {
-        targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
-      }
-
-      node.typeArguments = targs;
-      super.parseNewArguments(node);
-    }
-
-    parseAsyncArrowWithTypeParameters(startPos, startLoc) {
-      const node = this.startNodeAt(startPos, startLoc);
-      this.parseFunctionParams(node);
-      if (!this.parseArrow(node)) return;
-      return this.parseArrowExpression(node, undefined, true);
-    }
-
-    readToken_mult_modulo(code) {
-      const next = this.input.charCodeAt(this.state.pos + 1);
-
-      if (code === 42 && next === 47 && this.state.hasFlowComment) {
-        this.state.hasFlowComment = false;
-        this.state.pos += 2;
-        this.nextToken();
-        return;
-      }
-
-      super.readToken_mult_modulo(code);
-    }
-
-    readToken_pipe_amp(code) {
-      const next = this.input.charCodeAt(this.state.pos + 1);
-
-      if (code === 124 && next === 125) {
-        this.finishOp(_types.types.braceBarR, 2);
-        return;
-      }
-
-      super.readToken_pipe_amp(code);
-    }
-
-    parseTopLevel(file, program) {
-      const fileNode = super.parseTopLevel(file, program);
-
-      if (this.state.hasFlowComment) {
-        this.raise(this.state.pos, FlowErrors.UnterminatedFlowComment);
-      }
-
-      return fileNode;
-    }
-
-    skipBlockComment() {
-      if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
-        if (this.state.hasFlowComment) {
-          this.unexpected(null, FlowErrors.NestedFlowComment);
-        }
-
-        this.hasFlowCommentCompletion();
-        this.state.pos += this.skipFlowComment();
-        this.state.hasFlowComment = true;
-        return;
-      }
-
-      if (this.state.hasFlowComment) {
-        const end = this.input.indexOf("*-/", this.state.pos += 2);
-
-        if (end === -1) {
-          throw this.raise(this.state.pos - 2, _error.Errors.UnterminatedComment);
-        }
-
-        this.state.pos = end + 3;
-        return;
-      }
-
-      super.skipBlockComment();
-    }
-
-    skipFlowComment() {
-      const {
-        pos
-      } = this.state;
-      let shiftToFirstNonWhiteSpace = 2;
-
-      while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {
-        shiftToFirstNonWhiteSpace++;
-      }
-
-      const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
-      const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
-
-      if (ch2 === 58 && ch3 === 58) {
-        return shiftToFirstNonWhiteSpace + 2;
-      }
-
-      if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") {
-        return shiftToFirstNonWhiteSpace + 12;
-      }
-
-      if (ch2 === 58 && ch3 !== 58) {
-        return shiftToFirstNonWhiteSpace;
-      }
-
-      return false;
-    }
-
-    hasFlowCommentCompletion() {
-      const end = this.input.indexOf("*/", this.state.pos);
-
-      if (end === -1) {
-        throw this.raise(this.state.pos, _error.Errors.UnterminatedComment);
-      }
-    }
-
-    flowEnumErrorBooleanMemberNotInitialized(pos, {
-      enumName,
-      memberName
-    }) {
-      this.raise(pos, FlowErrors.EnumBooleanMemberNotInitialized, memberName, enumName);
-    }
-
-    flowEnumErrorInvalidMemberName(pos, {
-      enumName,
-      memberName
-    }) {
-      const suggestion = memberName[0].toUpperCase() + memberName.slice(1);
-      this.raise(pos, FlowErrors.EnumInvalidMemberName, memberName, suggestion, enumName);
-    }
-
-    flowEnumErrorDuplicateMemberName(pos, {
-      enumName,
-      memberName
-    }) {
-      this.raise(pos, FlowErrors.EnumDuplicateMemberName, memberName, enumName);
-    }
-
-    flowEnumErrorInconsistentMemberValues(pos, {
-      enumName
-    }) {
-      this.raise(pos, FlowErrors.EnumInconsistentMemberValues, enumName);
-    }
-
-    flowEnumErrorInvalidExplicitType(pos, {
-      enumName,
-      suppliedType
-    }) {
-      return this.raise(pos, suppliedType === null ? FlowErrors.EnumInvalidExplicitTypeUnknownSupplied : FlowErrors.EnumInvalidExplicitType, enumName, suppliedType);
-    }
-
-    flowEnumErrorInvalidMemberInitializer(pos, {
-      enumName,
-      explicitType,
-      memberName
-    }) {
-      let message = null;
-
-      switch (explicitType) {
-        case "boolean":
-        case "number":
-        case "string":
-          message = FlowErrors.EnumInvalidMemberInitializerPrimaryType;
-          break;
-
-        case "symbol":
-          message = FlowErrors.EnumInvalidMemberInitializerSymbolType;
-          break;
-
-        default:
-          message = FlowErrors.EnumInvalidMemberInitializerUnknownType;
-      }
-
-      return this.raise(pos, message, enumName, memberName, explicitType);
-    }
-
-    flowEnumErrorNumberMemberNotInitialized(pos, {
-      enumName,
-      memberName
-    }) {
-      this.raise(pos, FlowErrors.EnumNumberMemberNotInitialized, enumName, memberName);
-    }
-
-    flowEnumErrorStringMemberInconsistentlyInitailized(pos, {
-      enumName
-    }) {
-      this.raise(pos, FlowErrors.EnumStringMemberInconsistentlyInitailized, enumName);
-    }
-
-    flowEnumMemberInit() {
-      const startPos = this.state.start;
-
-      const endOfInit = () => this.match(_types.types.comma) || this.match(_types.types.braceR);
-
-      switch (this.state.type) {
-        case _types.types.num:
-          {
-            const literal = this.parseLiteral(this.state.value, "NumericLiteral");
-
-            if (endOfInit()) {
-              return {
-                type: "number",
-                pos: literal.start,
-                value: literal
-              };
-            }
-
-            return {
-              type: "invalid",
-              pos: startPos
-            };
-          }
-
-        case _types.types.string:
-          {
-            const literal = this.parseLiteral(this.state.value, "StringLiteral");
-
-            if (endOfInit()) {
-              return {
-                type: "string",
-                pos: literal.start,
-                value: literal
-              };
-            }
-
-            return {
-              type: "invalid",
-              pos: startPos
-            };
-          }
-
-        case _types.types._true:
-        case _types.types._false:
-          {
-            const literal = this.parseBooleanLiteral();
-
-            if (endOfInit()) {
-              return {
-                type: "boolean",
-                pos: literal.start,
-                value: literal
-              };
-            }
-
-            return {
-              type: "invalid",
-              pos: startPos
-            };
-          }
-
-        default:
-          return {
-            type: "invalid",
-            pos: startPos
-          };
-      }
-    }
-
-    flowEnumMemberRaw() {
-      const pos = this.state.start;
-      const id = this.parseIdentifier(true);
-      const init = this.eat(_types.types.eq) ? this.flowEnumMemberInit() : {
-        type: "none",
-        pos
-      };
-      return {
-        id,
-        init
-      };
-    }
-
-    flowEnumCheckExplicitTypeMismatch(pos, context, expectedType) {
-      const {
-        explicitType
-      } = context;
-
-      if (explicitType === null) {
-        return;
-      }
-
-      if (explicitType !== expectedType) {
-        this.flowEnumErrorInvalidMemberInitializer(pos, context);
-      }
-    }
-
-    flowEnumMembers({
-      enumName,
-      explicitType
-    }) {
-      const seenNames = new Set();
-      const members = {
-        booleanMembers: [],
-        numberMembers: [],
-        stringMembers: [],
-        defaultedMembers: []
-      };
-
-      while (!this.match(_types.types.braceR)) {
-        const memberNode = this.startNode();
-        const {
-          id,
-          init
-        } = this.flowEnumMemberRaw();
-        const memberName = id.name;
-
-        if (memberName === "") {
-          continue;
-        }
-
-        if (/^[a-z]/.test(memberName)) {
-          this.flowEnumErrorInvalidMemberName(id.start, {
-            enumName,
-            memberName
-          });
-        }
-
-        if (seenNames.has(memberName)) {
-          this.flowEnumErrorDuplicateMemberName(id.start, {
-            enumName,
-            memberName
-          });
-        }
-
-        seenNames.add(memberName);
-        const context = {
-          enumName,
-          explicitType,
-          memberName
-        };
-        memberNode.id = id;
-
-        switch (init.type) {
-          case "boolean":
-            {
-              this.flowEnumCheckExplicitTypeMismatch(init.pos, context, "boolean");
-              memberNode.init = init.value;
-              members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
-              break;
-            }
-
-          case "number":
-            {
-              this.flowEnumCheckExplicitTypeMismatch(init.pos, context, "number");
-              memberNode.init = init.value;
-              members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
-              break;
-            }
-
-          case "string":
-            {
-              this.flowEnumCheckExplicitTypeMismatch(init.pos, context, "string");
-              memberNode.init = init.value;
-              members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
-              break;
-            }
-
-          case "invalid":
-            {
-              throw this.flowEnumErrorInvalidMemberInitializer(init.pos, context);
-            }
-
-          case "none":
-            {
-              switch (explicitType) {
-                case "boolean":
-                  this.flowEnumErrorBooleanMemberNotInitialized(init.pos, context);
-                  break;
-
-                case "number":
-                  this.flowEnumErrorNumberMemberNotInitialized(init.pos, context);
-                  break;
-
-                default:
-                  members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
-              }
-            }
-        }
-
-        if (!this.match(_types.types.braceR)) {
-          this.expect(_types.types.comma);
-        }
-      }
-
-      return members;
-    }
-
-    flowEnumStringMembers(initializedMembers, defaultedMembers, {
-      enumName
-    }) {
-      if (initializedMembers.length === 0) {
-        return defaultedMembers;
-      } else if (defaultedMembers.length === 0) {
-        return initializedMembers;
-      } else if (defaultedMembers.length > initializedMembers.length) {
-        for (let _i = 0; _i < initializedMembers.length; _i++) {
-          const member = initializedMembers[_i];
-          this.flowEnumErrorStringMemberInconsistentlyInitailized(member.start, {
-            enumName
-          });
-        }
-
-        return defaultedMembers;
-      } else {
-        for (let _i2 = 0; _i2 < defaultedMembers.length; _i2++) {
-          const member = defaultedMembers[_i2];
-          this.flowEnumErrorStringMemberInconsistentlyInitailized(member.start, {
-            enumName
-          });
-        }
-
-        return initializedMembers;
-      }
-    }
-
-    flowEnumParseExplicitType({
-      enumName
-    }) {
-      if (this.eatContextual("of")) {
-        if (!this.match(_types.types.name)) {
-          throw this.flowEnumErrorInvalidExplicitType(this.state.start, {
-            enumName,
-            suppliedType: null
-          });
-        }
-
-        const {
-          value
-        } = this.state;
-        this.next();
-
-        if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
-          this.flowEnumErrorInvalidExplicitType(this.state.start, {
-            enumName,
-            suppliedType: value
-          });
-        }
-
-        return value;
-      }
-
-      return null;
-    }
-
-    flowEnumBody(node, {
-      enumName,
-      nameLoc
-    }) {
-      const explicitType = this.flowEnumParseExplicitType({
-        enumName
-      });
-      this.expect(_types.types.braceL);
-      const members = this.flowEnumMembers({
-        enumName,
-        explicitType
-      });
-
-      switch (explicitType) {
-        case "boolean":
-          node.explicitType = true;
-          node.members = members.booleanMembers;
-          this.expect(_types.types.braceR);
-          return this.finishNode(node, "EnumBooleanBody");
-
-        case "number":
-          node.explicitType = true;
-          node.members = members.numberMembers;
-          this.expect(_types.types.braceR);
-          return this.finishNode(node, "EnumNumberBody");
-
-        case "string":
-          node.explicitType = true;
-          node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
-            enumName
-          });
-          this.expect(_types.types.braceR);
-          return this.finishNode(node, "EnumStringBody");
-
-        case "symbol":
-          node.members = members.defaultedMembers;
-          this.expect(_types.types.braceR);
-          return this.finishNode(node, "EnumSymbolBody");
-
-        default:
-          {
-            const empty = () => {
-              node.members = [];
-              this.expect(_types.types.braceR);
-              return this.finishNode(node, "EnumStringBody");
-            };
-
-            node.explicitType = false;
-            const boolsLen = members.booleanMembers.length;
-            const numsLen = members.numberMembers.length;
-            const strsLen = members.stringMembers.length;
-            const defaultedLen = members.defaultedMembers.length;
-
-            if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {
-              return empty();
-            } else if (!boolsLen && !numsLen) {
-              node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
-                enumName
-              });
-              this.expect(_types.types.braceR);
-              return this.finishNode(node, "EnumStringBody");
-            } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
-              for (let _i3 = 0, _members$defaultedMem = members.defaultedMembers; _i3 < _members$defaultedMem.length; _i3++) {
-                const member = _members$defaultedMem[_i3];
-                this.flowEnumErrorBooleanMemberNotInitialized(member.start, {
-                  enumName,
-                  memberName: member.id.name
-                });
-              }
-
-              node.members = members.booleanMembers;
-              this.expect(_types.types.braceR);
-              return this.finishNode(node, "EnumBooleanBody");
-            } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
-              for (let _i4 = 0, _members$defaultedMem2 = members.defaultedMembers; _i4 < _members$defaultedMem2.length; _i4++) {
-                const member = _members$defaultedMem2[_i4];
-                this.flowEnumErrorNumberMemberNotInitialized(member.start, {
-                  enumName,
-                  memberName: member.id.name
-                });
-              }
-
-              node.members = members.numberMembers;
-              this.expect(_types.types.braceR);
-              return this.finishNode(node, "EnumNumberBody");
-            } else {
-              this.flowEnumErrorInconsistentMemberValues(nameLoc, {
-                enumName
-              });
-              return empty();
-            }
-          }
-      }
-    }
-
-    flowParseEnumDeclaration(node) {
-      const id = this.parseIdentifier();
-      node.id = id;
-      node.body = this.flowEnumBody(this.startNode(), {
-        enumName: id.name,
-        nameLoc: id.start
-      });
-      return this.finishNode(node, "EnumDeclaration");
-    }
-
-    updateContext(prevType) {
-      if (this.match(_types.types.name) && this.state.value === "of" && prevType === _types.types.name && this.input.slice(this.state.lastTokStart, this.state.lastTokEnd) === "interface") {
-        this.state.exprAllowed = false;
-      } else {
-        super.updateContext(prevType);
-      }
-    }
-
-    isLookaheadToken_lt() {
-      const next = this.nextTokenStart();
-
-      if (this.input.charCodeAt(next) === 60) {
-        const afterNext = this.input.charCodeAt(next + 1);
-        return afterNext !== 60 && afterNext !== 61;
-      }
-
-      return false;
-    }
-
-    maybeUnwrapTypeCastExpression(node) {
-      return node.type === "TypeCastExpression" ? node.expression : node;
-    }
-
-  }, _temp;
-};
-
-exports.default = _default;

node_modules/@babel/parser/lib/plugins/jsx/index.js

@@ -1,526 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _xhtml = _interopRequireDefault(require("./xhtml"));
-
-var _types = require("../../tokenizer/types");
-
-var _context = require("../../tokenizer/context");
-
-var N = _interopRequireWildcard(require("../../types"));
-
-var _identifier = require("../../util/identifier");
-
-var _whitespace = require("../../util/whitespace");
-
-var _error = require("../../parser/error");
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const HEX_NUMBER = /^[\da-fA-F]+$/;
-const DECIMAL_NUMBER = /^\d+$/;
-const JsxErrors = Object.freeze({
-  AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression",
-  MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>",
-  MissingClosingTagElement: "Expected corresponding JSX closing tag for <%0>",
-  UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text",
-  UnterminatedJsxContent: "Unterminated JSX contents",
-  UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
-});
-_context.types.j_oTag = new _context.TokContext("<tag", false);
-_context.types.j_cTag = new _context.TokContext("</tag", false);
-_context.types.j_expr = new _context.TokContext("<tag>...</tag>", true, true);
-_types.types.jsxName = new _types.TokenType("jsxName");
-_types.types.jsxText = new _types.TokenType("jsxText", {
-  beforeExpr: true
-});
-_types.types.jsxTagStart = new _types.TokenType("jsxTagStart", {
-  startsExpr: true
-});
-_types.types.jsxTagEnd = new _types.TokenType("jsxTagEnd");
-
-_types.types.jsxTagStart.updateContext = function () {
-  this.state.context.push(_context.types.j_expr);
-  this.state.context.push(_context.types.j_oTag);
-  this.state.exprAllowed = false;
-};
-
-_types.types.jsxTagEnd.updateContext = function (prevType) {
-  const out = this.state.context.pop();
-
-  if (out === _context.types.j_oTag && prevType === _types.types.slash || out === _context.types.j_cTag) {
-    this.state.context.pop();
-    this.state.exprAllowed = this.curContext() === _context.types.j_expr;
-  } else {
-    this.state.exprAllowed = true;
-  }
-};
-
-function isFragment(object) {
-  return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false;
-}
-
-function getQualifiedJSXName(object) {
-  if (object.type === "JSXIdentifier") {
-    return object.name;
-  }
-
-  if (object.type === "JSXNamespacedName") {
-    return object.namespace.name + ":" + object.name.name;
-  }
-
-  if (object.type === "JSXMemberExpression") {
-    return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property);
-  }
-
-  throw new Error("Node had unexpected type: " + object.type);
-}
-
-var _default = superClass => class extends superClass {
-  jsxReadToken() {
-    let out = "";
-    let chunkStart = this.state.pos;
-
-    for (;;) {
-      if (this.state.pos >= this.length) {
-        throw this.raise(this.state.start, JsxErrors.UnterminatedJsxContent);
-      }
-
-      const ch = this.input.charCodeAt(this.state.pos);
-
-      switch (ch) {
-        case 60:
-        case 123:
-          if (this.state.pos === this.state.start) {
-            if (ch === 60 && this.state.exprAllowed) {
-              ++this.state.pos;
-              return this.finishToken(_types.types.jsxTagStart);
-            }
-
-            return super.getTokenFromCode(ch);
-          }
-
-          out += this.input.slice(chunkStart, this.state.pos);
-          return this.finishToken(_types.types.jsxText, out);
-
-        case 38:
-          out += this.input.slice(chunkStart, this.state.pos);
-          out += this.jsxReadEntity();
-          chunkStart = this.state.pos;
-          break;
-
-        default:
-          if ((0, _whitespace.isNewLine)(ch)) {
-            out += this.input.slice(chunkStart, this.state.pos);
-            out += this.jsxReadNewLine(true);
-            chunkStart = this.state.pos;
-          } else {
-            ++this.state.pos;
-          }
-
-      }
-    }
-  }
-
-  jsxReadNewLine(normalizeCRLF) {
-    const ch = this.input.charCodeAt(this.state.pos);
-    let out;
-    ++this.state.pos;
-
-    if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) {
-      ++this.state.pos;
-      out = normalizeCRLF ? "\n" : "\r\n";
-    } else {
-      out = String.fromCharCode(ch);
-    }
-
-    ++this.state.curLine;
-    this.state.lineStart = this.state.pos;
-    return out;
-  }
-
-  jsxReadString(quote) {
-    let out = "";
-    let chunkStart = ++this.state.pos;
-
-    for (;;) {
-      if (this.state.pos >= this.length) {
-        throw this.raise(this.state.start, _error.Errors.UnterminatedString);
-      }
-
-      const ch = this.input.charCodeAt(this.state.pos);
-      if (ch === quote) break;
-
-      if (ch === 38) {
-        out += this.input.slice(chunkStart, this.state.pos);
-        out += this.jsxReadEntity();
-        chunkStart = this.state.pos;
-      } else if ((0, _whitespace.isNewLine)(ch)) {
-        out += this.input.slice(chunkStart, this.state.pos);
-        out += this.jsxReadNewLine(false);
-        chunkStart = this.state.pos;
-      } else {
-        ++this.state.pos;
-      }
-    }
-
-    out += this.input.slice(chunkStart, this.state.pos++);
-    return this.finishToken(_types.types.string, out);
-  }
-
-  jsxReadEntity() {
-    let str = "";
-    let count = 0;
-    let entity;
-    let ch = this.input[this.state.pos];
-    const startPos = ++this.state.pos;
-
-    while (this.state.pos < this.length && count++ < 10) {
-      ch = this.input[this.state.pos++];
-
-      if (ch === ";") {
-        if (str[0] === "#") {
-          if (str[1] === "x") {
-            str = str.substr(2);
-
-            if (HEX_NUMBER.test(str)) {
-              entity = String.fromCodePoint(parseInt(str, 16));
-            }
-          } else {
-            str = str.substr(1);
-
-            if (DECIMAL_NUMBER.test(str)) {
-              entity = String.fromCodePoint(parseInt(str, 10));
-            }
-          }
-        } else {
-          entity = _xhtml.default[str];
-        }
-
-        break;
-      }
-
-      str += ch;
-    }
-
-    if (!entity) {
-      this.state.pos = startPos;
-      return "&";
-    }
-
-    return entity;
-  }
-
-  jsxReadWord() {
-    let ch;
-    const start = this.state.pos;
-
-    do {
-      ch = this.input.charCodeAt(++this.state.pos);
-    } while ((0, _identifier.isIdentifierChar)(ch) || ch === 45);
-
-    return this.finishToken(_types.types.jsxName, this.input.slice(start, this.state.pos));
-  }
-
-  jsxParseIdentifier() {
-    const node = this.startNode();
-
-    if (this.match(_types.types.jsxName)) {
-      node.name = this.state.value;
-    } else if (this.state.type.keyword) {
-      node.name = this.state.type.keyword;
-    } else {
-      this.unexpected();
-    }
-
-    this.next();
-    return this.finishNode(node, "JSXIdentifier");
-  }
-
-  jsxParseNamespacedName() {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const name = this.jsxParseIdentifier();
-    if (!this.eat(_types.types.colon)) return name;
-    const node = this.startNodeAt(startPos, startLoc);
-    node.namespace = name;
-    node.name = this.jsxParseIdentifier();
-    return this.finishNode(node, "JSXNamespacedName");
-  }
-
-  jsxParseElementName() {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    let node = this.jsxParseNamespacedName();
-
-    if (node.type === "JSXNamespacedName") {
-      return node;
-    }
-
-    while (this.eat(_types.types.dot)) {
-      const newNode = this.startNodeAt(startPos, startLoc);
-      newNode.object = node;
-      newNode.property = this.jsxParseIdentifier();
-      node = this.finishNode(newNode, "JSXMemberExpression");
-    }
-
-    return node;
-  }
-
-  jsxParseAttributeValue() {
-    let node;
-
-    switch (this.state.type) {
-      case _types.types.braceL:
-        node = this.startNode();
-        this.next();
-        node = this.jsxParseExpressionContainer(node);
-
-        if (node.expression.type === "JSXEmptyExpression") {
-          this.raise(node.start, JsxErrors.AttributeIsEmpty);
-        }
-
-        return node;
-
-      case _types.types.jsxTagStart:
-      case _types.types.string:
-        return this.parseExprAtom();
-
-      default:
-        throw this.raise(this.state.start, JsxErrors.UnsupportedJsxValue);
-    }
-  }
-
-  jsxParseEmptyExpression() {
-    const node = this.startNodeAt(this.state.lastTokEnd, this.state.lastTokEndLoc);
-    return this.finishNodeAt(node, "JSXEmptyExpression", this.state.start, this.state.startLoc);
-  }
-
-  jsxParseSpreadChild(node) {
-    this.next();
-    node.expression = this.parseExpression();
-    this.expect(_types.types.braceR);
-    return this.finishNode(node, "JSXSpreadChild");
-  }
-
-  jsxParseExpressionContainer(node) {
-    if (this.match(_types.types.braceR)) {
-      node.expression = this.jsxParseEmptyExpression();
-    } else {
-      node.expression = this.parseExpression();
-    }
-
-    this.expect(_types.types.braceR);
-    return this.finishNode(node, "JSXExpressionContainer");
-  }
-
-  jsxParseAttribute() {
-    const node = this.startNode();
-
-    if (this.eat(_types.types.braceL)) {
-      this.expect(_types.types.ellipsis);
-      node.argument = this.parseMaybeAssignAllowIn();
-      this.expect(_types.types.braceR);
-      return this.finishNode(node, "JSXSpreadAttribute");
-    }
-
-    node.name = this.jsxParseNamespacedName();
-    node.value = this.eat(_types.types.eq) ? this.jsxParseAttributeValue() : null;
-    return this.finishNode(node, "JSXAttribute");
-  }
-
-  jsxParseOpeningElementAt(startPos, startLoc) {
-    const node = this.startNodeAt(startPos, startLoc);
-
-    if (this.match(_types.types.jsxTagEnd)) {
-      this.expect(_types.types.jsxTagEnd);
-      return this.finishNode(node, "JSXOpeningFragment");
-    }
-
-    node.name = this.jsxParseElementName();
-    return this.jsxParseOpeningElementAfterName(node);
-  }
-
-  jsxParseOpeningElementAfterName(node) {
-    const attributes = [];
-
-    while (!this.match(_types.types.slash) && !this.match(_types.types.jsxTagEnd)) {
-      attributes.push(this.jsxParseAttribute());
-    }
-
-    node.attributes = attributes;
-    node.selfClosing = this.eat(_types.types.slash);
-    this.expect(_types.types.jsxTagEnd);
-    return this.finishNode(node, "JSXOpeningElement");
-  }
-
-  jsxParseClosingElementAt(startPos, startLoc) {
-    const node = this.startNodeAt(startPos, startLoc);
-
-    if (this.match(_types.types.jsxTagEnd)) {
-      this.expect(_types.types.jsxTagEnd);
-      return this.finishNode(node, "JSXClosingFragment");
-    }
-
-    node.name = this.jsxParseElementName();
-    this.expect(_types.types.jsxTagEnd);
-    return this.finishNode(node, "JSXClosingElement");
-  }
-
-  jsxParseElementAt(startPos, startLoc) {
-    const node = this.startNodeAt(startPos, startLoc);
-    const children = [];
-    const openingElement = this.jsxParseOpeningElementAt(startPos, startLoc);
-    let closingElement = null;
-
-    if (!openingElement.selfClosing) {
-      contents: for (;;) {
-        switch (this.state.type) {
-          case _types.types.jsxTagStart:
-            startPos = this.state.start;
-            startLoc = this.state.startLoc;
-            this.next();
-
-            if (this.eat(_types.types.slash)) {
-              closingElement = this.jsxParseClosingElementAt(startPos, startLoc);
-              break contents;
-            }
-
-            children.push(this.jsxParseElementAt(startPos, startLoc));
-            break;
-
-          case _types.types.jsxText:
-            children.push(this.parseExprAtom());
-            break;
-
-          case _types.types.braceL:
-            {
-              const node = this.startNode();
-              this.next();
-
-              if (this.match(_types.types.ellipsis)) {
-                children.push(this.jsxParseSpreadChild(node));
-              } else {
-                children.push(this.jsxParseExpressionContainer(node));
-              }
-
-              break;
-            }
-
-          default:
-            throw this.unexpected();
-        }
-      }
-
-      if (isFragment(openingElement) && !isFragment(closingElement)) {
-        this.raise(closingElement.start, JsxErrors.MissingClosingTagFragment);
-      } else if (!isFragment(openingElement) && isFragment(closingElement)) {
-        this.raise(closingElement.start, JsxErrors.MissingClosingTagElement, getQualifiedJSXName(openingElement.name));
-      } else if (!isFragment(openingElement) && !isFragment(closingElement)) {
-        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
-          this.raise(closingElement.start, JsxErrors.MissingClosingTagElement, getQualifiedJSXName(openingElement.name));
-        }
-      }
-    }
-
-    if (isFragment(openingElement)) {
-      node.openingFragment = openingElement;
-      node.closingFragment = closingElement;
-    } else {
-      node.openingElement = openingElement;
-      node.closingElement = closingElement;
-    }
-
-    node.children = children;
-
-    if (this.isRelational("<")) {
-      throw this.raise(this.state.start, JsxErrors.UnwrappedAdjacentJSXElements);
-    }
-
-    return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
-  }
-
-  jsxParseElement() {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    this.next();
-    return this.jsxParseElementAt(startPos, startLoc);
-  }
-
-  parseExprAtom(refExpressionErrors) {
-    if (this.match(_types.types.jsxText)) {
-      return this.parseLiteral(this.state.value, "JSXText");
-    } else if (this.match(_types.types.jsxTagStart)) {
-      return this.jsxParseElement();
-    } else if (this.isRelational("<") && this.input.charCodeAt(this.state.pos) !== 33) {
-      this.finishToken(_types.types.jsxTagStart);
-      return this.jsxParseElement();
-    } else {
-      return super.parseExprAtom(refExpressionErrors);
-    }
-  }
-
-  getTokenFromCode(code) {
-    if (this.state.inPropertyName) return super.getTokenFromCode(code);
-    const context = this.curContext();
-
-    if (context === _context.types.j_expr) {
-      return this.jsxReadToken();
-    }
-
-    if (context === _context.types.j_oTag || context === _context.types.j_cTag) {
-      if ((0, _identifier.isIdentifierStart)(code)) {
-        return this.jsxReadWord();
-      }
-
-      if (code === 62) {
-        ++this.state.pos;
-        return this.finishToken(_types.types.jsxTagEnd);
-      }
-
-      if ((code === 34 || code === 39) && context === _context.types.j_oTag) {
-        return this.jsxReadString(code);
-      }
-    }
-
-    if (code === 60 && this.state.exprAllowed && this.input.charCodeAt(this.state.pos + 1) !== 33) {
-      ++this.state.pos;
-      return this.finishToken(_types.types.jsxTagStart);
-    }
-
-    return super.getTokenFromCode(code);
-  }
-
-  updateContext(prevType) {
-    if (this.match(_types.types.braceL)) {
-      const curContext = this.curContext();
-
-      if (curContext === _context.types.j_oTag) {
-        this.state.context.push(_context.types.braceExpression);
-      } else if (curContext === _context.types.j_expr) {
-        this.state.context.push(_context.types.templateQuasi);
-      } else {
-        super.updateContext(prevType);
-      }
-
-      this.state.exprAllowed = true;
-    } else if (this.match(_types.types.slash) && prevType === _types.types.jsxTagStart) {
-      this.state.context.length -= 2;
-      this.state.context.push(_context.types.j_cTag);
-      this.state.exprAllowed = false;
-    } else {
-      return super.updateContext(prevType);
-    }
-  }
-
-};
-
-exports.default = _default;

node_modules/@babel/parser/lib/plugins/jsx/xhtml.js

@@ -1,263 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-const entities = {
-  quot: "\u0022",
-  amp: "&",
-  apos: "\u0027",
-  lt: "<",
-  gt: ">",
-  nbsp: "\u00A0",
-  iexcl: "\u00A1",
-  cent: "\u00A2",
-  pound: "\u00A3",
-  curren: "\u00A4",
-  yen: "\u00A5",
-  brvbar: "\u00A6",
-  sect: "\u00A7",
-  uml: "\u00A8",
-  copy: "\u00A9",
-  ordf: "\u00AA",
-  laquo: "\u00AB",
-  not: "\u00AC",
-  shy: "\u00AD",
-  reg: "\u00AE",
-  macr: "\u00AF",
-  deg: "\u00B0",
-  plusmn: "\u00B1",
-  sup2: "\u00B2",
-  sup3: "\u00B3",
-  acute: "\u00B4",
-  micro: "\u00B5",
-  para: "\u00B6",
-  middot: "\u00B7",
-  cedil: "\u00B8",
-  sup1: "\u00B9",
-  ordm: "\u00BA",
-  raquo: "\u00BB",
-  frac14: "\u00BC",
-  frac12: "\u00BD",
-  frac34: "\u00BE",
-  iquest: "\u00BF",
-  Agrave: "\u00C0",
-  Aacute: "\u00C1",
-  Acirc: "\u00C2",
-  Atilde: "\u00C3",
-  Auml: "\u00C4",
-  Aring: "\u00C5",
-  AElig: "\u00C6",
-  Ccedil: "\u00C7",
-  Egrave: "\u00C8",
-  Eacute: "\u00C9",
-  Ecirc: "\u00CA",
-  Euml: "\u00CB",
-  Igrave: "\u00CC",
-  Iacute: "\u00CD",
-  Icirc: "\u00CE",
-  Iuml: "\u00CF",
-  ETH: "\u00D0",
-  Ntilde: "\u00D1",
-  Ograve: "\u00D2",
-  Oacute: "\u00D3",
-  Ocirc: "\u00D4",
-  Otilde: "\u00D5",
-  Ouml: "\u00D6",
-  times: "\u00D7",
-  Oslash: "\u00D8",
-  Ugrave: "\u00D9",
-  Uacute: "\u00DA",
-  Ucirc: "\u00DB",
-  Uuml: "\u00DC",
-  Yacute: "\u00DD",
-  THORN: "\u00DE",
-  szlig: "\u00DF",
-  agrave: "\u00E0",
-  aacute: "\u00E1",
-  acirc: "\u00E2",
-  atilde: "\u00E3",
-  auml: "\u00E4",
-  aring: "\u00E5",
-  aelig: "\u00E6",
-  ccedil: "\u00E7",
-  egrave: "\u00E8",
-  eacute: "\u00E9",
-  ecirc: "\u00EA",
-  euml: "\u00EB",
-  igrave: "\u00EC",
-  iacute: "\u00ED",
-  icirc: "\u00EE",
-  iuml: "\u00EF",
-  eth: "\u00F0",
-  ntilde: "\u00F1",
-  ograve: "\u00F2",
-  oacute: "\u00F3",
-  ocirc: "\u00F4",
-  otilde: "\u00F5",
-  ouml: "\u00F6",
-  divide: "\u00F7",
-  oslash: "\u00F8",
-  ugrave: "\u00F9",
-  uacute: "\u00FA",
-  ucirc: "\u00FB",
-  uuml: "\u00FC",
-  yacute: "\u00FD",
-  thorn: "\u00FE",
-  yuml: "\u00FF",
-  OElig: "\u0152",
-  oelig: "\u0153",
-  Scaron: "\u0160",
-  scaron: "\u0161",
-  Yuml: "\u0178",
-  fnof: "\u0192",
-  circ: "\u02C6",
-  tilde: "\u02DC",
-  Alpha: "\u0391",
-  Beta: "\u0392",
-  Gamma: "\u0393",
-  Delta: "\u0394",
-  Epsilon: "\u0395",
-  Zeta: "\u0396",
-  Eta: "\u0397",
-  Theta: "\u0398",
-  Iota: "\u0399",
-  Kappa: "\u039A",
-  Lambda: "\u039B",
-  Mu: "\u039C",
-  Nu: "\u039D",
-  Xi: "\u039E",
-  Omicron: "\u039F",
-  Pi: "\u03A0",
-  Rho: "\u03A1",
-  Sigma: "\u03A3",
-  Tau: "\u03A4",
-  Upsilon: "\u03A5",
-  Phi: "\u03A6",
-  Chi: "\u03A7",
-  Psi: "\u03A8",
-  Omega: "\u03A9",
-  alpha: "\u03B1",
-  beta: "\u03B2",
-  gamma: "\u03B3",
-  delta: "\u03B4",
-  epsilon: "\u03B5",
-  zeta: "\u03B6",
-  eta: "\u03B7",
-  theta: "\u03B8",
-  iota: "\u03B9",
-  kappa: "\u03BA",
-  lambda: "\u03BB",
-  mu: "\u03BC",
-  nu: "\u03BD",
-  xi: "\u03BE",
-  omicron: "\u03BF",
-  pi: "\u03C0",
-  rho: "\u03C1",
-  sigmaf: "\u03C2",
-  sigma: "\u03C3",
-  tau: "\u03C4",
-  upsilon: "\u03C5",
-  phi: "\u03C6",
-  chi: "\u03C7",
-  psi: "\u03C8",
-  omega: "\u03C9",
-  thetasym: "\u03D1",
-  upsih: "\u03D2",
-  piv: "\u03D6",
-  ensp: "\u2002",
-  emsp: "\u2003",
-  thinsp: "\u2009",
-  zwnj: "\u200C",
-  zwj: "\u200D",
-  lrm: "\u200E",
-  rlm: "\u200F",
-  ndash: "\u2013",
-  mdash: "\u2014",
-  lsquo: "\u2018",
-  rsquo: "\u2019",
-  sbquo: "\u201A",
-  ldquo: "\u201C",
-  rdquo: "\u201D",
-  bdquo: "\u201E",
-  dagger: "\u2020",
-  Dagger: "\u2021",
-  bull: "\u2022",
-  hellip: "\u2026",
-  permil: "\u2030",
-  prime: "\u2032",
-  Prime: "\u2033",
-  lsaquo: "\u2039",
-  rsaquo: "\u203A",
-  oline: "\u203E",
-  frasl: "\u2044",
-  euro: "\u20AC",
-  image: "\u2111",
-  weierp: "\u2118",
-  real: "\u211C",
-  trade: "\u2122",
-  alefsym: "\u2135",
-  larr: "\u2190",
-  uarr: "\u2191",
-  rarr: "\u2192",
-  darr: "\u2193",
-  harr: "\u2194",
-  crarr: "\u21B5",
-  lArr: "\u21D0",
-  uArr: "\u21D1",
-  rArr: "\u21D2",
-  dArr: "\u21D3",
-  hArr: "\u21D4",
-  forall: "\u2200",
-  part: "\u2202",
-  exist: "\u2203",
-  empty: "\u2205",
-  nabla: "\u2207",
-  isin: "\u2208",
-  notin: "\u2209",
-  ni: "\u220B",
-  prod: "\u220F",
-  sum: "\u2211",
-  minus: "\u2212",
-  lowast: "\u2217",
-  radic: "\u221A",
-  prop: "\u221D",
-  infin: "\u221E",
-  ang: "\u2220",
-  and: "\u2227",
-  or: "\u2228",
-  cap: "\u2229",
-  cup: "\u222A",
-  int: "\u222B",
-  there4: "\u2234",
-  sim: "\u223C",
-  cong: "\u2245",
-  asymp: "\u2248",
-  ne: "\u2260",
-  equiv: "\u2261",
-  le: "\u2264",
-  ge: "\u2265",
-  sub: "\u2282",
-  sup: "\u2283",
-  nsub: "\u2284",
-  sube: "\u2286",
-  supe: "\u2287",
-  oplus: "\u2295",
-  otimes: "\u2297",
-  perp: "\u22A5",
-  sdot: "\u22C5",
-  lceil: "\u2308",
-  rceil: "\u2309",
-  lfloor: "\u230A",
-  rfloor: "\u230B",
-  lang: "\u2329",
-  rang: "\u232A",
-  loz: "\u25CA",
-  spades: "\u2660",
-  clubs: "\u2663",
-  hearts: "\u2665",
-  diams: "\u2666"
-};
-var _default = entities;
-exports.default = _default;

node_modules/@babel/parser/lib/plugins/placeholders.js

@@ -1,219 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _types = require("../tokenizer/types");
-
-var N = _interopRequireWildcard(require("../types"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-_types.types.placeholder = new _types.TokenType("%%", {
-  startsExpr: true
-});
-
-var _default = superClass => class extends superClass {
-  parsePlaceholder(expectedNode) {
-    if (this.match(_types.types.placeholder)) {
-      const node = this.startNode();
-      this.next();
-      this.assertNoSpace("Unexpected space in placeholder.");
-      node.name = super.parseIdentifier(true);
-      this.assertNoSpace("Unexpected space in placeholder.");
-      this.expect(_types.types.placeholder);
-      return this.finishPlaceholder(node, expectedNode);
-    }
-  }
-
-  finishPlaceholder(node, expectedNode) {
-    const isFinished = !!(node.expectedNode && node.type === "Placeholder");
-    node.expectedNode = expectedNode;
-    return isFinished ? node : this.finishNode(node, "Placeholder");
-  }
-
-  getTokenFromCode(code) {
-    if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
-      return this.finishOp(_types.types.placeholder, 2);
-    }
-
-    return super.getTokenFromCode(...arguments);
-  }
-
-  parseExprAtom() {
-    return this.parsePlaceholder("Expression") || super.parseExprAtom(...arguments);
-  }
-
-  parseIdentifier() {
-    return this.parsePlaceholder("Identifier") || super.parseIdentifier(...arguments);
-  }
-
-  checkReservedWord(word) {
-    if (word !== undefined) super.checkReservedWord(...arguments);
-  }
-
-  parseBindingAtom() {
-    return this.parsePlaceholder("Pattern") || super.parseBindingAtom(...arguments);
-  }
-
-  checkLVal(expr) {
-    if (expr.type !== "Placeholder") super.checkLVal(...arguments);
-  }
-
-  toAssignable(node) {
-    if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
-      node.expectedNode = "Pattern";
-      return node;
-    }
-
-    return super.toAssignable(...arguments);
-  }
-
-  verifyBreakContinue(node) {
-    if (node.label && node.label.type === "Placeholder") return;
-    super.verifyBreakContinue(...arguments);
-  }
-
-  parseExpressionStatement(node, expr) {
-    if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) {
-      return super.parseExpressionStatement(...arguments);
-    }
-
-    if (this.match(_types.types.colon)) {
-      const stmt = node;
-      stmt.label = this.finishPlaceholder(expr, "Identifier");
-      this.next();
-      stmt.body = this.parseStatement("label");
-      return this.finishNode(stmt, "LabeledStatement");
-    }
-
-    this.semicolon();
-    node.name = expr.name;
-    return this.finishPlaceholder(node, "Statement");
-  }
-
-  parseBlock() {
-    return this.parsePlaceholder("BlockStatement") || super.parseBlock(...arguments);
-  }
-
-  parseFunctionId() {
-    return this.parsePlaceholder("Identifier") || super.parseFunctionId(...arguments);
-  }
-
-  parseClass(node, isStatement, optionalId) {
-    const type = isStatement ? "ClassDeclaration" : "ClassExpression";
-    this.next();
-    this.takeDecorators(node);
-    const oldStrict = this.state.strict;
-    const placeholder = this.parsePlaceholder("Identifier");
-
-    if (placeholder) {
-      if (this.match(_types.types._extends) || this.match(_types.types.placeholder) || this.match(_types.types.braceL)) {
-        node.id = placeholder;
-      } else if (optionalId || !isStatement) {
-        node.id = null;
-        node.body = this.finishPlaceholder(placeholder, "ClassBody");
-        return this.finishNode(node, type);
-      } else {
-        this.unexpected(null, "A class name is required");
-      }
-    } else {
-      this.parseClassId(node, isStatement, optionalId);
-    }
-
-    this.parseClassSuper(node);
-    node.body = this.parsePlaceholder("ClassBody") || this.parseClassBody(!!node.superClass, oldStrict);
-    return this.finishNode(node, type);
-  }
-
-  parseExport(node) {
-    const placeholder = this.parsePlaceholder("Identifier");
-    if (!placeholder) return super.parseExport(...arguments);
-
-    if (!this.isContextual("from") && !this.match(_types.types.comma)) {
-      node.specifiers = [];
-      node.source = null;
-      node.declaration = this.finishPlaceholder(placeholder, "Declaration");
-      return this.finishNode(node, "ExportNamedDeclaration");
-    }
-
-    this.expectPlugin("exportDefaultFrom");
-    const specifier = this.startNode();
-    specifier.exported = placeholder;
-    node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
-    return super.parseExport(node);
-  }
-
-  isExportDefaultSpecifier() {
-    if (this.match(_types.types._default)) {
-      const next = this.nextTokenStart();
-
-      if (this.isUnparsedContextual(next, "from")) {
-        if (this.input.startsWith(_types.types.placeholder.label, this.nextTokenStartSince(next + 4))) {
-          return true;
-        }
-      }
-    }
-
-    return super.isExportDefaultSpecifier();
-  }
-
-  maybeParseExportDefaultSpecifier(node) {
-    if (node.specifiers && node.specifiers.length > 0) {
-      return true;
-    }
-
-    return super.maybeParseExportDefaultSpecifier(...arguments);
-  }
-
-  checkExport(node) {
-    const {
-      specifiers
-    } = node;
-
-    if (specifiers?.length) {
-      node.specifiers = specifiers.filter(node => node.exported.type === "Placeholder");
-    }
-
-    super.checkExport(node);
-    node.specifiers = specifiers;
-  }
-
-  parseImport(node) {
-    const placeholder = this.parsePlaceholder("Identifier");
-    if (!placeholder) return super.parseImport(...arguments);
-    node.specifiers = [];
-
-    if (!this.isContextual("from") && !this.match(_types.types.comma)) {
-      node.source = this.finishPlaceholder(placeholder, "StringLiteral");
-      this.semicolon();
-      return this.finishNode(node, "ImportDeclaration");
-    }
-
-    const specifier = this.startNodeAtNode(placeholder);
-    specifier.local = placeholder;
-    this.finishNode(specifier, "ImportDefaultSpecifier");
-    node.specifiers.push(specifier);
-
-    if (this.eat(_types.types.comma)) {
-      const hasStarImport = this.maybeParseStarImportSpecifier(node);
-      if (!hasStarImport) this.parseNamedImportSpecifiers(node);
-    }
-
-    this.expectContextual("from");
-    node.source = this.parseImportSource();
-    this.semicolon();
-    return this.finishNode(node, "ImportDeclaration");
-  }
-
-  parseImportSource() {
-    return this.parsePlaceholder("StringLiteral") || super.parseImportSource(...arguments);
-  }
-
-};
-
-exports.default = _default;

node_modules/@babel/parser/lib/plugins/typescript/index.js

@@ -1,2283 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _types = require("../../tokenizer/types");
-
-var _context = require("../../tokenizer/context");
-
-var N = _interopRequireWildcard(require("../../types"));
-
-var _scopeflags = require("../../util/scopeflags");
-
-var _scope = _interopRequireDefault(require("./scope"));
-
-var _productionParameter = require("../../util/production-parameter");
-
-var _error = require("../../parser/error");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function nonNull(x) {
-  if (x == null) {
-    throw new Error(`Unexpected ${x} value.`);
-  }
-
-  return x;
-}
-
-function assert(x) {
-  if (!x) {
-    throw new Error("Assert fail");
-  }
-}
-
-const TSErrors = Object.freeze({
-  ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier",
-  ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier",
-  ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
-  DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
-  DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
-  DuplicateModifier: "Duplicate modifier: '%0'",
-  EmptyHeritageClauseType: "'%0' list cannot be empty.",
-  EmptyTypeArguments: "Type argument list cannot be empty.",
-  EmptyTypeParameters: "Type parameter list cannot be empty.",
-  IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier",
-  IndexSignatureHasAccessibility: "Index signatures cannot have an accessibility modifier ('%0')",
-  IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier",
-  IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier",
-  InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
-  MixedLabeledAndUnlabeledElements: "Tuple members must all have names or all not have names.",
-  OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
-  PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
-  PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
-  PrivateElementHasAccessibility: "Private elements cannot have an accessibility modifier ('%0')",
-  TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`",
-  UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
-  UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
-  UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
-  UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
-  UnsupportedImportTypeArgument: "Argument in a type import must be a string literal",
-  UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
-  UnsupportedSignatureParameterKind: "Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got %0"
-});
-
-function keywordTypeFromName(value) {
-  switch (value) {
-    case "any":
-      return "TSAnyKeyword";
-
-    case "boolean":
-      return "TSBooleanKeyword";
-
-    case "bigint":
-      return "TSBigIntKeyword";
-
-    case "never":
-      return "TSNeverKeyword";
-
-    case "number":
-      return "TSNumberKeyword";
-
-    case "object":
-      return "TSObjectKeyword";
-
-    case "string":
-      return "TSStringKeyword";
-
-    case "symbol":
-      return "TSSymbolKeyword";
-
-    case "undefined":
-      return "TSUndefinedKeyword";
-
-    case "unknown":
-      return "TSUnknownKeyword";
-
-    default:
-      return undefined;
-  }
-}
-
-var _default = superClass => class extends superClass {
-  getScopeHandler() {
-    return _scope.default;
-  }
-
-  tsIsIdentifier() {
-    return this.match(_types.types.name);
-  }
-
-  tsNextTokenCanFollowModifier() {
-    this.next();
-    return !this.hasPrecedingLineBreak() && !this.match(_types.types.parenL) && !this.match(_types.types.parenR) && !this.match(_types.types.colon) && !this.match(_types.types.eq) && !this.match(_types.types.question) && !this.match(_types.types.bang);
-  }
-
-  tsParseModifier(allowedModifiers) {
-    if (!this.match(_types.types.name)) {
-      return undefined;
-    }
-
-    const modifier = this.state.value;
-
-    if (allowedModifiers.indexOf(modifier) !== -1 && this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {
-      return modifier;
-    }
-
-    return undefined;
-  }
-
-  tsParseModifiers(modified, allowedModifiers) {
-    for (;;) {
-      const startPos = this.state.start;
-      const modifier = this.tsParseModifier(allowedModifiers);
-      if (!modifier) break;
-
-      if (Object.hasOwnProperty.call(modified, modifier)) {
-        this.raise(startPos, TSErrors.DuplicateModifier, modifier);
-      }
-
-      modified[modifier] = true;
-    }
-  }
-
-  tsIsListTerminator(kind) {
-    switch (kind) {
-      case "EnumMembers":
-      case "TypeMembers":
-        return this.match(_types.types.braceR);
-
-      case "HeritageClauseElement":
-        return this.match(_types.types.braceL);
-
-      case "TupleElementTypes":
-        return this.match(_types.types.bracketR);
-
-      case "TypeParametersOrArguments":
-        return this.isRelational(">");
-    }
-
-    throw new Error("Unreachable");
-  }
-
-  tsParseList(kind, parseElement) {
-    const result = [];
-
-    while (!this.tsIsListTerminator(kind)) {
-      result.push(parseElement());
-    }
-
-    return result;
-  }
-
-  tsParseDelimitedList(kind, parseElement) {
-    return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true));
-  }
-
-  tsParseDelimitedListWorker(kind, parseElement, expectSuccess) {
-    const result = [];
-
-    for (;;) {
-      if (this.tsIsListTerminator(kind)) {
-        break;
-      }
-
-      const element = parseElement();
-
-      if (element == null) {
-        return undefined;
-      }
-
-      result.push(element);
-
-      if (this.eat(_types.types.comma)) {
-        continue;
-      }
-
-      if (this.tsIsListTerminator(kind)) {
-        break;
-      }
-
-      if (expectSuccess) {
-        this.expect(_types.types.comma);
-      }
-
-      return undefined;
-    }
-
-    return result;
-  }
-
-  tsParseBracketedList(kind, parseElement, bracket, skipFirstToken) {
-    if (!skipFirstToken) {
-      if (bracket) {
-        this.expect(_types.types.bracketL);
-      } else {
-        this.expectRelational("<");
-      }
-    }
-
-    const result = this.tsParseDelimitedList(kind, parseElement);
-
-    if (bracket) {
-      this.expect(_types.types.bracketR);
-    } else {
-      this.expectRelational(">");
-    }
-
-    return result;
-  }
-
-  tsParseImportType() {
-    const node = this.startNode();
-    this.expect(_types.types._import);
-    this.expect(_types.types.parenL);
-
-    if (!this.match(_types.types.string)) {
-      this.raise(this.state.start, TSErrors.UnsupportedImportTypeArgument);
-    }
-
-    node.argument = this.parseExprAtom();
-    this.expect(_types.types.parenR);
-
-    if (this.eat(_types.types.dot)) {
-      node.qualifier = this.tsParseEntityName(true);
-    }
-
-    if (this.isRelational("<")) {
-      node.typeParameters = this.tsParseTypeArguments();
-    }
-
-    return this.finishNode(node, "TSImportType");
-  }
-
-  tsParseEntityName(allowReservedWords) {
-    let entity = this.parseIdentifier();
-
-    while (this.eat(_types.types.dot)) {
-      const node = this.startNodeAtNode(entity);
-      node.left = entity;
-      node.right = this.parseIdentifier(allowReservedWords);
-      entity = this.finishNode(node, "TSQualifiedName");
-    }
-
-    return entity;
-  }
-
-  tsParseTypeReference() {
-    const node = this.startNode();
-    node.typeName = this.tsParseEntityName(false);
-
-    if (!this.hasPrecedingLineBreak() && this.isRelational("<")) {
-      node.typeParameters = this.tsParseTypeArguments();
-    }
-
-    return this.finishNode(node, "TSTypeReference");
-  }
-
-  tsParseThisTypePredicate(lhs) {
-    this.next();
-    const node = this.startNodeAtNode(lhs);
-    node.parameterName = lhs;
-    node.typeAnnotation = this.tsParseTypeAnnotation(false);
-    return this.finishNode(node, "TSTypePredicate");
-  }
-
-  tsParseThisTypeNode() {
-    const node = this.startNode();
-    this.next();
-    return this.finishNode(node, "TSThisType");
-  }
-
-  tsParseTypeQuery() {
-    const node = this.startNode();
-    this.expect(_types.types._typeof);
-
-    if (this.match(_types.types._import)) {
-      node.exprName = this.tsParseImportType();
-    } else {
-      node.exprName = this.tsParseEntityName(true);
-    }
-
-    return this.finishNode(node, "TSTypeQuery");
-  }
-
-  tsParseTypeParameter() {
-    const node = this.startNode();
-    node.name = this.parseIdentifierName(node.start);
-    node.constraint = this.tsEatThenParseType(_types.types._extends);
-    node.default = this.tsEatThenParseType(_types.types.eq);
-    return this.finishNode(node, "TSTypeParameter");
-  }
-
-  tsTryParseTypeParameters() {
-    if (this.isRelational("<")) {
-      return this.tsParseTypeParameters();
-    }
-  }
-
-  tsParseTypeParameters() {
-    const node = this.startNode();
-
-    if (this.isRelational("<") || this.match(_types.types.jsxTagStart)) {
-      this.next();
-    } else {
-      this.unexpected();
-    }
-
-    node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this), false, true);
-
-    if (node.params.length === 0) {
-      this.raise(node.start, TSErrors.EmptyTypeParameters);
-    }
-
-    return this.finishNode(node, "TSTypeParameterDeclaration");
-  }
-
-  tsTryNextParseConstantContext() {
-    if (this.lookahead().type === _types.types._const) {
-      this.next();
-      return this.tsParseTypeReference();
-    }
-
-    return null;
-  }
-
-  tsFillSignature(returnToken, signature) {
-    const returnTokenRequired = returnToken === _types.types.arrow;
-    signature.typeParameters = this.tsTryParseTypeParameters();
-    this.expect(_types.types.parenL);
-    signature.parameters = this.tsParseBindingListForSignature();
-
-    if (returnTokenRequired) {
-      signature.typeAnnotation = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
-    } else if (this.match(returnToken)) {
-      signature.typeAnnotation = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
-    }
-  }
-
-  tsParseBindingListForSignature() {
-    return this.parseBindingList(_types.types.parenR, 41).map(pattern => {
-      if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") {
-        this.raise(pattern.start, TSErrors.UnsupportedSignatureParameterKind, pattern.type);
-      }
-
-      return pattern;
-    });
-  }
-
-  tsParseTypeMemberSemicolon() {
-    if (!this.eat(_types.types.comma)) {
-      this.semicolon();
-    }
-  }
-
-  tsParseSignatureMember(kind, node) {
-    this.tsFillSignature(_types.types.colon, node);
-    this.tsParseTypeMemberSemicolon();
-    return this.finishNode(node, kind);
-  }
-
-  tsIsUnambiguouslyIndexSignature() {
-    this.next();
-    return this.eat(_types.types.name) && this.match(_types.types.colon);
-  }
-
-  tsTryParseIndexSignature(node) {
-    if (!(this.match(_types.types.bracketL) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {
-      return undefined;
-    }
-
-    this.expect(_types.types.bracketL);
-    const id = this.parseIdentifier();
-    id.typeAnnotation = this.tsParseTypeAnnotation();
-    this.resetEndLocation(id);
-    this.expect(_types.types.bracketR);
-    node.parameters = [id];
-    const type = this.tsTryParseTypeAnnotation();
-    if (type) node.typeAnnotation = type;
-    this.tsParseTypeMemberSemicolon();
-    return this.finishNode(node, "TSIndexSignature");
-  }
-
-  tsParsePropertyOrMethodSignature(node, readonly) {
-    if (this.eat(_types.types.question)) node.optional = true;
-    const nodeAny = node;
-
-    if (!readonly && (this.match(_types.types.parenL) || this.isRelational("<"))) {
-      const method = nodeAny;
-      this.tsFillSignature(_types.types.colon, method);
-      this.tsParseTypeMemberSemicolon();
-      return this.finishNode(method, "TSMethodSignature");
-    } else {
-      const property = nodeAny;
-      if (readonly) property.readonly = true;
-      const type = this.tsTryParseTypeAnnotation();
-      if (type) property.typeAnnotation = type;
-      this.tsParseTypeMemberSemicolon();
-      return this.finishNode(property, "TSPropertySignature");
-    }
-  }
-
-  tsParseTypeMember() {
-    const node = this.startNode();
-
-    if (this.match(_types.types.parenL) || this.isRelational("<")) {
-      return this.tsParseSignatureMember("TSCallSignatureDeclaration", node);
-    }
-
-    if (this.match(_types.types._new)) {
-      const id = this.startNode();
-      this.next();
-
-      if (this.match(_types.types.parenL) || this.isRelational("<")) {
-        return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node);
-      } else {
-        node.key = this.createIdentifier(id, "new");
-        return this.tsParsePropertyOrMethodSignature(node, false);
-      }
-    }
-
-    const readonly = !!this.tsParseModifier(["readonly"]);
-    const idx = this.tsTryParseIndexSignature(node);
-
-    if (idx) {
-      if (readonly) node.readonly = true;
-      return idx;
-    }
-
-    this.parsePropertyName(node, false);
-    return this.tsParsePropertyOrMethodSignature(node, readonly);
-  }
-
-  tsParseTypeLiteral() {
-    const node = this.startNode();
-    node.members = this.tsParseObjectTypeMembers();
-    return this.finishNode(node, "TSTypeLiteral");
-  }
-
-  tsParseObjectTypeMembers() {
-    this.expect(_types.types.braceL);
-    const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
-    this.expect(_types.types.braceR);
-    return members;
-  }
-
-  tsIsStartOfMappedType() {
-    this.next();
-
-    if (this.eat(_types.types.plusMin)) {
-      return this.isContextual("readonly");
-    }
-
-    if (this.isContextual("readonly")) {
-      this.next();
-    }
-
-    if (!this.match(_types.types.bracketL)) {
-      return false;
-    }
-
-    this.next();
-
-    if (!this.tsIsIdentifier()) {
-      return false;
-    }
-
-    this.next();
-    return this.match(_types.types._in);
-  }
-
-  tsParseMappedTypeParameter() {
-    const node = this.startNode();
-    node.name = this.parseIdentifierName(node.start);
-    node.constraint = this.tsExpectThenParseType(_types.types._in);
-    return this.finishNode(node, "TSTypeParameter");
-  }
-
-  tsParseMappedType() {
-    const node = this.startNode();
-    this.expect(_types.types.braceL);
-
-    if (this.match(_types.types.plusMin)) {
-      node.readonly = this.state.value;
-      this.next();
-      this.expectContextual("readonly");
-    } else if (this.eatContextual("readonly")) {
-      node.readonly = true;
-    }
-
-    this.expect(_types.types.bracketL);
-    node.typeParameter = this.tsParseMappedTypeParameter();
-    node.nameType = this.eatContextual("as") ? this.tsParseType() : null;
-    this.expect(_types.types.bracketR);
-
-    if (this.match(_types.types.plusMin)) {
-      node.optional = this.state.value;
-      this.next();
-      this.expect(_types.types.question);
-    } else if (this.eat(_types.types.question)) {
-      node.optional = true;
-    }
-
-    node.typeAnnotation = this.tsTryParseType();
-    this.semicolon();
-    this.expect(_types.types.braceR);
-    return this.finishNode(node, "TSMappedType");
-  }
-
-  tsParseTupleType() {
-    const node = this.startNode();
-    node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false);
-    let seenOptionalElement = false;
-    let labeledElements = null;
-    node.elementTypes.forEach(elementNode => {
-      let {
-        type
-      } = elementNode;
-
-      if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
-        this.raise(elementNode.start, TSErrors.OptionalTypeBeforeRequired);
-      }
-
-      seenOptionalElement = seenOptionalElement || type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType";
-
-      if (type === "TSRestType") {
-        elementNode = elementNode.typeAnnotation;
-        type = elementNode.type;
-      }
-
-      const isLabeled = type === "TSNamedTupleMember";
-      labeledElements = labeledElements ?? isLabeled;
-
-      if (labeledElements !== isLabeled) {
-        this.raise(elementNode.start, TSErrors.MixedLabeledAndUnlabeledElements);
-      }
-    });
-    return this.finishNode(node, "TSTupleType");
-  }
-
-  tsParseTupleElementType() {
-    const {
-      start: startPos,
-      startLoc
-    } = this.state;
-    const rest = this.eat(_types.types.ellipsis);
-    let type = this.tsParseType();
-    const optional = this.eat(_types.types.question);
-    const labeled = this.eat(_types.types.colon);
-
-    if (labeled) {
-      const labeledNode = this.startNodeAtNode(type);
-      labeledNode.optional = optional;
-
-      if (type.type === "TSTypeReference" && !type.typeParameters && type.typeName.type === "Identifier") {
-        labeledNode.label = type.typeName;
-      } else {
-        this.raise(type.start, TSErrors.InvalidTupleMemberLabel);
-        labeledNode.label = type;
-      }
-
-      labeledNode.elementType = this.tsParseType();
-      type = this.finishNode(labeledNode, "TSNamedTupleMember");
-    } else if (optional) {
-      const optionalTypeNode = this.startNodeAtNode(type);
-      optionalTypeNode.typeAnnotation = type;
-      type = this.finishNode(optionalTypeNode, "TSOptionalType");
-    }
-
-    if (rest) {
-      const restNode = this.startNodeAt(startPos, startLoc);
-      restNode.typeAnnotation = type;
-      type = this.finishNode(restNode, "TSRestType");
-    }
-
-    return type;
-  }
-
-  tsParseParenthesizedType() {
-    const node = this.startNode();
-    this.expect(_types.types.parenL);
-    node.typeAnnotation = this.tsParseType();
-    this.expect(_types.types.parenR);
-    return this.finishNode(node, "TSParenthesizedType");
-  }
-
-  tsParseFunctionOrConstructorType(type) {
-    const node = this.startNode();
-
-    if (type === "TSConstructorType") {
-      this.expect(_types.types._new);
-    }
-
-    this.tsFillSignature(_types.types.arrow, node);
-    return this.finishNode(node, type);
-  }
-
-  tsParseLiteralTypeNode() {
-    const node = this.startNode();
-
-    node.literal = (() => {
-      switch (this.state.type) {
-        case _types.types.num:
-        case _types.types.bigint:
-        case _types.types.string:
-        case _types.types._true:
-        case _types.types._false:
-          return this.parseExprAtom();
-
-        default:
-          throw this.unexpected();
-      }
-    })();
-
-    return this.finishNode(node, "TSLiteralType");
-  }
-
-  tsParseTemplateLiteralType() {
-    const node = this.startNode();
-    node.literal = this.parseTemplate(false);
-    return this.finishNode(node, "TSLiteralType");
-  }
-
-  parseTemplateSubstitution() {
-    if (this.state.inType) return this.tsParseType();
-    return super.parseTemplateSubstitution();
-  }
-
-  tsParseThisTypeOrThisTypePredicate() {
-    const thisKeyword = this.tsParseThisTypeNode();
-
-    if (this.isContextual("is") && !this.hasPrecedingLineBreak()) {
-      return this.tsParseThisTypePredicate(thisKeyword);
-    } else {
-      return thisKeyword;
-    }
-  }
-
-  tsParseNonArrayType() {
-    switch (this.state.type) {
-      case _types.types.name:
-      case _types.types._void:
-      case _types.types._null:
-        {
-          const type = this.match(_types.types._void) ? "TSVoidKeyword" : this.match(_types.types._null) ? "TSNullKeyword" : keywordTypeFromName(this.state.value);
-
-          if (type !== undefined && this.lookaheadCharCode() !== 46) {
-            const node = this.startNode();
-            this.next();
-            return this.finishNode(node, type);
-          }
-
-          return this.tsParseTypeReference();
-        }
-
-      case _types.types.string:
-      case _types.types.num:
-      case _types.types.bigint:
-      case _types.types._true:
-      case _types.types._false:
-        return this.tsParseLiteralTypeNode();
-
-      case _types.types.plusMin:
-        if (this.state.value === "-") {
-          const node = this.startNode();
-          const nextToken = this.lookahead();
-
-          if (nextToken.type !== _types.types.num && nextToken.type !== _types.types.bigint) {
-            throw this.unexpected();
-          }
-
-          node.literal = this.parseMaybeUnary();
-          return this.finishNode(node, "TSLiteralType");
-        }
-
-        break;
-
-      case _types.types._this:
-        return this.tsParseThisTypeOrThisTypePredicate();
-
-      case _types.types._typeof:
-        return this.tsParseTypeQuery();
-
-      case _types.types._import:
-        return this.tsParseImportType();
-
-      case _types.types.braceL:
-        return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
-
-      case _types.types.bracketL:
-        return this.tsParseTupleType();
-
-      case _types.types.parenL:
-        return this.tsParseParenthesizedType();
-
-      case _types.types.backQuote:
-        return this.tsParseTemplateLiteralType();
-    }
-
-    throw this.unexpected();
-  }
-
-  tsParseArrayTypeOrHigher() {
-    let type = this.tsParseNonArrayType();
-
-    while (!this.hasPrecedingLineBreak() && this.eat(_types.types.bracketL)) {
-      if (this.match(_types.types.bracketR)) {
-        const node = this.startNodeAtNode(type);
-        node.elementType = type;
-        this.expect(_types.types.bracketR);
-        type = this.finishNode(node, "TSArrayType");
-      } else {
-        const node = this.startNodeAtNode(type);
-        node.objectType = type;
-        node.indexType = this.tsParseType();
-        this.expect(_types.types.bracketR);
-        type = this.finishNode(node, "TSIndexedAccessType");
-      }
-    }
-
-    return type;
-  }
-
-  tsParseTypeOperator(operator) {
-    const node = this.startNode();
-    this.expectContextual(operator);
-    node.operator = operator;
-    node.typeAnnotation = this.tsParseTypeOperatorOrHigher();
-
-    if (operator === "readonly") {
-      this.tsCheckTypeAnnotationForReadOnly(node);
-    }
-
-    return this.finishNode(node, "TSTypeOperator");
-  }
-
-  tsCheckTypeAnnotationForReadOnly(node) {
-    switch (node.typeAnnotation.type) {
-      case "TSTupleType":
-      case "TSArrayType":
-        return;
-
-      default:
-        this.raise(node.start, TSErrors.UnexpectedReadonly);
-    }
-  }
-
-  tsParseInferType() {
-    const node = this.startNode();
-    this.expectContextual("infer");
-    const typeParameter = this.startNode();
-    typeParameter.name = this.parseIdentifierName(typeParameter.start);
-    node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
-    return this.finishNode(node, "TSInferType");
-  }
-
-  tsParseTypeOperatorOrHigher() {
-    const operator = ["keyof", "unique", "readonly"].find(kw => this.isContextual(kw));
-    return operator ? this.tsParseTypeOperator(operator) : this.isContextual("infer") ? this.tsParseInferType() : this.tsParseArrayTypeOrHigher();
-  }
-
-  tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
-    this.eat(operator);
-    let type = parseConstituentType();
-
-    if (this.match(operator)) {
-      const types = [type];
-
-      while (this.eat(operator)) {
-        types.push(parseConstituentType());
-      }
-
-      const node = this.startNodeAtNode(type);
-      node.types = types;
-      type = this.finishNode(node, kind);
-    }
-
-    return type;
-  }
-
-  tsParseIntersectionTypeOrHigher() {
-    return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), _types.types.bitwiseAND);
-  }
-
-  tsParseUnionTypeOrHigher() {
-    return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), _types.types.bitwiseOR);
-  }
-
-  tsIsStartOfFunctionType() {
-    if (this.isRelational("<")) {
-      return true;
-    }
-
-    return this.match(_types.types.parenL) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
-  }
-
-  tsSkipParameterStart() {
-    if (this.match(_types.types.name) || this.match(_types.types._this)) {
-      this.next();
-      return true;
-    }
-
-    if (this.match(_types.types.braceL)) {
-      let braceStackCounter = 1;
-      this.next();
-
-      while (braceStackCounter > 0) {
-        if (this.match(_types.types.braceL)) {
-          ++braceStackCounter;
-        } else if (this.match(_types.types.braceR)) {
-          --braceStackCounter;
-        }
-
-        this.next();
-      }
-
-      return true;
-    }
-
-    if (this.match(_types.types.bracketL)) {
-      let braceStackCounter = 1;
-      this.next();
-
-      while (braceStackCounter > 0) {
-        if (this.match(_types.types.bracketL)) {
-          ++braceStackCounter;
-        } else if (this.match(_types.types.bracketR)) {
-          --braceStackCounter;
-        }
-
-        this.next();
-      }
-
-      return true;
-    }
-
-    return false;
-  }
-
-  tsIsUnambiguouslyStartOfFunctionType() {
-    this.next();
-
-    if (this.match(_types.types.parenR) || this.match(_types.types.ellipsis)) {
-      return true;
-    }
-
-    if (this.tsSkipParameterStart()) {
-      if (this.match(_types.types.colon) || this.match(_types.types.comma) || this.match(_types.types.question) || this.match(_types.types.eq)) {
-        return true;
-      }
-
-      if (this.match(_types.types.parenR)) {
-        this.next();
-
-        if (this.match(_types.types.arrow)) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-
-  tsParseTypeOrTypePredicateAnnotation(returnToken) {
-    return this.tsInType(() => {
-      const t = this.startNode();
-      this.expect(returnToken);
-      const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
-
-      if (asserts && this.match(_types.types._this)) {
-        let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();
-
-        if (thisTypePredicate.type === "TSThisType") {
-          const node = this.startNodeAtNode(t);
-          node.parameterName = thisTypePredicate;
-          node.asserts = true;
-          thisTypePredicate = this.finishNode(node, "TSTypePredicate");
-        } else {
-          thisTypePredicate.asserts = true;
-        }
-
-        t.typeAnnotation = thisTypePredicate;
-        return this.finishNode(t, "TSTypeAnnotation");
-      }
-
-      const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
-
-      if (!typePredicateVariable) {
-        if (!asserts) {
-          return this.tsParseTypeAnnotation(false, t);
-        }
-
-        const node = this.startNodeAtNode(t);
-        node.parameterName = this.parseIdentifier();
-        node.asserts = asserts;
-        t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
-        return this.finishNode(t, "TSTypeAnnotation");
-      }
-
-      const type = this.tsParseTypeAnnotation(false);
-      const node = this.startNodeAtNode(t);
-      node.parameterName = typePredicateVariable;
-      node.typeAnnotation = type;
-      node.asserts = asserts;
-      t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
-      return this.finishNode(t, "TSTypeAnnotation");
-    });
-  }
-
-  tsTryParseTypeOrTypePredicateAnnotation() {
-    return this.match(_types.types.colon) ? this.tsParseTypeOrTypePredicateAnnotation(_types.types.colon) : undefined;
-  }
-
-  tsTryParseTypeAnnotation() {
-    return this.match(_types.types.colon) ? this.tsParseTypeAnnotation() : undefined;
-  }
-
-  tsTryParseType() {
-    return this.tsEatThenParseType(_types.types.colon);
-  }
-
-  tsParseTypePredicatePrefix() {
-    const id = this.parseIdentifier();
-
-    if (this.isContextual("is") && !this.hasPrecedingLineBreak()) {
-      this.next();
-      return id;
-    }
-  }
-
-  tsParseTypePredicateAsserts() {
-    if (!this.match(_types.types.name) || this.state.value !== "asserts" || this.hasPrecedingLineBreak()) {
-      return false;
-    }
-
-    const containsEsc = this.state.containsEsc;
-    this.next();
-
-    if (!this.match(_types.types.name) && !this.match(_types.types._this)) {
-      return false;
-    }
-
-    if (containsEsc) {
-      this.raise(this.state.lastTokStart, _error.Errors.InvalidEscapedReservedWord, "asserts");
-    }
-
-    return true;
-  }
-
-  tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {
-    this.tsInType(() => {
-      if (eatColon) this.expect(_types.types.colon);
-      t.typeAnnotation = this.tsParseType();
-    });
-    return this.finishNode(t, "TSTypeAnnotation");
-  }
-
-  tsParseType() {
-    assert(this.state.inType);
-    const type = this.tsParseNonConditionalType();
-
-    if (this.hasPrecedingLineBreak() || !this.eat(_types.types._extends)) {
-      return type;
-    }
-
-    const node = this.startNodeAtNode(type);
-    node.checkType = type;
-    node.extendsType = this.tsParseNonConditionalType();
-    this.expect(_types.types.question);
-    node.trueType = this.tsParseType();
-    this.expect(_types.types.colon);
-    node.falseType = this.tsParseType();
-    return this.finishNode(node, "TSConditionalType");
-  }
-
-  tsParseNonConditionalType() {
-    if (this.tsIsStartOfFunctionType()) {
-      return this.tsParseFunctionOrConstructorType("TSFunctionType");
-    }
-
-    if (this.match(_types.types._new)) {
-      return this.tsParseFunctionOrConstructorType("TSConstructorType");
-    }
-
-    return this.tsParseUnionTypeOrHigher();
-  }
-
-  tsParseTypeAssertion() {
-    const node = this.startNode();
-
-    const _const = this.tsTryNextParseConstantContext();
-
-    node.typeAnnotation = _const || this.tsNextThenParseType();
-    this.expectRelational(">");
-    node.expression = this.parseMaybeUnary();
-    return this.finishNode(node, "TSTypeAssertion");
-  }
-
-  tsParseHeritageClause(descriptor) {
-    const originalStart = this.state.start;
-    const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", this.tsParseExpressionWithTypeArguments.bind(this));
-
-    if (!delimitedList.length) {
-      this.raise(originalStart, TSErrors.EmptyHeritageClauseType, descriptor);
-    }
-
-    return delimitedList;
-  }
-
-  tsParseExpressionWithTypeArguments() {
-    const node = this.startNode();
-    node.expression = this.tsParseEntityName(false);
-
-    if (this.isRelational("<")) {
-      node.typeParameters = this.tsParseTypeArguments();
-    }
-
-    return this.finishNode(node, "TSExpressionWithTypeArguments");
-  }
-
-  tsParseInterfaceDeclaration(node) {
-    node.id = this.parseIdentifier();
-    this.checkLVal(node.id, _scopeflags.BIND_TS_INTERFACE, undefined, "typescript interface declaration");
-    node.typeParameters = this.tsTryParseTypeParameters();
-
-    if (this.eat(_types.types._extends)) {
-      node.extends = this.tsParseHeritageClause("extends");
-    }
-
-    const body = this.startNode();
-    body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));
-    node.body = this.finishNode(body, "TSInterfaceBody");
-    return this.finishNode(node, "TSInterfaceDeclaration");
-  }
-
-  tsParseTypeAliasDeclaration(node) {
-    node.id = this.parseIdentifier();
-    this.checkLVal(node.id, _scopeflags.BIND_TS_TYPE, undefined, "typescript type alias");
-    node.typeParameters = this.tsTryParseTypeParameters();
-    node.typeAnnotation = this.tsInType(() => {
-      this.expect(_types.types.eq);
-
-      if (this.isContextual("intrinsic") && this.lookahead().type !== _types.types.dot) {
-        const node = this.startNode();
-        this.next();
-        return this.finishNode(node, "TSIntrinsicKeyword");
-      }
-
-      return this.tsParseType();
-    });
-    this.semicolon();
-    return this.finishNode(node, "TSTypeAliasDeclaration");
-  }
-
-  tsInNoContext(cb) {
-    const oldContext = this.state.context;
-    this.state.context = [oldContext[0]];
-
-    try {
-      return cb();
-    } finally {
-      this.state.context = oldContext;
-    }
-  }
-
-  tsInType(cb) {
-    const oldInType = this.state.inType;
-    this.state.inType = true;
-
-    try {
-      return cb();
-    } finally {
-      this.state.inType = oldInType;
-    }
-  }
-
-  tsEatThenParseType(token) {
-    return !this.match(token) ? undefined : this.tsNextThenParseType();
-  }
-
-  tsExpectThenParseType(token) {
-    return this.tsDoThenParseType(() => this.expect(token));
-  }
-
-  tsNextThenParseType() {
-    return this.tsDoThenParseType(() => this.next());
-  }
-
-  tsDoThenParseType(cb) {
-    return this.tsInType(() => {
-      cb();
-      return this.tsParseType();
-    });
-  }
-
-  tsParseEnumMember() {
-    const node = this.startNode();
-    node.id = this.match(_types.types.string) ? this.parseExprAtom() : this.parseIdentifier(true);
-
-    if (this.eat(_types.types.eq)) {
-      node.initializer = this.parseMaybeAssignAllowIn();
-    }
-
-    return this.finishNode(node, "TSEnumMember");
-  }
-
-  tsParseEnumDeclaration(node, isConst) {
-    if (isConst) node.const = true;
-    node.id = this.parseIdentifier();
-    this.checkLVal(node.id, isConst ? _scopeflags.BIND_TS_CONST_ENUM : _scopeflags.BIND_TS_ENUM, undefined, "typescript enum declaration");
-    this.expect(_types.types.braceL);
-    node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
-    this.expect(_types.types.braceR);
-    return this.finishNode(node, "TSEnumDeclaration");
-  }
-
-  tsParseModuleBlock() {
-    const node = this.startNode();
-    this.scope.enter(_scopeflags.SCOPE_OTHER);
-    this.expect(_types.types.braceL);
-    this.parseBlockOrModuleBlockBody(node.body = [], undefined, true, _types.types.braceR);
-    this.scope.exit();
-    return this.finishNode(node, "TSModuleBlock");
-  }
-
-  tsParseModuleOrNamespaceDeclaration(node, nested = false) {
-    node.id = this.parseIdentifier();
-
-    if (!nested) {
-      this.checkLVal(node.id, _scopeflags.BIND_TS_NAMESPACE, null, "module or namespace declaration");
-    }
-
-    if (this.eat(_types.types.dot)) {
-      const inner = this.startNode();
-      this.tsParseModuleOrNamespaceDeclaration(inner, true);
-      node.body = inner;
-    } else {
-      this.scope.enter(_scopeflags.SCOPE_TS_MODULE);
-      this.prodParam.enter(_productionParameter.PARAM);
-      node.body = this.tsParseModuleBlock();
-      this.prodParam.exit();
-      this.scope.exit();
-    }
-
-    return this.finishNode(node, "TSModuleDeclaration");
-  }
-
-  tsParseAmbientExternalModuleDeclaration(node) {
-    if (this.isContextual("global")) {
-      node.global = true;
-      node.id = this.parseIdentifier();
-    } else if (this.match(_types.types.string)) {
-      node.id = this.parseExprAtom();
-    } else {
-      this.unexpected();
-    }
-
-    if (this.match(_types.types.braceL)) {
-      this.scope.enter(_scopeflags.SCOPE_TS_MODULE);
-      this.prodParam.enter(_productionParameter.PARAM);
-      node.body = this.tsParseModuleBlock();
-      this.prodParam.exit();
-      this.scope.exit();
-    } else {
-      this.semicolon();
-    }
-
-    return this.finishNode(node, "TSModuleDeclaration");
-  }
-
-  tsParseImportEqualsDeclaration(node, isExport) {
-    node.isExport = isExport || false;
-    node.id = this.parseIdentifier();
-    this.checkLVal(node.id, _scopeflags.BIND_LEXICAL, undefined, "import equals declaration");
-    this.expect(_types.types.eq);
-    node.moduleReference = this.tsParseModuleReference();
-    this.semicolon();
-    return this.finishNode(node, "TSImportEqualsDeclaration");
-  }
-
-  tsIsExternalModuleReference() {
-    return this.isContextual("require") && this.lookaheadCharCode() === 40;
-  }
-
-  tsParseModuleReference() {
-    return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
-  }
-
-  tsParseExternalModuleReference() {
-    const node = this.startNode();
-    this.expectContextual("require");
-    this.expect(_types.types.parenL);
-
-    if (!this.match(_types.types.string)) {
-      throw this.unexpected();
-    }
-
-    node.expression = this.parseExprAtom();
-    this.expect(_types.types.parenR);
-    return this.finishNode(node, "TSExternalModuleReference");
-  }
-
-  tsLookAhead(f) {
-    const state = this.state.clone();
-    const res = f();
-    this.state = state;
-    return res;
-  }
-
-  tsTryParseAndCatch(f) {
-    const result = this.tryParse(abort => f() || abort());
-    if (result.aborted || !result.node) return undefined;
-    if (result.error) this.state = result.failState;
-    return result.node;
-  }
-
-  tsTryParse(f) {
-    const state = this.state.clone();
-    const result = f();
-
-    if (result !== undefined && result !== false) {
-      return result;
-    } else {
-      this.state = state;
-      return undefined;
-    }
-  }
-
-  tsTryParseDeclare(nany) {
-    if (this.isLineTerminator()) {
-      return;
-    }
-
-    let starttype = this.state.type;
-    let kind;
-
-    if (this.isContextual("let")) {
-      starttype = _types.types._var;
-      kind = "let";
-    }
-
-    return this.tsInDeclareContext(() => {
-      switch (starttype) {
-        case _types.types._function:
-          nany.declare = true;
-          return this.parseFunctionStatement(nany, false, true);
-
-        case _types.types._class:
-          nany.declare = true;
-          return this.parseClass(nany, true, false);
-
-        case _types.types._const:
-          if (this.match(_types.types._const) && this.isLookaheadContextual("enum")) {
-            this.expect(_types.types._const);
-            this.expectContextual("enum");
-            return this.tsParseEnumDeclaration(nany, true);
-          }
-
-        case _types.types._var:
-          kind = kind || this.state.value;
-          return this.parseVarStatement(nany, kind);
-
-        case _types.types.name:
-          {
-            const value = this.state.value;
-
-            if (value === "global") {
-              return this.tsParseAmbientExternalModuleDeclaration(nany);
-            } else {
-              return this.tsParseDeclaration(nany, value, true);
-            }
-          }
-      }
-    });
-  }
-
-  tsTryParseExportDeclaration() {
-    return this.tsParseDeclaration(this.startNode(), this.state.value, true);
-  }
-
-  tsParseExpressionStatement(node, expr) {
-    switch (expr.name) {
-      case "declare":
-        {
-          const declaration = this.tsTryParseDeclare(node);
-
-          if (declaration) {
-            declaration.declare = true;
-            return declaration;
-          }
-
-          break;
-        }
-
-      case "global":
-        if (this.match(_types.types.braceL)) {
-          this.scope.enter(_scopeflags.SCOPE_TS_MODULE);
-          this.prodParam.enter(_productionParameter.PARAM);
-          const mod = node;
-          mod.global = true;
-          mod.id = expr;
-          mod.body = this.tsParseModuleBlock();
-          this.scope.exit();
-          this.prodParam.exit();
-          return this.finishNode(mod, "TSModuleDeclaration");
-        }
-
-        break;
-
-      default:
-        return this.tsParseDeclaration(node, expr.name, false);
-    }
-  }
-
-  tsParseDeclaration(node, value, next) {
-    switch (value) {
-      case "abstract":
-        if (this.tsCheckLineTerminatorAndMatch(_types.types._class, next)) {
-          const cls = node;
-          cls.abstract = true;
-
-          if (next) {
-            this.next();
-
-            if (!this.match(_types.types._class)) {
-              this.unexpected(null, _types.types._class);
-            }
-          }
-
-          return this.parseClass(cls, true, false);
-        }
-
-        break;
-
-      case "enum":
-        if (next || this.match(_types.types.name)) {
-          if (next) this.next();
-          return this.tsParseEnumDeclaration(node, false);
-        }
-
-        break;
-
-      case "interface":
-        if (this.tsCheckLineTerminatorAndMatch(_types.types.name, next)) {
-          if (next) this.next();
-          return this.tsParseInterfaceDeclaration(node);
-        }
-
-        break;
-
-      case "module":
-        if (next) this.next();
-
-        if (this.match(_types.types.string)) {
-          return this.tsParseAmbientExternalModuleDeclaration(node);
-        } else if (this.tsCheckLineTerminatorAndMatch(_types.types.name, next)) {
-          return this.tsParseModuleOrNamespaceDeclaration(node);
-        }
-
-        break;
-
-      case "namespace":
-        if (this.tsCheckLineTerminatorAndMatch(_types.types.name, next)) {
-          if (next) this.next();
-          return this.tsParseModuleOrNamespaceDeclaration(node);
-        }
-
-        break;
-
-      case "type":
-        if (this.tsCheckLineTerminatorAndMatch(_types.types.name, next)) {
-          if (next) this.next();
-          return this.tsParseTypeAliasDeclaration(node);
-        }
-
-        break;
-    }
-  }
-
-  tsCheckLineTerminatorAndMatch(tokenType, next) {
-    return (next || this.match(tokenType)) && !this.isLineTerminator();
-  }
-
-  tsTryParseGenericAsyncArrowFunction(startPos, startLoc) {
-    if (!this.isRelational("<")) {
-      return undefined;
-    }
-
-    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
-    this.state.maybeInArrowParameters = true;
-    const res = this.tsTryParseAndCatch(() => {
-      const node = this.startNodeAt(startPos, startLoc);
-      node.typeParameters = this.tsParseTypeParameters();
-      super.parseFunctionParams(node);
-      node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
-      this.expect(_types.types.arrow);
-      return node;
-    });
-    this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
-
-    if (!res) {
-      return undefined;
-    }
-
-    return this.parseArrowExpression(res, null, true);
-  }
-
-  tsParseTypeArguments() {
-    const node = this.startNode();
-    node.params = this.tsInType(() => this.tsInNoContext(() => {
-      this.expectRelational("<");
-      return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
-    }));
-
-    if (node.params.length === 0) {
-      this.raise(node.start, TSErrors.EmptyTypeArguments);
-    }
-
-    this.state.exprAllowed = false;
-    this.expectRelational(">");
-    return this.finishNode(node, "TSTypeParameterInstantiation");
-  }
-
-  tsIsDeclarationStart() {
-    if (this.match(_types.types.name)) {
-      switch (this.state.value) {
-        case "abstract":
-        case "declare":
-        case "enum":
-        case "interface":
-        case "module":
-        case "namespace":
-        case "type":
-          return true;
-      }
-    }
-
-    return false;
-  }
-
-  isExportDefaultSpecifier() {
-    if (this.tsIsDeclarationStart()) return false;
-    return super.isExportDefaultSpecifier();
-  }
-
-  parseAssignableListItem(allowModifiers, decorators) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    let accessibility;
-    let readonly = false;
-
-    if (allowModifiers !== undefined) {
-      accessibility = this.parseAccessModifier();
-      readonly = !!this.tsParseModifier(["readonly"]);
-
-      if (allowModifiers === false && (accessibility || readonly)) {
-        this.raise(startPos, TSErrors.UnexpectedParameterModifier);
-      }
-    }
-
-    const left = this.parseMaybeDefault();
-    this.parseAssignableListItemTypes(left);
-    const elt = this.parseMaybeDefault(left.start, left.loc.start, left);
-
-    if (accessibility || readonly) {
-      const pp = this.startNodeAt(startPos, startLoc);
-
-      if (decorators.length) {
-        pp.decorators = decorators;
-      }
-
-      if (accessibility) pp.accessibility = accessibility;
-      if (readonly) pp.readonly = readonly;
-
-      if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
-        this.raise(pp.start, TSErrors.UnsupportedParameterPropertyKind);
-      }
-
-      pp.parameter = elt;
-      return this.finishNode(pp, "TSParameterProperty");
-    }
-
-    if (decorators.length) {
-      left.decorators = decorators;
-    }
-
-    return elt;
-  }
-
-  parseFunctionBodyAndFinish(node, type, isMethod = false) {
-    if (this.match(_types.types.colon)) {
-      node.returnType = this.tsParseTypeOrTypePredicateAnnotation(_types.types.colon);
-    }
-
-    const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" ? "TSDeclareMethod" : undefined;
-
-    if (bodilessType && !this.match(_types.types.braceL) && this.isLineTerminator()) {
-      this.finishNode(node, bodilessType);
-      return;
-    }
-
-    if (bodilessType === "TSDeclareFunction" && this.state.isDeclareContext) {
-      this.raise(node.start, TSErrors.DeclareFunctionHasImplementation);
-
-      if (node.declare) {
-        super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
-        return;
-      }
-    }
-
-    super.parseFunctionBodyAndFinish(node, type, isMethod);
-  }
-
-  registerFunctionStatementId(node) {
-    if (!node.body && node.id) {
-      this.checkLVal(node.id, _scopeflags.BIND_TS_AMBIENT, null, "function name");
-    } else {
-      super.registerFunctionStatementId(...arguments);
-    }
-  }
-
-  tsCheckForInvalidTypeCasts(items) {
-    items.forEach(node => {
-      if (node?.type === "TSTypeCastExpression") {
-        this.raise(node.typeAnnotation.start, TSErrors.UnexpectedTypeAnnotation);
-      }
-    });
-  }
-
-  toReferencedList(exprList, isInParens) {
-    this.tsCheckForInvalidTypeCasts(exprList);
-    return exprList;
-  }
-
-  parseArrayLike(...args) {
-    const node = super.parseArrayLike(...args);
-
-    if (node.type === "ArrayExpression") {
-      this.tsCheckForInvalidTypeCasts(node.elements);
-    }
-
-    return node;
-  }
-
-  parseSubscript(base, startPos, startLoc, noCalls, state) {
-    if (!this.hasPrecedingLineBreak() && this.match(_types.types.bang)) {
-      this.state.exprAllowed = false;
-      this.next();
-      const nonNullExpression = this.startNodeAt(startPos, startLoc);
-      nonNullExpression.expression = base;
-      return this.finishNode(nonNullExpression, "TSNonNullExpression");
-    }
-
-    if (this.isRelational("<")) {
-      const result = this.tsTryParseAndCatch(() => {
-        if (!noCalls && this.atPossibleAsyncArrow(base)) {
-          const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startPos, startLoc);
-
-          if (asyncArrowFn) {
-            return asyncArrowFn;
-          }
-        }
-
-        const node = this.startNodeAt(startPos, startLoc);
-        node.callee = base;
-        const typeArguments = this.tsParseTypeArguments();
-
-        if (typeArguments) {
-          if (!noCalls && this.eat(_types.types.parenL)) {
-            node.arguments = this.parseCallExpressionArguments(_types.types.parenR, false);
-            this.tsCheckForInvalidTypeCasts(node.arguments);
-            node.typeParameters = typeArguments;
-            return this.finishCallExpression(node, state.optionalChainMember);
-          } else if (this.match(_types.types.backQuote)) {
-            const result = this.parseTaggedTemplateExpression(base, startPos, startLoc, state);
-            result.typeParameters = typeArguments;
-            return result;
-          }
-        }
-
-        this.unexpected();
-      });
-      if (result) return result;
-    }
-
-    return super.parseSubscript(base, startPos, startLoc, noCalls, state);
-  }
-
-  parseNewArguments(node) {
-    if (this.isRelational("<")) {
-      const typeParameters = this.tsTryParseAndCatch(() => {
-        const args = this.tsParseTypeArguments();
-        if (!this.match(_types.types.parenL)) this.unexpected();
-        return args;
-      });
-
-      if (typeParameters) {
-        node.typeParameters = typeParameters;
-      }
-    }
-
-    super.parseNewArguments(node);
-  }
-
-  parseExprOp(left, leftStartPos, leftStartLoc, minPrec) {
-    if (nonNull(_types.types._in.binop) > minPrec && !this.hasPrecedingLineBreak() && this.isContextual("as")) {
-      const node = this.startNodeAt(leftStartPos, leftStartLoc);
-      node.expression = left;
-
-      const _const = this.tsTryNextParseConstantContext();
-
-      if (_const) {
-        node.typeAnnotation = _const;
-      } else {
-        node.typeAnnotation = this.tsNextThenParseType();
-      }
-
-      this.finishNode(node, "TSAsExpression");
-      this.reScan_lt_gt();
-      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec);
-    }
-
-    return super.parseExprOp(left, leftStartPos, leftStartLoc, minPrec);
-  }
-
-  checkReservedWord(word, startLoc, checkKeywords, isBinding) {}
-
-  checkDuplicateExports() {}
-
-  parseImport(node) {
-    if (this.match(_types.types.name) || this.match(_types.types.star) || this.match(_types.types.braceL)) {
-      const ahead = this.lookahead();
-
-      if (this.match(_types.types.name) && ahead.type === _types.types.eq) {
-        return this.tsParseImportEqualsDeclaration(node);
-      }
-
-      if (this.isContextual("type") && ahead.type !== _types.types.comma && !(ahead.type === _types.types.name && ahead.value === "from")) {
-        node.importKind = "type";
-        this.next();
-      }
-    }
-
-    if (!node.importKind) {
-      node.importKind = "value";
-    }
-
-    const importNode = super.parseImport(node);
-
-    if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
-      this.raise(importNode.start, "A type-only import can specify a default import or named bindings, but not both.");
-    }
-
-    return importNode;
-  }
-
-  parseExport(node) {
-    if (this.match(_types.types._import)) {
-      this.expect(_types.types._import);
-      return this.tsParseImportEqualsDeclaration(node, true);
-    } else if (this.eat(_types.types.eq)) {
-      const assign = node;
-      assign.expression = this.parseExpression();
-      this.semicolon();
-      return this.finishNode(assign, "TSExportAssignment");
-    } else if (this.eatContextual("as")) {
-      const decl = node;
-      this.expectContextual("namespace");
-      decl.id = this.parseIdentifier();
-      this.semicolon();
-      return this.finishNode(decl, "TSNamespaceExportDeclaration");
-    } else {
-      if (this.isContextual("type") && this.lookahead().type === _types.types.braceL) {
-        this.next();
-        node.exportKind = "type";
-      } else {
-        node.exportKind = "value";
-      }
-
-      return super.parseExport(node);
-    }
-  }
-
-  isAbstractClass() {
-    return this.isContextual("abstract") && this.lookahead().type === _types.types._class;
-  }
-
-  parseExportDefaultExpression() {
-    if (this.isAbstractClass()) {
-      const cls = this.startNode();
-      this.next();
-      this.parseClass(cls, true, true);
-      cls.abstract = true;
-      return cls;
-    }
-
-    if (this.state.value === "interface") {
-      const result = this.tsParseDeclaration(this.startNode(), this.state.value, true);
-      if (result) return result;
-    }
-
-    return super.parseExportDefaultExpression();
-  }
-
-  parseStatementContent(context, topLevel) {
-    if (this.state.type === _types.types._const) {
-      const ahead = this.lookahead();
-
-      if (ahead.type === _types.types.name && ahead.value === "enum") {
-        const node = this.startNode();
-        this.expect(_types.types._const);
-        this.expectContextual("enum");
-        return this.tsParseEnumDeclaration(node, true);
-      }
-    }
-
-    return super.parseStatementContent(context, topLevel);
-  }
-
-  parseAccessModifier() {
-    return this.tsParseModifier(["public", "protected", "private"]);
-  }
-
-  parseClassMember(classBody, member, state) {
-    this.tsParseModifiers(member, ["declare"]);
-    const accessibility = this.parseAccessModifier();
-    if (accessibility) member.accessibility = accessibility;
-    this.tsParseModifiers(member, ["declare"]);
-
-    const callParseClassMember = () => {
-      super.parseClassMember(classBody, member, state);
-    };
-
-    if (member.declare) {
-      this.tsInDeclareContext(callParseClassMember);
-    } else {
-      callParseClassMember();
-    }
-  }
-
-  parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
-    this.tsParseModifiers(member, ["abstract", "readonly", "declare"]);
-    const idx = this.tsTryParseIndexSignature(member);
-
-    if (idx) {
-      classBody.body.push(idx);
-
-      if (member.abstract) {
-        this.raise(member.start, TSErrors.IndexSignatureHasAbstract);
-      }
-
-      if (isStatic) {
-        this.raise(member.start, TSErrors.IndexSignatureHasStatic);
-      }
-
-      if (member.accessibility) {
-        this.raise(member.start, TSErrors.IndexSignatureHasAccessibility, member.accessibility);
-      }
-
-      if (member.declare) {
-        this.raise(member.start, TSErrors.IndexSignatureHasDeclare);
-      }
-
-      return;
-    }
-
-    super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
-  }
-
-  parsePostMemberNameModifiers(methodOrProp) {
-    const optional = this.eat(_types.types.question);
-    if (optional) methodOrProp.optional = true;
-
-    if (methodOrProp.readonly && this.match(_types.types.parenL)) {
-      this.raise(methodOrProp.start, TSErrors.ClassMethodHasReadonly);
-    }
-
-    if (methodOrProp.declare && this.match(_types.types.parenL)) {
-      this.raise(methodOrProp.start, TSErrors.ClassMethodHasDeclare);
-    }
-  }
-
-  parseExpressionStatement(node, expr) {
-    const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr) : undefined;
-    return decl || super.parseExpressionStatement(node, expr);
-  }
-
-  shouldParseExportDeclaration() {
-    if (this.tsIsDeclarationStart()) return true;
-    return super.shouldParseExportDeclaration();
-  }
-
-  parseConditional(expr, startPos, startLoc, refNeedsArrowPos) {
-    if (!refNeedsArrowPos || !this.match(_types.types.question)) {
-      return super.parseConditional(expr, startPos, startLoc, refNeedsArrowPos);
-    }
-
-    const result = this.tryParse(() => super.parseConditional(expr, startPos, startLoc));
-
-    if (!result.node) {
-      refNeedsArrowPos.start = result.error.pos || this.state.start;
-      return expr;
-    }
-
-    if (result.error) this.state = result.failState;
-    return result.node;
-  }
-
-  parseParenItem(node, startPos, startLoc) {
-    node = super.parseParenItem(node, startPos, startLoc);
-
-    if (this.eat(_types.types.question)) {
-      node.optional = true;
-      this.resetEndLocation(node);
-    }
-
-    if (this.match(_types.types.colon)) {
-      const typeCastNode = this.startNodeAt(startPos, startLoc);
-      typeCastNode.expression = node;
-      typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
-      return this.finishNode(typeCastNode, "TSTypeCastExpression");
-    }
-
-    return node;
-  }
-
-  parseExportDeclaration(node) {
-    const startPos = this.state.start;
-    const startLoc = this.state.startLoc;
-    const isDeclare = this.eatContextual("declare");
-    let declaration;
-
-    if (this.match(_types.types.name)) {
-      declaration = this.tsTryParseExportDeclaration();
-    }
-
-    if (!declaration) {
-      declaration = super.parseExportDeclaration(node);
-    }
-
-    if (declaration && (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare)) {
-      node.exportKind = "type";
-    }
-
-    if (declaration && isDeclare) {
-      this.resetStartLocation(declaration, startPos, startLoc);
-      declaration.declare = true;
-    }
-
-    return declaration;
-  }
-
-  parseClassId(node, isStatement, optionalId) {
-    if ((!isStatement || optionalId) && this.isContextual("implements")) {
-      return;
-    }
-
-    super.parseClassId(node, isStatement, optionalId, node.declare ? _scopeflags.BIND_TS_AMBIENT : _scopeflags.BIND_CLASS);
-    const typeParameters = this.tsTryParseTypeParameters();
-    if (typeParameters) node.typeParameters = typeParameters;
-  }
-
-  parseClassPropertyAnnotation(node) {
-    if (!node.optional && this.eat(_types.types.bang)) {
-      node.definite = true;
-    }
-
-    const type = this.tsTryParseTypeAnnotation();
-    if (type) node.typeAnnotation = type;
-  }
-
-  parseClassProperty(node) {
-    this.parseClassPropertyAnnotation(node);
-
-    if (this.state.isDeclareContext && this.match(_types.types.eq)) {
-      this.raise(this.state.start, TSErrors.DeclareClassFieldHasInitializer);
-    }
-
-    return super.parseClassProperty(node);
-  }
-
-  parseClassPrivateProperty(node) {
-    if (node.abstract) {
-      this.raise(node.start, TSErrors.PrivateElementHasAbstract);
-    }
-
-    if (node.accessibility) {
-      this.raise(node.start, TSErrors.PrivateElementHasAccessibility, node.accessibility);
-    }
-
-    this.parseClassPropertyAnnotation(node);
-    return super.parseClassPrivateProperty(node);
-  }
-
-  pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-    const typeParameters = this.tsTryParseTypeParameters();
-
-    if (typeParameters && isConstructor) {
-      this.raise(typeParameters.start, TSErrors.ConstructorHasTypeParameters);
-    }
-
-    if (typeParameters) method.typeParameters = typeParameters;
-    super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
-  }
-
-  pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
-    const typeParameters = this.tsTryParseTypeParameters();
-    if (typeParameters) method.typeParameters = typeParameters;
-    super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
-  }
-
-  parseClassSuper(node) {
-    super.parseClassSuper(node);
-
-    if (node.superClass && this.isRelational("<")) {
-      node.superTypeParameters = this.tsParseTypeArguments();
-    }
-
-    if (this.eatContextual("implements")) {
-      node.implements = this.tsParseHeritageClause("implements");
-    }
-  }
-
-  parseObjPropValue(prop, ...args) {
-    const typeParameters = this.tsTryParseTypeParameters();
-    if (typeParameters) prop.typeParameters = typeParameters;
-    super.parseObjPropValue(prop, ...args);
-  }
-
-  parseFunctionParams(node, allowModifiers) {
-    const typeParameters = this.tsTryParseTypeParameters();
-    if (typeParameters) node.typeParameters = typeParameters;
-    super.parseFunctionParams(node, allowModifiers);
-  }
-
-  parseVarId(decl, kind) {
-    super.parseVarId(decl, kind);
-
-    if (decl.id.type === "Identifier" && this.eat(_types.types.bang)) {
-      decl.definite = true;
-    }
-
-    const type = this.tsTryParseTypeAnnotation();
-
-    if (type) {
-      decl.id.typeAnnotation = type;
-      this.resetEndLocation(decl.id);
-    }
-  }
-
-  parseAsyncArrowFromCallExpression(node, call) {
-    if (this.match(_types.types.colon)) {
-      node.returnType = this.tsParseTypeAnnotation();
-    }
-
-    return super.parseAsyncArrowFromCallExpression(node, call);
-  }
-
-  parseMaybeAssign(...args) {
-    let state;
-    let jsx;
-    let typeCast;
-
-    if (this.match(_types.types.jsxTagStart)) {
-      state = this.state.clone();
-      jsx = this.tryParse(() => super.parseMaybeAssign(...args), state);
-      if (!jsx.error) return jsx.node;
-      const {
-        context
-      } = this.state;
-
-      if (context[context.length - 1] === _context.types.j_oTag) {
-        context.length -= 2;
-      } else if (context[context.length - 1] === _context.types.j_expr) {
-        context.length -= 1;
-      }
-    }
-
-    if (!jsx?.error && !this.isRelational("<")) {
-      return super.parseMaybeAssign(...args);
-    }
-
-    let typeParameters;
-    state = state || this.state.clone();
-    const arrow = this.tryParse(abort => {
-      typeParameters = this.tsParseTypeParameters();
-      const expr = super.parseMaybeAssign(...args);
-
-      if (expr.type !== "ArrowFunctionExpression" || expr.extra && expr.extra.parenthesized) {
-        abort();
-      }
-
-      if (typeParameters?.params.length !== 0) {
-        this.resetStartLocationFromNode(expr, typeParameters);
-      }
-
-      expr.typeParameters = typeParameters;
-      return expr;
-    }, state);
-    if (!arrow.error && !arrow.aborted) return arrow.node;
-
-    if (!jsx) {
-      assert(!this.hasPlugin("jsx"));
-      typeCast = this.tryParse(() => super.parseMaybeAssign(...args), state);
-      if (!typeCast.error) return typeCast.node;
-    }
-
-    if (jsx?.node) {
-      this.state = jsx.failState;
-      return jsx.node;
-    }
-
-    if (arrow.node) {
-      this.state = arrow.failState;
-      return arrow.node;
-    }
-
-    if (typeCast?.node) {
-      this.state = typeCast.failState;
-      return typeCast.node;
-    }
-
-    if (jsx?.thrown) throw jsx.error;
-    if (arrow.thrown) throw arrow.error;
-    if (typeCast?.thrown) throw typeCast.error;
-    throw jsx?.error || arrow.error || typeCast?.error;
-  }
-
-  parseMaybeUnary(refExpressionErrors) {
-    if (!this.hasPlugin("jsx") && this.isRelational("<")) {
-      return this.tsParseTypeAssertion();
-    } else {
-      return super.parseMaybeUnary(refExpressionErrors);
-    }
-  }
-
-  parseArrow(node) {
-    if (this.match(_types.types.colon)) {
-      const result = this.tryParse(abort => {
-        const returnType = this.tsParseTypeOrTypePredicateAnnotation(_types.types.colon);
-        if (this.canInsertSemicolon() || !this.match(_types.types.arrow)) abort();
-        return returnType;
-      });
-      if (result.aborted) return;
-
-      if (!result.thrown) {
-        if (result.error) this.state = result.failState;
-        node.returnType = result.node;
-      }
-    }
-
-    return super.parseArrow(node);
-  }
-
-  parseAssignableListItemTypes(param) {
-    if (this.eat(_types.types.question)) {
-      if (param.type !== "Identifier" && !this.state.isDeclareContext && !this.state.inType) {
-        this.raise(param.start, TSErrors.PatternIsOptional);
-      }
-
-      param.optional = true;
-    }
-
-    const type = this.tsTryParseTypeAnnotation();
-    if (type) param.typeAnnotation = type;
-    this.resetEndLocation(param);
-    return param;
-  }
-
-  toAssignable(node) {
-    switch (node.type) {
-      case "TSTypeCastExpression":
-        return super.toAssignable(this.typeCastToParameter(node));
-
-      case "TSParameterProperty":
-        return super.toAssignable(node);
-
-      case "TSAsExpression":
-      case "TSNonNullExpression":
-      case "TSTypeAssertion":
-        node.expression = this.toAssignable(node.expression);
-        return node;
-
-      default:
-        return super.toAssignable(node);
-    }
-  }
-
-  checkLVal(expr, bindingType = _scopeflags.BIND_NONE, checkClashes, contextDescription) {
-    switch (expr.type) {
-      case "TSTypeCastExpression":
-        return;
-
-      case "TSParameterProperty":
-        this.checkLVal(expr.parameter, bindingType, checkClashes, "parameter property");
-        return;
-
-      case "TSAsExpression":
-      case "TSNonNullExpression":
-      case "TSTypeAssertion":
-        this.checkLVal(expr.expression, bindingType, checkClashes, contextDescription);
-        return;
-
-      default:
-        super.checkLVal(expr, bindingType, checkClashes, contextDescription);
-        return;
-    }
-  }
-
-  parseBindingAtom() {
-    switch (this.state.type) {
-      case _types.types._this:
-        return this.parseIdentifier(true);
-
-      default:
-        return super.parseBindingAtom();
-    }
-  }
-
-  parseMaybeDecoratorArguments(expr) {
-    if (this.isRelational("<")) {
-      const typeArguments = this.tsParseTypeArguments();
-
-      if (this.match(_types.types.parenL)) {
-        const call = super.parseMaybeDecoratorArguments(expr);
-        call.typeParameters = typeArguments;
-        return call;
-      }
-
-      this.unexpected(this.state.start, _types.types.parenL);
-    }
-
-    return super.parseMaybeDecoratorArguments(expr);
-  }
-
-  isClassMethod() {
-    return this.isRelational("<") || super.isClassMethod();
-  }
-
-  isClassProperty() {
-    return this.match(_types.types.bang) || this.match(_types.types.colon) || super.isClassProperty();
-  }
-
-  parseMaybeDefault(...args) {
-    const node = super.parseMaybeDefault(...args);
-
-    if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
-      this.raise(node.typeAnnotation.start, TSErrors.TypeAnnotationAfterAssign);
-    }
-
-    return node;
-  }
-
-  getTokenFromCode(code) {
-    if (this.state.inType && (code === 62 || code === 60)) {
-      return this.finishOp(_types.types.relational, 1);
-    } else {
-      return super.getTokenFromCode(code);
-    }
-  }
-
-  reScan_lt_gt() {
-    if (this.match(_types.types.relational)) {
-      const code = this.input.charCodeAt(this.state.start);
-
-      if (code === 60 || code === 62) {
-        this.state.pos -= 1;
-        this.readToken_lt_gt(code);
-      }
-    }
-  }
-
-  toAssignableList(exprList) {
-    for (let i = 0; i < exprList.length; i++) {
-      const expr = exprList[i];
-      if (!expr) continue;
-
-      switch (expr.type) {
-        case "TSTypeCastExpression":
-          exprList[i] = this.typeCastToParameter(expr);
-          break;
-
-        case "TSAsExpression":
-        case "TSTypeAssertion":
-          if (!this.state.maybeInArrowParameters) {
-            exprList[i] = this.typeCastToParameter(expr);
-          } else {
-            this.raise(expr.start, TSErrors.UnexpectedTypeCastInParameter);
-          }
-
-          break;
-      }
-    }
-
-    return super.toAssignableList(...arguments);
-  }
-
-  typeCastToParameter(node) {
-    node.expression.typeAnnotation = node.typeAnnotation;
-    this.resetEndLocation(node.expression, node.typeAnnotation.end, node.typeAnnotation.loc.end);
-    return node.expression;
-  }
-
-  shouldParseArrow() {
-    return this.match(_types.types.colon) || super.shouldParseArrow();
-  }
-
-  shouldParseAsyncArrow() {
-    return this.match(_types.types.colon) || super.shouldParseAsyncArrow();
-  }
-
-  canHaveLeadingDecorator() {
-    return super.canHaveLeadingDecorator() || this.isAbstractClass();
-  }
-
-  jsxParseOpeningElementAfterName(node) {
-    if (this.isRelational("<")) {
-      const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArguments());
-      if (typeArguments) node.typeParameters = typeArguments;
-    }
-
-    return super.jsxParseOpeningElementAfterName(node);
-  }
-
-  getGetterSetterExpectedParamCount(method) {
-    const baseCount = super.getGetterSetterExpectedParamCount(method);
-    const firstParam = method.params[0];
-    const hasContextParam = firstParam && firstParam.type === "Identifier" && firstParam.name === "this";
-    return hasContextParam ? baseCount + 1 : baseCount;
-  }
-
-  parseCatchClauseParam() {
-    const param = super.parseCatchClauseParam();
-    const type = this.tsTryParseTypeAnnotation();
-
-    if (type) {
-      param.typeAnnotation = type;
-      this.resetEndLocation(param);
-    }
-
-    return param;
-  }
-
-  tsInDeclareContext(cb) {
-    const oldIsDeclareContext = this.state.isDeclareContext;
-    this.state.isDeclareContext = true;
-
-    try {
-      return cb();
-    } finally {
-      this.state.isDeclareContext = oldIsDeclareContext;
-    }
-  }
-
-};
-
-exports.default = _default;

node_modules/@babel/parser/lib/plugins/typescript/scope.js

@@ -1,94 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _scope = _interopRequireWildcard(require("../../util/scope"));
-
-var _scopeflags = require("../../util/scopeflags");
-
-var N = _interopRequireWildcard(require("../../types"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-class TypeScriptScope extends _scope.Scope {
-  constructor(...args) {
-    super(...args);
-    this.types = [];
-    this.enums = [];
-    this.constEnums = [];
-    this.classes = [];
-    this.exportOnlyBindings = [];
-  }
-
-}
-
-class TypeScriptScopeHandler extends _scope.default {
-  createScope(flags) {
-    return new TypeScriptScope(flags);
-  }
-
-  declareName(name, bindingType, pos) {
-    const scope = this.currentScope();
-
-    if (bindingType & _scopeflags.BIND_FLAGS_TS_EXPORT_ONLY) {
-      this.maybeExportDefined(scope, name);
-      scope.exportOnlyBindings.push(name);
-      return;
-    }
-
-    super.declareName(...arguments);
-
-    if (bindingType & _scopeflags.BIND_KIND_TYPE) {
-      if (!(bindingType & _scopeflags.BIND_KIND_VALUE)) {
-        this.checkRedeclarationInScope(scope, name, bindingType, pos);
-        this.maybeExportDefined(scope, name);
-      }
-
-      scope.types.push(name);
-    }
-
-    if (bindingType & _scopeflags.BIND_FLAGS_TS_ENUM) scope.enums.push(name);
-    if (bindingType & _scopeflags.BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.push(name);
-    if (bindingType & _scopeflags.BIND_FLAGS_CLASS) scope.classes.push(name);
-  }
-
-  isRedeclaredInScope(scope, name, bindingType) {
-    if (scope.enums.indexOf(name) > -1) {
-      if (bindingType & _scopeflags.BIND_FLAGS_TS_ENUM) {
-        const isConst = !!(bindingType & _scopeflags.BIND_FLAGS_TS_CONST_ENUM);
-        const wasConst = scope.constEnums.indexOf(name) > -1;
-        return isConst !== wasConst;
-      }
-
-      return true;
-    }
-
-    if (bindingType & _scopeflags.BIND_FLAGS_CLASS && scope.classes.indexOf(name) > -1) {
-      if (scope.lexical.indexOf(name) > -1) {
-        return !!(bindingType & _scopeflags.BIND_KIND_VALUE);
-      } else {
-        return false;
-      }
-    }
-
-    if (bindingType & _scopeflags.BIND_KIND_TYPE && scope.types.indexOf(name) > -1) {
-      return true;
-    }
-
-    return super.isRedeclaredInScope(...arguments);
-  }
-
-  checkLocalExport(id) {
-    if (this.scopeStack[0].types.indexOf(id.name) === -1 && this.scopeStack[0].exportOnlyBindings.indexOf(id.name) === -1) {
-      super.checkLocalExport(id);
-    }
-  }
-
-}
-
-exports.default = TypeScriptScopeHandler;

node_modules/@babel/parser/lib/plugins/v8intrinsic.js

@@ -1,43 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _types = require("../tokenizer/types");
-
-var N = _interopRequireWildcard(require("../types"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-var _default = superClass => class extends superClass {
-  parseV8Intrinsic() {
-    if (this.match(_types.types.modulo)) {
-      const v8IntrinsicStart = this.state.start;
-      const node = this.startNode();
-      this.eat(_types.types.modulo);
-
-      if (this.match(_types.types.name)) {
-        const name = this.parseIdentifierName(this.state.start);
-        const identifier = this.createIdentifier(node, name);
-        identifier.type = "V8IntrinsicIdentifier";
-
-        if (this.match(_types.types.parenL)) {
-          return identifier;
-        }
-      }
-
-      this.unexpected(v8IntrinsicStart);
-    }
-  }
-
-  parseExprAtom() {
-    return this.parseV8Intrinsic() || super.parseExprAtom(...arguments);
-  }
-
-};
-
-exports.default = _default;

node_modules/@babel/parser/lib/tokenizer/context.js

@@ -1,110 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.types = exports.TokContext = void 0;
-
-var _types = require("./types");
-
-class TokContext {
-  constructor(token, isExpr, preserveSpace, override) {
-    this.token = void 0;
-    this.isExpr = void 0;
-    this.preserveSpace = void 0;
-    this.override = void 0;
-    this.token = token;
-    this.isExpr = !!isExpr;
-    this.preserveSpace = !!preserveSpace;
-    this.override = override;
-  }
-
-}
-
-exports.TokContext = TokContext;
-const types = {
-  braceStatement: new TokContext("{", false),
-  braceExpression: new TokContext("{", true),
-  recordExpression: new TokContext("#{", true),
-  templateQuasi: new TokContext("${", false),
-  parenStatement: new TokContext("(", false),
-  parenExpression: new TokContext("(", true),
-  template: new TokContext("`", true, true, p => p.readTmplToken()),
-  functionExpression: new TokContext("function", true),
-  functionStatement: new TokContext("function", false)
-};
-exports.types = types;
-
-_types.types.parenR.updateContext = _types.types.braceR.updateContext = function () {
-  if (this.state.context.length === 1) {
-    this.state.exprAllowed = true;
-    return;
-  }
-
-  let out = this.state.context.pop();
-
-  if (out === types.braceStatement && this.curContext().token === "function") {
-    out = this.state.context.pop();
-  }
-
-  this.state.exprAllowed = !out.isExpr;
-};
-
-_types.types.name.updateContext = function (prevType) {
-  let allowed = false;
-
-  if (prevType !== _types.types.dot) {
-    if (this.state.value === "of" && !this.state.exprAllowed && prevType !== _types.types._function && prevType !== _types.types._class) {
-      allowed = true;
-    }
-  }
-
-  this.state.exprAllowed = allowed;
-
-  if (this.state.isIterator) {
-    this.state.isIterator = false;
-  }
-};
-
-_types.types.braceL.updateContext = function (prevType) {
-  this.state.context.push(this.braceIsBlock(prevType) ? types.braceStatement : types.braceExpression);
-  this.state.exprAllowed = true;
-};
-
-_types.types.dollarBraceL.updateContext = function () {
-  this.state.context.push(types.templateQuasi);
-  this.state.exprAllowed = true;
-};
-
-_types.types.parenL.updateContext = function (prevType) {
-  const statementParens = prevType === _types.types._if || prevType === _types.types._for || prevType === _types.types._with || prevType === _types.types._while;
-  this.state.context.push(statementParens ? types.parenStatement : types.parenExpression);
-  this.state.exprAllowed = true;
-};
-
-_types.types.incDec.updateContext = function () {};
-
-_types.types._function.updateContext = _types.types._class.updateContext = function (prevType) {
-  if (prevType.beforeExpr && prevType !== _types.types.semi && prevType !== _types.types._else && !(prevType === _types.types._return && this.hasPrecedingLineBreak()) && !((prevType === _types.types.colon || prevType === _types.types.braceL) && this.curContext() === types.b_stat)) {
-    this.state.context.push(types.functionExpression);
-  } else {
-    this.state.context.push(types.functionStatement);
-  }
-
-  this.state.exprAllowed = false;
-};
-
-_types.types.backQuote.updateContext = function () {
-  if (this.curContext() === types.template) {
-    this.state.context.pop();
-  } else {
-    this.state.context.push(types.template);
-  }
-
-  this.state.exprAllowed = false;
-};
-
-_types.types.braceHashL.updateContext = function () {
-  this.state.context.push(types.recordExpression);
-  this.state.exprAllowed = true;
-};

node_modules/@babel/parser/lib/tokenizer/index.js

@@ -1,1302 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.Token = void 0;
-
-var N = _interopRequireWildcard(require("../types"));
-
-var _identifier = require("../util/identifier");
-
-var _types2 = require("./types");
-
-var _context = require("./context");
-
-var _error = _interopRequireWildcard(require("../parser/error"));
-
-var _location = require("../util/location");
-
-var _whitespace = require("../util/whitespace");
-
-var _state = _interopRequireDefault(require("./state"));
-
-var _isDigit = function isDigit(code) {
-  return code >= 48 && code <= 57;
-};
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const VALID_REGEX_FLAGS = new Set(["g", "m", "s", "i", "y", "u"]);
-const forbiddenNumericSeparatorSiblings = {
-  decBinOct: [46, 66, 69, 79, 95, 98, 101, 111],
-  hex: [46, 88, 95, 120]
-};
-const allowedNumericSeparatorSiblings = {};
-allowedNumericSeparatorSiblings.bin = [48, 49];
-allowedNumericSeparatorSiblings.oct = [...allowedNumericSeparatorSiblings.bin, 50, 51, 52, 53, 54, 55];
-allowedNumericSeparatorSiblings.dec = [...allowedNumericSeparatorSiblings.oct, 56, 57];
-allowedNumericSeparatorSiblings.hex = [...allowedNumericSeparatorSiblings.dec, 65, 66, 67, 68, 69, 70, 97, 98, 99, 100, 101, 102];
-
-class Token {
-  constructor(state) {
-    this.type = state.type;
-    this.value = state.value;
-    this.start = state.start;
-    this.end = state.end;
-    this.loc = new _location.SourceLocation(state.startLoc, state.endLoc);
-  }
-
-}
-
-exports.Token = Token;
-
-class Tokenizer extends _error.default {
-  constructor(options, input) {
-    super();
-    this.isLookahead = void 0;
-    this.tokens = [];
-    this.state = new _state.default();
-    this.state.init(options);
-    this.input = input;
-    this.length = input.length;
-    this.isLookahead = false;
-  }
-
-  pushToken(token) {
-    this.tokens.length = this.state.tokensLength;
-    this.tokens.push(token);
-    ++this.state.tokensLength;
-  }
-
-  next() {
-    if (!this.isLookahead) {
-      this.checkKeywordEscapes();
-
-      if (this.options.tokens) {
-        this.pushToken(new Token(this.state));
-      }
-    }
-
-    this.state.lastTokEnd = this.state.end;
-    this.state.lastTokStart = this.state.start;
-    this.state.lastTokEndLoc = this.state.endLoc;
-    this.state.lastTokStartLoc = this.state.startLoc;
-    this.nextToken();
-  }
-
-  eat(type) {
-    if (this.match(type)) {
-      this.next();
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  match(type) {
-    return this.state.type === type;
-  }
-
-  lookahead() {
-    const old = this.state;
-    this.state = old.clone(true);
-    this.isLookahead = true;
-    this.next();
-    this.isLookahead = false;
-    const curr = this.state;
-    this.state = old;
-    return curr;
-  }
-
-  nextTokenStart() {
-    return this.nextTokenStartSince(this.state.pos);
-  }
-
-  nextTokenStartSince(pos) {
-    _whitespace.skipWhiteSpace.lastIndex = pos;
-
-    const skip = _whitespace.skipWhiteSpace.exec(this.input);
-
-    return pos + skip[0].length;
-  }
-
-  lookaheadCharCode() {
-    return this.input.charCodeAt(this.nextTokenStart());
-  }
-
-  setStrict(strict) {
-    this.state.strict = strict;
-    if (!this.match(_types2.types.num) && !this.match(_types2.types.string)) return;
-    this.state.pos = this.state.start;
-
-    while (this.state.pos < this.state.lineStart) {
-      this.state.lineStart = this.input.lastIndexOf("\n", this.state.lineStart - 2) + 1;
-      --this.state.curLine;
-    }
-
-    this.nextToken();
-  }
-
-  curContext() {
-    return this.state.context[this.state.context.length - 1];
-  }
-
-  nextToken() {
-    const curContext = this.curContext();
-    if (!curContext?.preserveSpace) this.skipSpace();
-    this.state.octalPositions = [];
-    this.state.start = this.state.pos;
-    this.state.startLoc = this.state.curPosition();
-
-    if (this.state.pos >= this.length) {
-      this.finishToken(_types2.types.eof);
-      return;
-    }
-
-    const override = curContext?.override;
-
-    if (override) {
-      override(this);
-    } else {
-      this.getTokenFromCode(this.input.codePointAt(this.state.pos));
-    }
-  }
-
-  pushComment(block, text, start, end, startLoc, endLoc) {
-    const comment = {
-      type: block ? "CommentBlock" : "CommentLine",
-      value: text,
-      start: start,
-      end: end,
-      loc: new _location.SourceLocation(startLoc, endLoc)
-    };
-    if (this.options.tokens) this.pushToken(comment);
-    this.state.comments.push(comment);
-    this.addComment(comment);
-  }
-
-  skipBlockComment() {
-    const startLoc = this.state.curPosition();
-    const start = this.state.pos;
-    const end = this.input.indexOf("*/", this.state.pos + 2);
-    if (end === -1) throw this.raise(start, _error.Errors.UnterminatedComment);
-    this.state.pos = end + 2;
-    _whitespace.lineBreakG.lastIndex = start;
-    let match;
-
-    while ((match = _whitespace.lineBreakG.exec(this.input)) && match.index < this.state.pos) {
-      ++this.state.curLine;
-      this.state.lineStart = match.index + match[0].length;
-    }
-
-    if (this.isLookahead) return;
-    this.pushComment(true, this.input.slice(start + 2, end), start, this.state.pos, startLoc, this.state.curPosition());
-  }
-
-  skipLineComment(startSkip) {
-    const start = this.state.pos;
-    const startLoc = this.state.curPosition();
-    let ch = this.input.charCodeAt(this.state.pos += startSkip);
-
-    if (this.state.pos < this.length) {
-      while (!(0, _whitespace.isNewLine)(ch) && ++this.state.pos < this.length) {
-        ch = this.input.charCodeAt(this.state.pos);
-      }
-    }
-
-    if (this.isLookahead) return;
-    this.pushComment(false, this.input.slice(start + startSkip, this.state.pos), start, this.state.pos, startLoc, this.state.curPosition());
-  }
-
-  skipSpace() {
-    loop: while (this.state.pos < this.length) {
-      const ch = this.input.charCodeAt(this.state.pos);
-
-      switch (ch) {
-        case 32:
-        case 160:
-        case 9:
-          ++this.state.pos;
-          break;
-
-        case 13:
-          if (this.input.charCodeAt(this.state.pos + 1) === 10) {
-            ++this.state.pos;
-          }
-
-        case 10:
-        case 8232:
-        case 8233:
-          ++this.state.pos;
-          ++this.state.curLine;
-          this.state.lineStart = this.state.pos;
-          break;
-
-        case 47:
-          switch (this.input.charCodeAt(this.state.pos + 1)) {
-            case 42:
-              this.skipBlockComment();
-              break;
-
-            case 47:
-              this.skipLineComment(2);
-              break;
-
-            default:
-              break loop;
-          }
-
-          break;
-
-        default:
-          if ((0, _whitespace.isWhitespace)(ch)) {
-            ++this.state.pos;
-          } else {
-            break loop;
-          }
-
-      }
-    }
-  }
-
-  finishToken(type, val) {
-    this.state.end = this.state.pos;
-    this.state.endLoc = this.state.curPosition();
-    const prevType = this.state.type;
-    this.state.type = type;
-    this.state.value = val;
-    if (!this.isLookahead) this.updateContext(prevType);
-  }
-
-  readToken_numberSign() {
-    if (this.state.pos === 0 && this.readToken_interpreter()) {
-      return;
-    }
-
-    const nextPos = this.state.pos + 1;
-    const next = this.input.charCodeAt(nextPos);
-
-    if (next >= 48 && next <= 57) {
-      throw this.raise(this.state.pos, _error.Errors.UnexpectedDigitAfterHash);
-    }
-
-    if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
-      this.expectPlugin("recordAndTuple");
-
-      if (this.getPluginOption("recordAndTuple", "syntaxType") !== "hash") {
-        throw this.raise(this.state.pos, next === 123 ? _error.Errors.RecordExpressionHashIncorrectStartSyntaxType : _error.Errors.TupleExpressionHashIncorrectStartSyntaxType);
-      }
-
-      if (next === 123) {
-        this.finishToken(_types2.types.braceHashL);
-      } else {
-        this.finishToken(_types2.types.bracketHashL);
-      }
-
-      this.state.pos += 2;
-    } else {
-      this.finishOp(_types2.types.hash, 1);
-    }
-  }
-
-  readToken_dot() {
-    const next = this.input.charCodeAt(this.state.pos + 1);
-
-    if (next >= 48 && next <= 57) {
-      this.readNumber(true);
-      return;
-    }
-
-    if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {
-      this.state.pos += 3;
-      this.finishToken(_types2.types.ellipsis);
-    } else {
-      ++this.state.pos;
-      this.finishToken(_types2.types.dot);
-    }
-  }
-
-  readToken_slash() {
-    if (this.state.exprAllowed && !this.state.inType) {
-      ++this.state.pos;
-      this.readRegexp();
-      return;
-    }
-
-    const next = this.input.charCodeAt(this.state.pos + 1);
-
-    if (next === 61) {
-      this.finishOp(_types2.types.assign, 2);
-    } else {
-      this.finishOp(_types2.types.slash, 1);
-    }
-  }
-
-  readToken_interpreter() {
-    if (this.state.pos !== 0 || this.length < 2) return false;
-    let ch = this.input.charCodeAt(this.state.pos + 1);
-    if (ch !== 33) return false;
-    const start = this.state.pos;
-    this.state.pos += 1;
-
-    while (!(0, _whitespace.isNewLine)(ch) && ++this.state.pos < this.length) {
-      ch = this.input.charCodeAt(this.state.pos);
-    }
-
-    const value = this.input.slice(start + 2, this.state.pos);
-    this.finishToken(_types2.types.interpreterDirective, value);
-    return true;
-  }
-
-  readToken_mult_modulo(code) {
-    let type = code === 42 ? _types2.types.star : _types2.types.modulo;
-    let width = 1;
-    let next = this.input.charCodeAt(this.state.pos + 1);
-    const exprAllowed = this.state.exprAllowed;
-
-    if (code === 42 && next === 42) {
-      width++;
-      next = this.input.charCodeAt(this.state.pos + 2);
-      type = _types2.types.exponent;
-    }
-
-    if (next === 61 && !exprAllowed) {
-      width++;
-      type = _types2.types.assign;
-    }
-
-    this.finishOp(type, width);
-  }
-
-  readToken_pipe_amp(code) {
-    const next = this.input.charCodeAt(this.state.pos + 1);
-
-    if (next === code) {
-      if (this.input.charCodeAt(this.state.pos + 2) === 61) {
-        this.finishOp(_types2.types.assign, 3);
-      } else {
-        this.finishOp(code === 124 ? _types2.types.logicalOR : _types2.types.logicalAND, 2);
-      }
-
-      return;
-    }
-
-    if (code === 124) {
-      if (next === 62) {
-        this.finishOp(_types2.types.pipeline, 2);
-        return;
-      }
-
-      if (this.hasPlugin("recordAndTuple") && next === 125) {
-        if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-          throw this.raise(this.state.pos, _error.Errors.RecordExpressionBarIncorrectEndSyntaxType);
-        }
-
-        this.finishOp(_types2.types.braceBarR, 2);
-        return;
-      }
-
-      if (this.hasPlugin("recordAndTuple") && next === 93) {
-        if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-          throw this.raise(this.state.pos, _error.Errors.TupleExpressionBarIncorrectEndSyntaxType);
-        }
-
-        this.finishOp(_types2.types.bracketBarR, 2);
-        return;
-      }
-    }
-
-    if (next === 61) {
-      this.finishOp(_types2.types.assign, 2);
-      return;
-    }
-
-    this.finishOp(code === 124 ? _types2.types.bitwiseOR : _types2.types.bitwiseAND, 1);
-  }
-
-  readToken_caret() {
-    const next = this.input.charCodeAt(this.state.pos + 1);
-
-    if (next === 61) {
-      this.finishOp(_types2.types.assign, 2);
-    } else {
-      this.finishOp(_types2.types.bitwiseXOR, 1);
-    }
-  }
-
-  readToken_plus_min(code) {
-    const next = this.input.charCodeAt(this.state.pos + 1);
-
-    if (next === code) {
-      if (next === 45 && !this.inModule && this.input.charCodeAt(this.state.pos + 2) === 62 && (this.state.lastTokEnd === 0 || this.hasPrecedingLineBreak())) {
-        this.skipLineComment(3);
-        this.skipSpace();
-        this.nextToken();
-        return;
-      }
-
-      this.finishOp(_types2.types.incDec, 2);
-      return;
-    }
-
-    if (next === 61) {
-      this.finishOp(_types2.types.assign, 2);
-    } else {
-      this.finishOp(_types2.types.plusMin, 1);
-    }
-  }
-
-  readToken_lt_gt(code) {
-    const next = this.input.charCodeAt(this.state.pos + 1);
-    let size = 1;
-
-    if (next === code) {
-      size = code === 62 && this.input.charCodeAt(this.state.pos + 2) === 62 ? 3 : 2;
-
-      if (this.input.charCodeAt(this.state.pos + size) === 61) {
-        this.finishOp(_types2.types.assign, size + 1);
-        return;
-      }
-
-      this.finishOp(_types2.types.bitShift, size);
-      return;
-    }
-
-    if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.state.pos + 2) === 45 && this.input.charCodeAt(this.state.pos + 3) === 45) {
-      this.skipLineComment(4);
-      this.skipSpace();
-      this.nextToken();
-      return;
-    }
-
-    if (next === 61) {
-      size = 2;
-    }
-
-    this.finishOp(_types2.types.relational, size);
-  }
-
-  readToken_eq_excl(code) {
-    const next = this.input.charCodeAt(this.state.pos + 1);
-
-    if (next === 61) {
-      this.finishOp(_types2.types.equality, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);
-      return;
-    }
-
-    if (code === 61 && next === 62) {
-      this.state.pos += 2;
-      this.finishToken(_types2.types.arrow);
-      return;
-    }
-
-    this.finishOp(code === 61 ? _types2.types.eq : _types2.types.bang, 1);
-  }
-
-  readToken_question() {
-    const next = this.input.charCodeAt(this.state.pos + 1);
-    const next2 = this.input.charCodeAt(this.state.pos + 2);
-
-    if (next === 63) {
-      if (next2 === 61) {
-        this.finishOp(_types2.types.assign, 3);
-      } else {
-        this.finishOp(_types2.types.nullishCoalescing, 2);
-      }
-    } else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {
-      this.state.pos += 2;
-      this.finishToken(_types2.types.questionDot);
-    } else {
-      ++this.state.pos;
-      this.finishToken(_types2.types.question);
-    }
-  }
-
-  getTokenFromCode(code) {
-    switch (code) {
-      case 46:
-        this.readToken_dot();
-        return;
-
-      case 40:
-        ++this.state.pos;
-        this.finishToken(_types2.types.parenL);
-        return;
-
-      case 41:
-        ++this.state.pos;
-        this.finishToken(_types2.types.parenR);
-        return;
-
-      case 59:
-        ++this.state.pos;
-        this.finishToken(_types2.types.semi);
-        return;
-
-      case 44:
-        ++this.state.pos;
-        this.finishToken(_types2.types.comma);
-        return;
-
-      case 91:
-        if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
-          if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-            throw this.raise(this.state.pos, _error.Errors.TupleExpressionBarIncorrectStartSyntaxType);
-          }
-
-          this.finishToken(_types2.types.bracketBarL);
-          this.state.pos += 2;
-        } else {
-          ++this.state.pos;
-          this.finishToken(_types2.types.bracketL);
-        }
-
-        return;
-
-      case 93:
-        ++this.state.pos;
-        this.finishToken(_types2.types.bracketR);
-        return;
-
-      case 123:
-        if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
-          if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
-            throw this.raise(this.state.pos, _error.Errors.RecordExpressionBarIncorrectStartSyntaxType);
-          }
-
-          this.finishToken(_types2.types.braceBarL);
-          this.state.pos += 2;
-        } else {
-          ++this.state.pos;
-          this.finishToken(_types2.types.braceL);
-        }
-
-        return;
-
-      case 125:
-        ++this.state.pos;
-        this.finishToken(_types2.types.braceR);
-        return;
-
-      case 58:
-        if (this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58) {
-          this.finishOp(_types2.types.doubleColon, 2);
-        } else {
-          ++this.state.pos;
-          this.finishToken(_types2.types.colon);
-        }
-
-        return;
-
-      case 63:
-        this.readToken_question();
-        return;
-
-      case 96:
-        ++this.state.pos;
-        this.finishToken(_types2.types.backQuote);
-        return;
-
-      case 48:
-        {
-          const next = this.input.charCodeAt(this.state.pos + 1);
-
-          if (next === 120 || next === 88) {
-            this.readRadixNumber(16);
-            return;
-          }
-
-          if (next === 111 || next === 79) {
-            this.readRadixNumber(8);
-            return;
-          }
-
-          if (next === 98 || next === 66) {
-            this.readRadixNumber(2);
-            return;
-          }
-        }
-
-      case 49:
-      case 50:
-      case 51:
-      case 52:
-      case 53:
-      case 54:
-      case 55:
-      case 56:
-      case 57:
-        this.readNumber(false);
-        return;
-
-      case 34:
-      case 39:
-        this.readString(code);
-        return;
-
-      case 47:
-        this.readToken_slash();
-        return;
-
-      case 37:
-      case 42:
-        this.readToken_mult_modulo(code);
-        return;
-
-      case 124:
-      case 38:
-        this.readToken_pipe_amp(code);
-        return;
-
-      case 94:
-        this.readToken_caret();
-        return;
-
-      case 43:
-      case 45:
-        this.readToken_plus_min(code);
-        return;
-
-      case 60:
-      case 62:
-        this.readToken_lt_gt(code);
-        return;
-
-      case 61:
-      case 33:
-        this.readToken_eq_excl(code);
-        return;
-
-      case 126:
-        this.finishOp(_types2.types.tilde, 1);
-        return;
-
-      case 64:
-        ++this.state.pos;
-        this.finishToken(_types2.types.at);
-        return;
-
-      case 35:
-        this.readToken_numberSign();
-        return;
-
-      case 92:
-        this.readWord();
-        return;
-
-      default:
-        if ((0, _identifier.isIdentifierStart)(code)) {
-          this.readWord();
-          return;
-        }
-
-    }
-
-    throw this.raise(this.state.pos, _error.Errors.InvalidOrUnexpectedToken, String.fromCodePoint(code));
-  }
-
-  finishOp(type, size) {
-    const str = this.input.slice(this.state.pos, this.state.pos + size);
-    this.state.pos += size;
-    this.finishToken(type, str);
-  }
-
-  readRegexp() {
-    const start = this.state.pos;
-    let escaped, inClass;
-
-    for (;;) {
-      if (this.state.pos >= this.length) {
-        throw this.raise(start, _error.Errors.UnterminatedRegExp);
-      }
-
-      const ch = this.input.charAt(this.state.pos);
-
-      if (_whitespace.lineBreak.test(ch)) {
-        throw this.raise(start, _error.Errors.UnterminatedRegExp);
-      }
-
-      if (escaped) {
-        escaped = false;
-      } else {
-        if (ch === "[") {
-          inClass = true;
-        } else if (ch === "]" && inClass) {
-          inClass = false;
-        } else if (ch === "/" && !inClass) {
-          break;
-        }
-
-        escaped = ch === "\\";
-      }
-
-      ++this.state.pos;
-    }
-
-    const content = this.input.slice(start, this.state.pos);
-    ++this.state.pos;
-    let mods = "";
-
-    while (this.state.pos < this.length) {
-      const char = this.input[this.state.pos];
-      const charCode = this.input.codePointAt(this.state.pos);
-
-      if (VALID_REGEX_FLAGS.has(char)) {
-        if (mods.indexOf(char) > -1) {
-          this.raise(this.state.pos + 1, _error.Errors.DuplicateRegExpFlags);
-        }
-      } else if ((0, _identifier.isIdentifierChar)(charCode) || charCode === 92) {
-        this.raise(this.state.pos + 1, _error.Errors.MalformedRegExpFlags);
-      } else {
-        break;
-      }
-
-      ++this.state.pos;
-      mods += char;
-    }
-
-    this.finishToken(_types2.types.regexp, {
-      pattern: content,
-      flags: mods
-    });
-  }
-
-  readInt(radix, len, forceLen, allowNumSeparator = true) {
-    const start = this.state.pos;
-    const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
-    const allowedSiblings = radix === 16 ? allowedNumericSeparatorSiblings.hex : radix === 10 ? allowedNumericSeparatorSiblings.dec : radix === 8 ? allowedNumericSeparatorSiblings.oct : allowedNumericSeparatorSiblings.bin;
-    let invalid = false;
-    let total = 0;
-
-    for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-      const code = this.input.charCodeAt(this.state.pos);
-      let val;
-
-      if (code === 95) {
-        const prev = this.input.charCodeAt(this.state.pos - 1);
-        const next = this.input.charCodeAt(this.state.pos + 1);
-
-        if (allowedSiblings.indexOf(next) === -1) {
-          this.raise(this.state.pos, _error.Errors.UnexpectedNumericSeparator);
-        } else if (forbiddenSiblings.indexOf(prev) > -1 || forbiddenSiblings.indexOf(next) > -1 || Number.isNaN(next)) {
-          this.raise(this.state.pos, _error.Errors.UnexpectedNumericSeparator);
-        }
-
-        if (!allowNumSeparator) {
-          this.raise(this.state.pos, _error.Errors.NumericSeparatorInEscapeSequence);
-        }
-
-        ++this.state.pos;
-        continue;
-      }
-
-      if (code >= 97) {
-        val = code - 97 + 10;
-      } else if (code >= 65) {
-        val = code - 65 + 10;
-      } else if (_isDigit(code)) {
-        val = code - 48;
-      } else {
-        val = Infinity;
-      }
-
-      if (val >= radix) {
-        if (this.options.errorRecovery && val <= 9) {
-          val = 0;
-          this.raise(this.state.start + i + 2, _error.Errors.InvalidDigit, radix);
-        } else if (forceLen) {
-          val = 0;
-          invalid = true;
-        } else {
-          break;
-        }
-      }
-
-      ++this.state.pos;
-      total = total * radix + val;
-    }
-
-    if (this.state.pos === start || len != null && this.state.pos - start !== len || invalid) {
-      return null;
-    }
-
-    return total;
-  }
-
-  readRadixNumber(radix) {
-    const start = this.state.pos;
-    let isBigInt = false;
-    this.state.pos += 2;
-    const val = this.readInt(radix);
-
-    if (val == null) {
-      this.raise(this.state.start + 2, _error.Errors.InvalidDigit, radix);
-    }
-
-    const next = this.input.charCodeAt(this.state.pos);
-
-    if (next === 110) {
-      ++this.state.pos;
-      isBigInt = true;
-    } else if (next === 109) {
-      throw this.raise(start, _error.Errors.InvalidDecimal);
-    }
-
-    if ((0, _identifier.isIdentifierStart)(this.input.codePointAt(this.state.pos))) {
-      throw this.raise(this.state.pos, _error.Errors.NumberIdentifier);
-    }
-
-    if (isBigInt) {
-      const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
-      this.finishToken(_types2.types.bigint, str);
-      return;
-    }
-
-    this.finishToken(_types2.types.num, val);
-  }
-
-  readNumber(startsWithDot) {
-    const start = this.state.pos;
-    let isFloat = false;
-    let isBigInt = false;
-    let isDecimal = false;
-    let hasExponent = false;
-    let isOctal = false;
-
-    if (!startsWithDot && this.readInt(10) === null) {
-      this.raise(start, _error.Errors.InvalidNumber);
-    }
-
-    const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;
-
-    if (hasLeadingZero) {
-      const integer = this.input.slice(start, this.state.pos);
-
-      if (this.state.strict) {
-        this.raise(start, _error.Errors.StrictOctalLiteral);
-      } else {
-        const underscorePos = integer.indexOf("_");
-
-        if (underscorePos > 0) {
-          this.raise(underscorePos + start, _error.Errors.ZeroDigitNumericSeparator);
-        }
-      }
-
-      isOctal = hasLeadingZero && !/[89]/.test(integer);
-    }
-
-    let next = this.input.charCodeAt(this.state.pos);
-
-    if (next === 46 && !isOctal) {
-      ++this.state.pos;
-      this.readInt(10);
-      isFloat = true;
-      next = this.input.charCodeAt(this.state.pos);
-    }
-
-    if ((next === 69 || next === 101) && !isOctal) {
-      next = this.input.charCodeAt(++this.state.pos);
-
-      if (next === 43 || next === 45) {
-        ++this.state.pos;
-      }
-
-      if (this.readInt(10) === null) {
-        this.raise(start, _error.Errors.InvalidOrMissingExponent);
-      }
-
-      isFloat = true;
-      hasExponent = true;
-      next = this.input.charCodeAt(this.state.pos);
-    }
-
-    if (next === 110) {
-      if (isFloat || hasLeadingZero) {
-        this.raise(start, _error.Errors.InvalidBigIntLiteral);
-      }
-
-      ++this.state.pos;
-      isBigInt = true;
-    }
-
-    if (next === 109) {
-      this.expectPlugin("decimal", this.state.pos);
-
-      if (hasExponent || hasLeadingZero) {
-        this.raise(start, _error.Errors.InvalidDecimal);
-      }
-
-      ++this.state.pos;
-      isDecimal = true;
-    }
-
-    if ((0, _identifier.isIdentifierStart)(this.input.codePointAt(this.state.pos))) {
-      throw this.raise(this.state.pos, _error.Errors.NumberIdentifier);
-    }
-
-    const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
-
-    if (isBigInt) {
-      this.finishToken(_types2.types.bigint, str);
-      return;
-    }
-
-    if (isDecimal) {
-      this.finishToken(_types2.types.decimal, str);
-      return;
-    }
-
-    const val = isOctal ? parseInt(str, 8) : parseFloat(str);
-    this.finishToken(_types2.types.num, val);
-  }
-
-  readCodePoint(throwOnInvalid) {
-    const ch = this.input.charCodeAt(this.state.pos);
-    let code;
-
-    if (ch === 123) {
-      const codePos = ++this.state.pos;
-      code = this.readHexChar(this.input.indexOf("}", this.state.pos) - this.state.pos, true, throwOnInvalid);
-      ++this.state.pos;
-
-      if (code !== null && code > 0x10ffff) {
-        if (throwOnInvalid) {
-          this.raise(codePos, _error.Errors.InvalidCodePoint);
-        } else {
-          return null;
-        }
-      }
-    } else {
-      code = this.readHexChar(4, false, throwOnInvalid);
-    }
-
-    return code;
-  }
-
-  readString(quote) {
-    let out = "",
-        chunkStart = ++this.state.pos;
-
-    for (;;) {
-      if (this.state.pos >= this.length) {
-        throw this.raise(this.state.start, _error.Errors.UnterminatedString);
-      }
-
-      const ch = this.input.charCodeAt(this.state.pos);
-      if (ch === quote) break;
-
-      if (ch === 92) {
-        out += this.input.slice(chunkStart, this.state.pos);
-        out += this.readEscapedChar(false);
-        chunkStart = this.state.pos;
-      } else if (ch === 8232 || ch === 8233) {
-        ++this.state.pos;
-        ++this.state.curLine;
-        this.state.lineStart = this.state.pos;
-      } else if ((0, _whitespace.isNewLine)(ch)) {
-        throw this.raise(this.state.start, _error.Errors.UnterminatedString);
-      } else {
-        ++this.state.pos;
-      }
-    }
-
-    out += this.input.slice(chunkStart, this.state.pos++);
-    this.finishToken(_types2.types.string, out);
-  }
-
-  readTmplToken() {
-    let out = "",
-        chunkStart = this.state.pos,
-        containsInvalid = false;
-
-    for (;;) {
-      if (this.state.pos >= this.length) {
-        throw this.raise(this.state.start, _error.Errors.UnterminatedTemplate);
-      }
-
-      const ch = this.input.charCodeAt(this.state.pos);
-
-      if (ch === 96 || ch === 36 && this.input.charCodeAt(this.state.pos + 1) === 123) {
-        if (this.state.pos === this.state.start && this.match(_types2.types.template)) {
-          if (ch === 36) {
-            this.state.pos += 2;
-            this.finishToken(_types2.types.dollarBraceL);
-            return;
-          } else {
-            ++this.state.pos;
-            this.finishToken(_types2.types.backQuote);
-            return;
-          }
-        }
-
-        out += this.input.slice(chunkStart, this.state.pos);
-        this.finishToken(_types2.types.template, containsInvalid ? null : out);
-        return;
-      }
-
-      if (ch === 92) {
-        out += this.input.slice(chunkStart, this.state.pos);
-        const escaped = this.readEscapedChar(true);
-
-        if (escaped === null) {
-          containsInvalid = true;
-        } else {
-          out += escaped;
-        }
-
-        chunkStart = this.state.pos;
-      } else if ((0, _whitespace.isNewLine)(ch)) {
-        out += this.input.slice(chunkStart, this.state.pos);
-        ++this.state.pos;
-
-        switch (ch) {
-          case 13:
-            if (this.input.charCodeAt(this.state.pos) === 10) {
-              ++this.state.pos;
-            }
-
-          case 10:
-            out += "\n";
-            break;
-
-          default:
-            out += String.fromCharCode(ch);
-            break;
-        }
-
-        ++this.state.curLine;
-        this.state.lineStart = this.state.pos;
-        chunkStart = this.state.pos;
-      } else {
-        ++this.state.pos;
-      }
-    }
-  }
-
-  readEscapedChar(inTemplate) {
-    const throwOnInvalid = !inTemplate;
-    const ch = this.input.charCodeAt(++this.state.pos);
-    ++this.state.pos;
-
-    switch (ch) {
-      case 110:
-        return "\n";
-
-      case 114:
-        return "\r";
-
-      case 120:
-        {
-          const code = this.readHexChar(2, false, throwOnInvalid);
-          return code === null ? null : String.fromCharCode(code);
-        }
-
-      case 117:
-        {
-          const code = this.readCodePoint(throwOnInvalid);
-          return code === null ? null : String.fromCodePoint(code);
-        }
-
-      case 116:
-        return "\t";
-
-      case 98:
-        return "\b";
-
-      case 118:
-        return "\u000b";
-
-      case 102:
-        return "\f";
-
-      case 13:
-        if (this.input.charCodeAt(this.state.pos) === 10) {
-          ++this.state.pos;
-        }
-
-      case 10:
-        this.state.lineStart = this.state.pos;
-        ++this.state.curLine;
-
-      case 8232:
-      case 8233:
-        return "";
-
-      case 56:
-      case 57:
-        if (inTemplate) {
-          return null;
-        } else if (this.state.strict) {
-          this.raise(this.state.pos - 1, _error.Errors.StrictNumericEscape);
-        }
-
-      default:
-        if (ch >= 48 && ch <= 55) {
-          const codePos = this.state.pos - 1;
-          const match = this.input.substr(this.state.pos - 1, 3).match(/^[0-7]+/);
-          let octalStr = match[0];
-          let octal = parseInt(octalStr, 8);
-
-          if (octal > 255) {
-            octalStr = octalStr.slice(0, -1);
-            octal = parseInt(octalStr, 8);
-          }
-
-          this.state.pos += octalStr.length - 1;
-          const next = this.input.charCodeAt(this.state.pos);
-
-          if (octalStr !== "0" || next === 56 || next === 57) {
-            if (inTemplate) {
-              return null;
-            } else if (this.state.strict) {
-              this.raise(codePos, _error.Errors.StrictNumericEscape);
-            } else {
-              this.state.octalPositions.push(codePos);
-            }
-          }
-
-          return String.fromCharCode(octal);
-        }
-
-        return String.fromCharCode(ch);
-    }
-  }
-
-  readHexChar(len, forceLen, throwOnInvalid) {
-    const codePos = this.state.pos;
-    const n = this.readInt(16, len, forceLen, false);
-
-    if (n === null) {
-      if (throwOnInvalid) {
-        this.raise(codePos, _error.Errors.InvalidEscapeSequence);
-      } else {
-        this.state.pos = codePos - 1;
-      }
-    }
-
-    return n;
-  }
-
-  readWord1() {
-    let word = "";
-    this.state.containsEsc = false;
-    const start = this.state.pos;
-    let chunkStart = this.state.pos;
-
-    while (this.state.pos < this.length) {
-      const ch = this.input.codePointAt(this.state.pos);
-
-      if ((0, _identifier.isIdentifierChar)(ch)) {
-        this.state.pos += ch <= 0xffff ? 1 : 2;
-      } else if (this.state.isIterator && ch === 64) {
-        ++this.state.pos;
-      } else if (ch === 92) {
-        this.state.containsEsc = true;
-        word += this.input.slice(chunkStart, this.state.pos);
-        const escStart = this.state.pos;
-        const identifierCheck = this.state.pos === start ? _identifier.isIdentifierStart : _identifier.isIdentifierChar;
-
-        if (this.input.charCodeAt(++this.state.pos) !== 117) {
-          this.raise(this.state.pos, _error.Errors.MissingUnicodeEscape);
-          continue;
-        }
-
-        ++this.state.pos;
-        const esc = this.readCodePoint(true);
-
-        if (esc !== null) {
-          if (!identifierCheck(esc)) {
-            this.raise(escStart, _error.Errors.EscapedCharNotAnIdentifier);
-          }
-
-          word += String.fromCodePoint(esc);
-        }
-
-        chunkStart = this.state.pos;
-      } else {
-        break;
-      }
-    }
-
-    return word + this.input.slice(chunkStart, this.state.pos);
-  }
-
-  isIterator(word) {
-    return word === "@@iterator" || word === "@@asyncIterator";
-  }
-
-  readWord() {
-    const word = this.readWord1();
-
-    const type = _types2.keywords.get(word) || _types2.types.name;
-
-    if (this.state.isIterator && (!this.isIterator(word) || !this.state.inType)) {
-      this.raise(this.state.pos, _error.Errors.InvalidIdentifier, word);
-    }
-
-    this.finishToken(type, word);
-  }
-
-  checkKeywordEscapes() {
-    const kw = this.state.type.keyword;
-
-    if (kw && this.state.containsEsc) {
-      this.raise(this.state.start, _error.Errors.InvalidEscapedReservedWord, kw);
-    }
-  }
-
-  braceIsBlock(prevType) {
-    const parent = this.curContext();
-
-    if (parent === _context.types.functionExpression || parent === _context.types.functionStatement) {
-      return true;
-    }
-
-    if (prevType === _types2.types.colon && (parent === _context.types.braceStatement || parent === _context.types.braceExpression)) {
-      return !parent.isExpr;
-    }
-
-    if (prevType === _types2.types._return || prevType === _types2.types.name && this.state.exprAllowed) {
-      return this.hasPrecedingLineBreak();
-    }
-
-    if (prevType === _types2.types._else || prevType === _types2.types.semi || prevType === _types2.types.eof || prevType === _types2.types.parenR || prevType === _types2.types.arrow) {
-      return true;
-    }
-
-    if (prevType === _types2.types.braceL) {
-      return parent === _context.types.braceStatement;
-    }
-
-    if (prevType === _types2.types._var || prevType === _types2.types._const || prevType === _types2.types.name) {
-      return false;
-    }
-
-    if (prevType === _types2.types.relational) {
-      return true;
-    }
-
-    return !this.state.exprAllowed;
-  }
-
-  updateContext(prevType) {
-    const type = this.state.type;
-    let update;
-
-    if (type.keyword && (prevType === _types2.types.dot || prevType === _types2.types.questionDot)) {
-      this.state.exprAllowed = false;
-    } else if (update = type.updateContext) {
-      update.call(this, prevType);
-    } else {
-      this.state.exprAllowed = type.beforeExpr;
-    }
-  }
-
-}
-
-exports.default = Tokenizer;

node_modules/@babel/parser/lib/tokenizer/state.js

@@ -1,99 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var N = _interopRequireWildcard(require("../types"));
-
-var _location = require("../util/location");
-
-var _context = require("./context");
-
-var _types2 = require("./types");
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-class State {
-  constructor() {
-    this.strict = void 0;
-    this.curLine = void 0;
-    this.startLoc = void 0;
-    this.endLoc = void 0;
-    this.errors = [];
-    this.potentialArrowAt = -1;
-    this.noArrowAt = [];
-    this.noArrowParamsConversionAt = [];
-    this.maybeInArrowParameters = false;
-    this.inPipeline = false;
-    this.inType = false;
-    this.noAnonFunctionType = false;
-    this.inPropertyName = false;
-    this.hasFlowComment = false;
-    this.isIterator = false;
-    this.isDeclareContext = false;
-    this.topicContext = {
-      maxNumOfResolvableTopics: 0,
-      maxTopicIndex: null
-    };
-    this.soloAwait = false;
-    this.inFSharpPipelineDirectBody = false;
-    this.labels = [];
-    this.decoratorStack = [[]];
-    this.comments = [];
-    this.trailingComments = [];
-    this.leadingComments = [];
-    this.commentStack = [];
-    this.commentPreviousNode = null;
-    this.pos = 0;
-    this.lineStart = 0;
-    this.type = _types2.types.eof;
-    this.value = null;
-    this.start = 0;
-    this.end = 0;
-    this.lastTokEndLoc = null;
-    this.lastTokStartLoc = null;
-    this.lastTokStart = 0;
-    this.lastTokEnd = 0;
-    this.context = [_context.types.braceStatement];
-    this.exprAllowed = true;
-    this.containsEsc = false;
-    this.octalPositions = [];
-    this.exportedIdentifiers = [];
-    this.tokensLength = 0;
-  }
-
-  init(options) {
-    this.strict = options.strictMode === false ? false : options.sourceType === "module";
-    this.curLine = options.startLine;
-    this.startLoc = this.endLoc = this.curPosition();
-  }
-
-  curPosition() {
-    return new _location.Position(this.curLine, this.pos - this.lineStart);
-  }
-
-  clone(skipArrays) {
-    const state = new State();
-    const keys = Object.keys(this);
-
-    for (let i = 0, length = keys.length; i < length; i++) {
-      const key = keys[i];
-      let val = this[key];
-
-      if (!skipArrays && Array.isArray(val)) {
-        val = val.slice();
-      }
-
-      state[key] = val;
-    }
-
-    return state;
-  }
-
-}
-
-exports.default = State;

node_modules/@babel/parser/lib/tokenizer/types.js

@@ -1,296 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.types = exports.keywords = exports.TokenType = void 0;
-const beforeExpr = true;
-const startsExpr = true;
-const isLoop = true;
-const isAssign = true;
-const prefix = true;
-const postfix = true;
-
-class TokenType {
-  constructor(label, conf = {}) {
-    this.label = void 0;
-    this.keyword = void 0;
-    this.beforeExpr = void 0;
-    this.startsExpr = void 0;
-    this.rightAssociative = void 0;
-    this.isLoop = void 0;
-    this.isAssign = void 0;
-    this.prefix = void 0;
-    this.postfix = void 0;
-    this.binop = void 0;
-    this.updateContext = void 0;
-    this.label = label;
-    this.keyword = conf.keyword;
-    this.beforeExpr = !!conf.beforeExpr;
-    this.startsExpr = !!conf.startsExpr;
-    this.rightAssociative = !!conf.rightAssociative;
-    this.isLoop = !!conf.isLoop;
-    this.isAssign = !!conf.isAssign;
-    this.prefix = !!conf.prefix;
-    this.postfix = !!conf.postfix;
-    this.binop = conf.binop != null ? conf.binop : null;
-    this.updateContext = null;
-  }
-
-}
-
-exports.TokenType = TokenType;
-const keywords = new Map();
-exports.keywords = keywords;
-
-function createKeyword(name, options = {}) {
-  options.keyword = name;
-  const token = new TokenType(name, options);
-  keywords.set(name, token);
-  return token;
-}
-
-function createBinop(name, binop) {
-  return new TokenType(name, {
-    beforeExpr,
-    binop
-  });
-}
-
-const types = {
-  num: new TokenType("num", {
-    startsExpr
-  }),
-  bigint: new TokenType("bigint", {
-    startsExpr
-  }),
-  decimal: new TokenType("decimal", {
-    startsExpr
-  }),
-  regexp: new TokenType("regexp", {
-    startsExpr
-  }),
-  string: new TokenType("string", {
-    startsExpr
-  }),
-  name: new TokenType("name", {
-    startsExpr
-  }),
-  eof: new TokenType("eof"),
-  bracketL: new TokenType("[", {
-    beforeExpr,
-    startsExpr
-  }),
-  bracketHashL: new TokenType("#[", {
-    beforeExpr,
-    startsExpr
-  }),
-  bracketBarL: new TokenType("[|", {
-    beforeExpr,
-    startsExpr
-  }),
-  bracketR: new TokenType("]"),
-  bracketBarR: new TokenType("|]"),
-  braceL: new TokenType("{", {
-    beforeExpr,
-    startsExpr
-  }),
-  braceBarL: new TokenType("{|", {
-    beforeExpr,
-    startsExpr
-  }),
-  braceHashL: new TokenType("#{", {
-    beforeExpr,
-    startsExpr
-  }),
-  braceR: new TokenType("}"),
-  braceBarR: new TokenType("|}"),
-  parenL: new TokenType("(", {
-    beforeExpr,
-    startsExpr
-  }),
-  parenR: new TokenType(")"),
-  comma: new TokenType(",", {
-    beforeExpr
-  }),
-  semi: new TokenType(";", {
-    beforeExpr
-  }),
-  colon: new TokenType(":", {
-    beforeExpr
-  }),
-  doubleColon: new TokenType("::", {
-    beforeExpr
-  }),
-  dot: new TokenType("."),
-  question: new TokenType("?", {
-    beforeExpr
-  }),
-  questionDot: new TokenType("?."),
-  arrow: new TokenType("=>", {
-    beforeExpr
-  }),
-  template: new TokenType("template"),
-  ellipsis: new TokenType("...", {
-    beforeExpr
-  }),
-  backQuote: new TokenType("`", {
-    startsExpr
-  }),
-  dollarBraceL: new TokenType("${", {
-    beforeExpr,
-    startsExpr
-  }),
-  at: new TokenType("@"),
-  hash: new TokenType("#", {
-    startsExpr
-  }),
-  interpreterDirective: new TokenType("#!..."),
-  eq: new TokenType("=", {
-    beforeExpr,
-    isAssign
-  }),
-  assign: new TokenType("_=", {
-    beforeExpr,
-    isAssign
-  }),
-  incDec: new TokenType("++/--", {
-    prefix,
-    postfix,
-    startsExpr
-  }),
-  bang: new TokenType("!", {
-    beforeExpr,
-    prefix,
-    startsExpr
-  }),
-  tilde: new TokenType("~", {
-    beforeExpr,
-    prefix,
-    startsExpr
-  }),
-  pipeline: createBinop("|>", 0),
-  nullishCoalescing: createBinop("??", 1),
-  logicalOR: createBinop("||", 1),
-  logicalAND: createBinop("&&", 2),
-  bitwiseOR: createBinop("|", 3),
-  bitwiseXOR: createBinop("^", 4),
-  bitwiseAND: createBinop("&", 5),
-  equality: createBinop("==/!=/===/!==", 6),
-  relational: createBinop("</>/<=/>=", 7),
-  bitShift: createBinop("<</>>/>>>", 8),
-  plusMin: new TokenType("+/-", {
-    beforeExpr,
-    binop: 9,
-    prefix,
-    startsExpr
-  }),
-  modulo: new TokenType("%", {
-    beforeExpr,
-    binop: 10,
-    startsExpr
-  }),
-  star: new TokenType("*", {
-    binop: 10
-  }),
-  slash: createBinop("/", 10),
-  exponent: new TokenType("**", {
-    beforeExpr,
-    binop: 11,
-    rightAssociative: true
-  }),
-  _break: createKeyword("break"),
-  _case: createKeyword("case", {
-    beforeExpr
-  }),
-  _catch: createKeyword("catch"),
-  _continue: createKeyword("continue"),
-  _debugger: createKeyword("debugger"),
-  _default: createKeyword("default", {
-    beforeExpr
-  }),
-  _do: createKeyword("do", {
-    isLoop,
-    beforeExpr
-  }),
-  _else: createKeyword("else", {
-    beforeExpr
-  }),
-  _finally: createKeyword("finally"),
-  _for: createKeyword("for", {
-    isLoop
-  }),
-  _function: createKeyword("function", {
-    startsExpr
-  }),
-  _if: createKeyword("if"),
-  _return: createKeyword("return", {
-    beforeExpr
-  }),
-  _switch: createKeyword("switch"),
-  _throw: createKeyword("throw", {
-    beforeExpr,
-    prefix,
-    startsExpr
-  }),
-  _try: createKeyword("try"),
-  _var: createKeyword("var"),
-  _const: createKeyword("const"),
-  _while: createKeyword("while", {
-    isLoop
-  }),
-  _with: createKeyword("with"),
-  _new: createKeyword("new", {
-    beforeExpr,
-    startsExpr
-  }),
-  _this: createKeyword("this", {
-    startsExpr
-  }),
-  _super: createKeyword("super", {
-    startsExpr
-  }),
-  _class: createKeyword("class", {
-    startsExpr
-  }),
-  _extends: createKeyword("extends", {
-    beforeExpr
-  }),
-  _export: createKeyword("export"),
-  _import: createKeyword("import", {
-    startsExpr
-  }),
-  _null: createKeyword("null", {
-    startsExpr
-  }),
-  _true: createKeyword("true", {
-    startsExpr
-  }),
-  _false: createKeyword("false", {
-    startsExpr
-  }),
-  _in: createKeyword("in", {
-    beforeExpr,
-    binop: 7
-  }),
-  _instanceof: createKeyword("instanceof", {
-    beforeExpr,
-    binop: 7
-  }),
-  _typeof: createKeyword("typeof", {
-    beforeExpr,
-    prefix,
-    startsExpr
-  }),
-  _void: createKeyword("void", {
-    beforeExpr,
-    prefix,
-    startsExpr
-  }),
-  _delete: createKeyword("delete", {
-    beforeExpr,
-    prefix,
-    startsExpr
-  })
-};
-exports.types = types;

node_modules/@babel/parser/lib/util/class-scope.js

@@ -1,99 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.ClassScope = void 0;
-
-var _scopeflags = require("./scopeflags");
-
-var _error = require("../parser/error");
-
-class ClassScope {
-  constructor() {
-    this.privateNames = new Set();
-    this.loneAccessors = new Map();
-    this.undefinedPrivateNames = new Map();
-  }
-
-}
-
-exports.ClassScope = ClassScope;
-
-class ClassScopeHandler {
-  constructor(raise) {
-    this.stack = [];
-    this.undefinedPrivateNames = new Map();
-    this.raise = raise;
-  }
-
-  current() {
-    return this.stack[this.stack.length - 1];
-  }
-
-  enter() {
-    this.stack.push(new ClassScope());
-  }
-
-  exit() {
-    const oldClassScope = this.stack.pop();
-    const current = this.current();
-
-    for (let _i = 0, _Array$from = Array.from(oldClassScope.undefinedPrivateNames); _i < _Array$from.length; _i++) {
-      const [name, pos] = _Array$from[_i];
-
-      if (current) {
-        if (!current.undefinedPrivateNames.has(name)) {
-          current.undefinedPrivateNames.set(name, pos);
-        }
-      } else {
-        this.raise(pos, _error.Errors.InvalidPrivateFieldResolution, name);
-      }
-    }
-  }
-
-  declarePrivateName(name, elementType, pos) {
-    const classScope = this.current();
-    let redefined = classScope.privateNames.has(name);
-
-    if (elementType & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR) {
-      const accessor = redefined && classScope.loneAccessors.get(name);
-
-      if (accessor) {
-        const oldStatic = accessor & _scopeflags.CLASS_ELEMENT_FLAG_STATIC;
-        const newStatic = elementType & _scopeflags.CLASS_ELEMENT_FLAG_STATIC;
-        const oldKind = accessor & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR;
-        const newKind = elementType & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR;
-        redefined = oldKind === newKind || oldStatic !== newStatic;
-        if (!redefined) classScope.loneAccessors.delete(name);
-      } else if (!redefined) {
-        classScope.loneAccessors.set(name, elementType);
-      }
-    }
-
-    if (redefined) {
-      this.raise(pos, _error.Errors.PrivateNameRedeclaration, name);
-    }
-
-    classScope.privateNames.add(name);
-    classScope.undefinedPrivateNames.delete(name);
-  }
-
-  usePrivateName(name, pos) {
-    let classScope;
-
-    for (let _i2 = 0, _this$stack = this.stack; _i2 < _this$stack.length; _i2++) {
-      classScope = _this$stack[_i2];
-      if (classScope.privateNames.has(name)) return;
-    }
-
-    if (classScope) {
-      classScope.undefinedPrivateNames.set(name, pos);
-    } else {
-      this.raise(pos, _error.Errors.InvalidPrivateFieldResolution, name);
-    }
-  }
-
-}
-
-exports.default = ClassScopeHandler;

node_modules/@babel/parser/lib/util/expression-scope.js

@@ -1,138 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.newParameterDeclarationScope = newParameterDeclarationScope;
-exports.newArrowHeadScope = newArrowHeadScope;
-exports.newAsyncArrowScope = newAsyncArrowScope;
-exports.newExpressionScope = newExpressionScope;
-exports.default = void 0;
-const kExpression = 0,
-      kMaybeArrowParameterDeclaration = 1,
-      kMaybeAsyncArrowParameterDeclaration = 2,
-      kParameterDeclaration = 3;
-
-class ExpressionScope {
-  constructor(type = kExpression) {
-    this.type = void 0;
-    this.type = type;
-  }
-
-  canBeArrowParameterDeclaration() {
-    return this.type === kMaybeAsyncArrowParameterDeclaration || this.type === kMaybeArrowParameterDeclaration;
-  }
-
-  isCertainlyParameterDeclaration() {
-    return this.type === kParameterDeclaration;
-  }
-
-}
-
-class ArrowHeadParsingScope extends ExpressionScope {
-  constructor(type) {
-    super(type);
-    this.errors = new Map();
-  }
-
-  recordDeclarationError(pos, message) {
-    this.errors.set(pos, message);
-  }
-
-  clearDeclarationError(pos) {
-    this.errors.delete(pos);
-  }
-
-  iterateErrors(iterator) {
-    this.errors.forEach(iterator);
-  }
-
-}
-
-class ExpressionScopeHandler {
-  constructor(raise) {
-    this.stack = [new ExpressionScope()];
-    this.raise = raise;
-  }
-
-  enter(scope) {
-    this.stack.push(scope);
-  }
-
-  exit() {
-    this.stack.pop();
-  }
-
-  recordParameterInitializerError(pos, message) {
-    const {
-      stack
-    } = this;
-    let i = stack.length - 1;
-    let scope = stack[i];
-
-    while (!scope.isCertainlyParameterDeclaration()) {
-      if (scope.canBeArrowParameterDeclaration()) {
-        scope.recordDeclarationError(pos, message);
-      } else {
-        return;
-      }
-
-      scope = stack[--i];
-    }
-
-    this.raise(pos, message);
-  }
-
-  recordAsyncArrowParametersError(pos, message) {
-    const {
-      stack
-    } = this;
-    let i = stack.length - 1;
-    let scope = stack[i];
-
-    while (scope.canBeArrowParameterDeclaration()) {
-      if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
-        scope.recordDeclarationError(pos, message);
-      }
-
-      scope = stack[--i];
-    }
-  }
-
-  validateAsPattern() {
-    const {
-      stack
-    } = this;
-    const currentScope = stack[stack.length - 1];
-    if (!currentScope.canBeArrowParameterDeclaration()) return;
-    currentScope.iterateErrors((message, pos) => {
-      this.raise(pos, message);
-      let i = stack.length - 2;
-      let scope = stack[i];
-
-      while (scope.canBeArrowParameterDeclaration()) {
-        scope.clearDeclarationError(pos);
-        scope = stack[--i];
-      }
-    });
-  }
-
-}
-
-exports.default = ExpressionScopeHandler;
-
-function newParameterDeclarationScope() {
-  return new ExpressionScope(kParameterDeclaration);
-}
-
-function newArrowHeadScope() {
-  return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);
-}
-
-function newAsyncArrowScope() {
-  return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);
-}
-
-function newExpressionScope() {
-  return new ExpressionScope();
-}

node_modules/@babel/parser/lib/util/identifier.js

@@ -1,58 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isIteratorStart = isIteratorStart;
-Object.defineProperty(exports, "isIdentifierStart", {
-  enumerable: true,
-  get: function () {
-    return _helperValidatorIdentifier.isIdentifierStart;
-  }
-});
-Object.defineProperty(exports, "isIdentifierChar", {
-  enumerable: true,
-  get: function () {
-    return _helperValidatorIdentifier.isIdentifierChar;
-  }
-});
-Object.defineProperty(exports, "isReservedWord", {
-  enumerable: true,
-  get: function () {
-    return _helperValidatorIdentifier.isReservedWord;
-  }
-});
-Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
-  enumerable: true,
-  get: function () {
-    return _helperValidatorIdentifier.isStrictBindOnlyReservedWord;
-  }
-});
-Object.defineProperty(exports, "isStrictBindReservedWord", {
-  enumerable: true,
-  get: function () {
-    return _helperValidatorIdentifier.isStrictBindReservedWord;
-  }
-});
-Object.defineProperty(exports, "isStrictReservedWord", {
-  enumerable: true,
-  get: function () {
-    return _helperValidatorIdentifier.isStrictReservedWord;
-  }
-});
-Object.defineProperty(exports, "isKeyword", {
-  enumerable: true,
-  get: function () {
-    return _helperValidatorIdentifier.isKeyword;
-  }
-});
-exports.keywordRelationalOperator = void 0;
-
-var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
-
-const keywordRelationalOperator = /^in(stanceof)?$/;
-exports.keywordRelationalOperator = keywordRelationalOperator;
-
-function isIteratorStart(current, next) {
-  return current === 64 && next === 64;
-}

node_modules/@babel/parser/lib/util/location.js

@@ -1,49 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getLineInfo = getLineInfo;
-exports.SourceLocation = exports.Position = void 0;
-
-var _whitespace = require("./whitespace");
-
-class Position {
-  constructor(line, col) {
-    this.line = void 0;
-    this.column = void 0;
-    this.line = line;
-    this.column = col;
-  }
-
-}
-
-exports.Position = Position;
-
-class SourceLocation {
-  constructor(start, end) {
-    this.start = void 0;
-    this.end = void 0;
-    this.filename = void 0;
-    this.identifierName = void 0;
-    this.start = start;
-    this.end = end;
-  }
-
-}
-
-exports.SourceLocation = SourceLocation;
-
-function getLineInfo(input, offset) {
-  let line = 1;
-  let lineStart = 0;
-  let match;
-  _whitespace.lineBreakG.lastIndex = 0;
-
-  while ((match = _whitespace.lineBreakG.exec(input)) && match.index < offset) {
-    line++;
-    lineStart = _whitespace.lineBreakG.lastIndex;
-  }
-
-  return new Position(line, offset - lineStart);
-}