221 changed files with 50723 additions and 3426 deletions
--- a/.eslintrc.json
+++ b/.eslintrc.json
@ -1,3 +0,0 @@
-{
-  "extends": "next/core-web-vitals"
-}
--- a/.gitattributes
+++ b/.gitattributes
@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto
--- a/.gitignore
+++ b/.gitignore
@ -1,40 +1,2 @@
-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
-
-# dependencies
-/node_modules
-/.pnp
-.pnp.js
-
-# testing
-/coverage
-
-# next.js
-/.next/
-/out/
-
-# production
-/build
-
-# misc
-.DS_Store
-*.pem
-
-# debug
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-.pnpm-debug.log*
-
-# local env files
-.env*.local
-.env
-
-# vercel
-.vercel
-
-# prisma data
-/prisma/migrations
-/prisma/borders.db
-
-/public/images/*
-!/public/images/default.png
+config.json
+node_modules/
--- a/README.md
+++ b/README.md
@ -1,34 +1,21 @@
-This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
+# express-discord-oauth2
+An example on how to use Discord's OAuth2 in Node.js using Express

-## Getting Started
+## Instalation
+1. Install Node.JS [here](https://nodejs.org/)
+2. To install the dependencies, run `npm install`

-First, run the development server:
+## Configuration
+* `port`: The port the website will use
+* `oauth2`:
+  * `redirect_uri`: URI that you'll be redirected after Discord authorization
+  * `client_id`: Your Discord application ID
+  * `client_secret`: Your Discord application secret
+  * `scopes`: Scopes that will be requested
+  
+  Discord's OAuth2 API docs: https://discord.com/developers/docs/topics/oauth2
+  * `cookie`:
+    * `maxAge`: Max age of cookies in milliseconds

-```bash
-npm run dev
-# or
-yarn dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
-
-You can start editing the page by modifying `pages/index.js`. The page auto-updates as you edit the file.
-
-[API routes](https://nextjs.org/docs/api-routes/introduction) can be accessed on [http://localhost:3000/api/hello](http://localhost:3000/api/hello). This endpoint can be edited in `pages/api/hello.js`.
-
-The `pages/api` directory is mapped to `/api/*`. Files in this directory are treated as [API routes](https://nextjs.org/docs/api-routes/introduction) instead of React pages.
-
-## Learn More
-
-To learn more about Next.js, take a look at the following resources:
-
- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
-
-You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!
-
-## Deploy on Vercel
-
-The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
-
-Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
+----------------
+You can read about Discord's OAuth2 API [here](https://discord.dev/topics/oauth2)
--- a/app.js
+++ b/app.js
@ -0,0 +1,123 @@
+const express = require('express')
+const config = require('./config.json')
+const FormData = require('form-data')
+const fetch = require('node-fetch')
+const app = express()
+const ejs = require('ejs')
+app.use(require('express-session')(config.session))
+app.engine('html', ejs.renderFile);
+app.set('view engine', 'ejs')
+
+app.get('/', async (req, res) => {
+    if (req.headers.cookie == undefined) {
+        console.log('No Cookies Found')
+        res.render('index.html', { signedIn: false, tokenRefreshed: 'false', json: {} })
+    }
+    if (req.headers.cookie !== undefined) {
+        console.log('Cookies Found')
+        if (req.headers.cookie.includes('bearer_token') == false) {
+            console.log('No Bearer Token Found')
+            if (req.headers.cookie.includes('refresh_token') == true) {
+                console.log('Refresh Token Found')
+                res.redirect('/login/refresh')
+            }
+            else {
+                console.log('No Refresh Token Found')
+                res.redirect('/login')
+            }
+        }
+        else {
+            console.log('Bearer Token Found')
+            var bearer_token = req.headers.cookie.split('bearer_token=')[1].split(';')[0]
+            var data = await fetch(`https://discord.com/api/users/@me`, {headers: { Authorization: `Bearer ${bearer_token}` } }) // Fetching user data
+            var json = await data.json()
+            if (req.query.tokenrefreshed == 'true') {
+                console.log('Token Refreshed')
+                res.render('index.html', { signedIn: true, tokenRefreshed: true, json })
+            }
+            else {
+                res.render('index.html', { signedIn: true, tokenRefreshed: false, json })
+            }
+        }
+    }
+})
+
+app.get('/login', (req, res) => {
+    res.redirect(`https://discord.com/api/oauth2/authorize` +
+                 `?client_id=${config.oauth2.client_id}` +
+                 `&redirect_uri=${encodeURIComponent(config.oauth2.redirect_uri)}` +
+                 `&response_type=code&scope=${encodeURIComponent(config.oauth2.scopes.join(" "))}`)
+})
+
+app.get('/login/callback', async (req, res) => {
+    const accessCode = req.query.code
+    if (!accessCode) {return res.redirect('/401')}
+
+    // Creating form to make request
+    const data = new FormData()
+    data.append('client_id', config.oauth2.client_id)
+    data.append('client_secret', config.oauth2.client_secret)
+    data.append('grant_type', 'authorization_code')
+    data.append('redirect_uri', config.oauth2.redirect_uri)
+    data.append('scope', 'identify')
+    data.append('code', accessCode)
+
+    // Making request to oauth2/token to get the Bearer token
+    const json = await (await fetch('https://discord.com/api/oauth2/token', {method: 'POST', body: data})).json()
+
+    // Setting cookie with Bearer token
+    res.cookie("bearer_token", json.access_token, { maxAge: json.expires_in * 1000 })
+    res.cookie("refresh_token", json.refresh_token)
+    res.redirect('/') // Redirecting to main page
+})
+
+app.get('/login/refresh', async (req, res) => {
+    const refreshToken = req.headers.cookie.split('refresh_token=')[1].split(';')[0]
+    if (!refreshToken && !undefined) {return res.redirect('/401')}
+    else {console.log('Refresh Token Found')}
+
+    // Creating form to make request
+    const data = new FormData()
+    data.append('client_id', config.oauth2.client_id)
+    data.append('client_secret', config.oauth2.client_secret)
+    data.append('grant_type', 'refresh_token')
+    data.append('refresh_token', refreshToken)
+
+    // Making request to oauth2/token to get the Bearer token
+    const json = await (await fetch('https://discord.com/api/oauth2/token', {method: 'POST', body: data})).json()
+
+    // Setting cookie with Bearer token
+    res.cookie("bearer_token", json.access_token, { maxAge: json.expires_in * 1000 })
+    res.cookie("refresh_token", json.refresh_token)
+    console.log('New Bearer and Refresh tokens set')
+    res.redirect('/?tokenrefreshed=true') // Redirecting to main page
+})
+
+app.get('/logout', (req, res) => {
+    var json = req.headers.cookie.split(';')
+    res.clearCookie("bearer_token", json[0].replace('bearer_token=', ''))
+    res.clearCookie("refresh_token", json[1].replace(' refresh_token=', ''))
+    res.render('logout.html')
+})
+
+app.get('/error', (req, res) => {
+    res.render('error.html')
+})
+
+app.get('/401', (req, res) => {
+    res.render('401.html')
+})
+
+app.get('/404', (req, res) => {
+    res.render('404.html')
+})
+
+app.get('*', (req, res) => {
+    var route = req.url
+    res.render('404.html', { route })
+})
+
+// Starting our application
+app.listen(config.port, () => {
+    console.log(`Listening at http://localhost:${config.port}/`)
+})
--- a/components/alert.js
+++ b/components/alert.js
@ -1,129 +0,0 @@
-import { useState, useEffect, useRef } from "react";
-import { useRouter } from "next/router";
-import PropTypes from "prop-types";
-
-import { alertService, AlertType } from "../services";
-
-export { Alert };
-
-Alert.propTypes = {
-  id: PropTypes.string,
-  fade: PropTypes.bool,
-};
-
-Alert.defaultProps = {
-  id: "default-alert",
-  fade: true,
-};
-
-function Alert({ id, fade }) {
-  const mounted = useRef(false);
-  const router = useRouter();
-  const [alerts, setAlerts] = useState([]);
-
-  useEffect(() => {
-    mounted.current = true;
-
-    // subscribe to new alert notifications
-    const subscription = alertService.onAlert(id).subscribe((alert) => {
-      // clear alerts when an empty alert is received
-      if (!alert.message) {
-        setAlerts((alerts) => {
-          // filter out alerts without 'keepAfterRouteChange' flag
-          const filteredAlerts = alerts.filter((x) => x.keepAfterRouteChange);
-
-          // remove 'keepAfterRouteChange' flag on the rest
-          return omit(filteredAlerts, "keepAfterRouteChange");
-        });
-      } else {
-        // add alert to array with unique id
-        alert.itemId = Math.random();
-        setAlerts((alerts) => [...alerts, alert]);
-
-        // auto close alert if required
-        if (alert.autoClose) {
-          setTimeout(() => removeAlert(alert), 3000);
-        }
-      }
-    });
-
-    // clear alerts on location change
-    const clearAlerts = () => alertService.clear(id);
-    router.events.on("routeChangeStart", clearAlerts);
-
-    // clean up function that runs when the component unmounts
-    return () => {
-      mounted.current = false;
-
-      // unsubscribe to avoid memory leaks
-      subscription.unsubscribe();
-      router.events.off("routeChangeStart", clearAlerts);
-    };
-
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  function omit(arr, key) {
-    return arr.map((obj) => {
-      const { [key]: omitted, ...rest } = obj;
-      return rest;
-    });
-  }
-
-  function removeAlert(alert) {
-    if (!mounted.current) return;
-
-    if (fade) {
-      // fade out alert
-      setAlerts((alerts) =>
-        alerts.map((x) =>
-          x.itemId === alert.itemId ? { ...x, fade: true } : x
-        )
-      );
-
-      // remove alert after faded out
-      setTimeout(() => {
-        setAlerts((alerts) => alerts.filter((x) => x.itemId !== alert.itemId));
-      }, 250);
-    } else {
-      // remove alert
-      setAlerts((alerts) => alerts.filter((x) => x.itemId !== alert.itemId));
-    }
-  }
-
-  function cssClasses(alert) {
-    if (!alert) return;
-
-    const classes = ["alert", "alert-dismissable"];
-
-    const alertTypeClass = {
-      [AlertType.Success]: "alert-success",
-      [AlertType.Error]: "alert-danger",
-      [AlertType.Info]: "alert-info",
-      [AlertType.Warning]: "alert-warning",
-    };
-
-    classes.push(alertTypeClass[alert.type]);
-
-    if (alert.fade) {
-      classes.push("fade");
-    }
-
-    return classes.join(" ");
-  }
-
-  if (!alerts.length) return null;
-
-  return (
-    <div>
-      {alerts.map((alert, index) => (
-        <div key={index} className={cssClasses(alert)}>
-          <a className="close" onClick={() => removeAlert(alert)}>
-            &times;
-          </a>
-          <span>{alert.message}</span>
-        </div>
-      ))}
-    </div>
-  );
-}
--- a/components/borderImage.js
+++ b/components/borderImage.js
@ -1,37 +0,0 @@
-import Image from "next/image";
-import styles from "../styles/Components.module.css";
-
-export default function BorderImage(props) {
-  const { key, border, selected, size, onSelect, customImage } = props;
-
-  const imageSize = size || 128;
-
-  const classNames = [
-    styles.borderKeeper,
-    selected == border.id ? styles.selected : undefined,
-  ].join(" ");
-  return (
-    <div className={classNames} key={key}>
-      <Image
-        className={styles.userImage}
-        src={customImage || "/user.png"}
-        alt="user image"
-        width={imageSize}
-        height={imageSize}
-        onClick={(ev) => {
-          onSelect && onSelect(border.id);
-        }}
-      />
-      <Image
-        className={styles.borderImage}
-        src={`/images/${border.imageName}`}
-        alt={`border with id ${border.id}`}
-        width={Math.floor(imageSize * 1.03125)}
-        height={Math.floor(imageSize * 1.03125)}
-        onClick={(ev) => {
-          onSelect && onSelect(border.id);
-        }}
-      />
-    </div>
-  );
-}
--- a/components/borderPreview.js
+++ b/components/borderPreview.js
@ -1,46 +0,0 @@
-import BorderImage from "./borderImage";
-import styles from "../styles/Components.module.css";
-import { useSession } from "next-auth/react";
-
-export default function Preview(props) {
-  const { data: session } = useSession();
-  const { data, current, selected, apply } = props;
-
-  const currentItem = data?.filter(
-    (item) => parseInt(item.id) === (current != null ? parseInt(current) : 0)
-  )?.[0];
-
-  const selectedItem = data?.filter(
-    (item) => parseInt(item.id) === parseInt(selected)
-  )?.[0];
-
-  // console.log(currentItem, selectedItem, session);
-
-  return (
-    <div className={styles.preview}>
-      current
-      <br />
-      {currentItem && (
-        <BorderImage
-          border={currentItem}
-          selected={-1}
-          size={256}
-          customImage={session?.user?.image}
-        />
-      )}
-      <br />
-      new
-      <br />
-      {selectedItem && (
-        <BorderImage
-          border={selectedItem}
-          selected={-1}
-          size={256}
-          customImage={session?.user?.image}
-        />
-      )}
-      <br />
-      <button onClick={apply}>Apply</button>
-    </div>
-  );
-}
--- a/components/select.js
+++ b/components/select.js
@ -1,47 +0,0 @@
-import BorderImage from "./borderImage";
-import InfiniteScroll from "react-infinite-scroll-component";
-import { useEffect, useState } from "react";
-import styles from "../styles/Components.module.css";
-
-const pageSize = 48;
-
-export default function Select(props) {
-  const { data, total, onSelect, selected = {} } = props;
-  // console.log("data", data, "selected", selected, total);
-
-  const [scrollIndex, setScrollIndex] = useState(36);
-  const [scrollData, setScrollData] = useState([]);
-
-  useEffect(() => {
-    setScrollData(data.slice(0, pageSize - 1));
-  }, [data]);
-
-  const fetchMore = () => {
-    let newData = data.slice(scrollIndex, scrollIndex + pageSize);
-    setScrollData([...scrollData, ...newData]);
-    setScrollIndex(scrollIndex + pageSize);
-  };
-
-  return (
-    <InfiniteScroll
-      dataLength={scrollData?.length || 0}
-      next={fetchMore}
-      hasMore={total > scrollData?.length || 0}
-      height={"75vh"}
-      className={styles.select}
-      loader={<h4>Loading...</h4>}
-      endMessage={<h4>No more borders.</h4>}>
-      {scrollData &&
-        scrollData.map((border, index) => {
-          return (
-            <BorderImage
-              key={border.id}
-              border={border}
-              selected={selected}
-              onSelect={onSelect}
-            />
-          );
-        })}
-    </InfiniteScroll>
-  );
-}
--- a/components/userInfo.js
+++ b/components/userInfo.js
@ -1,24 +0,0 @@
-import { useSession, signIn, signOut } from "next-auth/react";
-import { useEffect, useState } from "react";
-import styles from "../styles/Components.module.css";
-
-export default function UserInfo(props) {
-  const { data: session } = useSession();
-  const { borderData } = props;
-
-  return (
-    <div>
-      <p className={styles.description}>
-        {session
-          ? `Signed in as ${session.user.name} (${borderData?.discordId})`
-          : "Not signed in"}
-        <br />
-        {session ? (
-          <button onClick={() => signOut()}>Sign Out</button>
-        ) : (
-          <button onClick={() => signIn()}>Sign In</button>
-        )}
-      </p>
-    </div>
-  );
-}
--- a/config.json
+++ b/config.json
@ -0,0 +1,19 @@
+{
+  "port": "80",
+  "oauth2": {
+    "redirect_uri": "http://localhost/login/callback",
+    "client_id": "852944034455748628",
+    "client_secret": "AyZ54S2aZuaCrRGAAbqbCBOutEQkkwBt",
+    "scopes": [
+      "identify"
+    ]
+  },
+  "session": {
+    "secret": "PIZZAPASTA",
+    "cookie": {
+      "maxAge": 86400000
+    },
+    "resave": true,
+    "saveUninitialized": false
+  }
+}
--- a/lib/borders.js
+++ b/lib/borders.js
@ -1,96 +0,0 @@
-import { getSession } from "next-auth/react";
-import prisma from "./prisma";
-
-export const getBorderById = async (id) => {
-  return await prisma.borderImage.findFirst({
-    where: {
-      id: parseInt(id),
-    },
-  });
-};
-
-export const countAllBorders = async () => {
-  return await prisma.borderImage.count();
-};
-
-export const getAllBorders = async (limit = undefined, cursor = undefined) => {
-  const sanitizedLimit = parseInt(limit) || undefined;
-  const sanitizedCursor = parseInt(cursor) || 0;
-  return await prisma.borderImage.findMany({
-    take: sanitizedLimit,
-    cursor: {
-      id: sanitizedCursor,
-    },
-    orderBy: {
-      id: "asc",
-    },
-  });
-};
-
-export const getUserBorders = async (req) => {
-  const session = await getSession({ req });
-  if (!session) {
-    return undefined;
-  }
-
-  const accountData = await prisma.account.findFirst({
-    where: {
-      userId: session.user.id,
-    },
-  });
-
-  const userData = await prisma.applicationUserData.findUnique({
-    where: {
-      userId: session.user.id,
-    },
-  });
-
-  if (!!userData) {
-    return userData;
-  }
-
-  const result = await prisma.applicationUserData.create({
-    data: {
-      userId: session.user.id,
-      discordId: accountData.providerAccountId,
-    },
-  });
-  return result;
-};
-
-export const setUserBorder = async (req, borderId) => {
-  const session = await getSession({ req });
-  if (!session) {
-    return undefined;
-  }
-
-  const accountData = await prisma.account.findFirst({
-    where: {
-      userId: session.user.id,
-    },
-  });
-
-  const updateData = await prisma.applicationUserData.upsert({
-    create: {
-      userId: session.user.id,
-      discordId: accountData.providerAccountId,
-      borderId: parseInt(borderId),
-    },
-    update: {
-      borderId: parseInt(borderId),
-    },
-    where: {
-      userId: session.user.id,
-    },
-  });
-  return updateData;
-};
-
-export const getByDiscordId = async (id) => {
-  const userData = await prisma.applicationUserData.findUnique({
-    where: {
-      discordId: id,
-    },
-  });
-  return userData?.borderId ? `${userData.borderId}` : undefined;
-};
--- a/lib/prisma.js
+++ b/lib/prisma.js
@ -1,14 +0,0 @@
-import { PrismaClient } from "@prisma/client";
-
-let prisma;
-
-if (process.env.NODE_ENV === "production") {
-  prisma = new PrismaClient();
-} else {
-  if (!global.prisma) {
-    global.prisma = new PrismaClient();
-  }
-  prisma = global.prisma;
-}
-
-export default prisma;
--- a/next.config.js
+++ b/next.config.js
@ -1,14 +0,0 @@
-/** @type {import('next').NextConfig} */
-
-const webpack = require("webpack");
-const { parsed: environment } = require("dotenv").config();
-
-module.exports = {
-  webpack(config) {
-    config.plugins.push(new webpack.EnvironmentPlugin(environment));
-    return config;
-  },
-  images: {
-    domains: ["localhost", "borders.j4.pm", "cdn.discordapp.com"],
-  },
-};
--- a/node_modules/.bin/ejs
+++ b/node_modules/.bin/ejs
@ -0,0 +1,17 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/ejs@3.1.6/node_modules/ejs/bin/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/ejs@3.1.6/node_modules/ejs/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/ejs@3.1.6/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules:/mnt/d/DISCORD STEAM BORDERS/node_modules:/mnt/d/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/ejs/bin/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/ejs/node_modules"
+else
+  export NODE_PATH="$NODE_PATH:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/ejs@3.1.6/node_modules/ejs/bin/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/ejs@3.1.6/node_modules/ejs/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/ejs@3.1.6/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules:/mnt/d/DISCORD STEAM BORDERS/node_modules:/mnt/d/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/ejs/bin/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/ejs/node_modules"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../ejs/bin/cli.js" "$@"
+else
+  exec node  "$basedir/../ejs/bin/cli.js" "$@"
+fi
--- a/node_modules/.bin/ejs.cmd
+++ b/node_modules/.bin/ejs.cmd
@ -0,0 +1,12 @@
+@SETLOCAL
+@IF NOT DEFINED NODE_PATH (
+  @SET "NODE_PATH=D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\ejs@3.1.6\node_modules\ejs\bin\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\ejs@3.1.6\node_modules\ejs\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\ejs@3.1.6\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules;D:\DISCORD STEAM BORDERS\node_modules;D:\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\ejs\bin\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\ejs\node_modules"
+) ELSE (
+  @SET "NODE_PATH=%NODE_PATH%;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\ejs@3.1.6\node_modules\ejs\bin\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\ejs@3.1.6\node_modules\ejs\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\ejs@3.1.6\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules;D:\DISCORD STEAM BORDERS\node_modules;D:\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\ejs\bin\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\ejs\node_modules"
+)
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\ejs\bin\cli.js" %*
+) ELSE (
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\ejs\bin\cli.js" %*
+)
--- a/node_modules/.bin/ejs.ps1
+++ b/node_modules/.bin/ejs.ps1
@ -0,0 +1,41 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+$pathsep=":"
+$env_node_path=$env:NODE_PATH
+$new_node_path="D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\ejs@3.1.6\node_modules\ejs\bin\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\ejs@3.1.6\node_modules\ejs\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\ejs@3.1.6\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\.pnpm\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules;D:\DISCORD STEAM BORDERS\node_modules;D:\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\ejs\bin\node_modules;D:\DISCORD STEAM BORDERS\discord-oauth2-express\node_modules\ejs\node_modules"
+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"
+  $pathsep=";"
+} else {
+  $new_node_path="/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/ejs@3.1.6/node_modules/ejs/bin/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/ejs@3.1.6/node_modules/ejs/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/ejs@3.1.6/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/.pnpm/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules:/mnt/d/DISCORD STEAM BORDERS/node_modules:/mnt/d/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/ejs/bin/node_modules:/mnt/d/DISCORD STEAM BORDERS/discord-oauth2-express/node_modules/ejs/node_modules"
+}
+if ([string]::IsNullOrEmpty($env_node_path)) {
+  $env:NODE_PATH=$new_node_path
+} else {
+  $env:NODE_PATH="$env_node_path$pathsep$new_node_path"
+}
+
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../ejs/bin/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../ejs/bin/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../ejs/bin/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../ejs/bin/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+$env:NODE_PATH=$env_node_path
+exit $ret
--- a/node_modules/@babel/types/LICENSE
+++ b/node_modules/@babel/types/LICENSE
@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/@babel/types/README.md
+++ b/node_modules/@babel/types/README.md
@ -0,0 +1,19 @@
+# @babel/types
+
+> Babel Types is a Lodash-esque utility library for AST nodes
+
+See our website [@babel/types](https://babeljs.io/docs/en/babel-types) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/types
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/types --dev
+```
--- a/node_modules/@babel/types/lib/asserts/assertNode.js
+++ b/node_modules/@babel/types/lib/asserts/assertNode.js
@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = assertNode;
+
+var _isNode = require("../validators/isNode");
+
+function assertNode(node) {
+  if (!(0, _isNode.default)(node)) {
+    var _node$type;
+
+    const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);
+    throw new TypeError(`Not a valid node of type "${type}"`);
+  }
+}
--- a/node_modules/@babel/types/lib/asserts/generated/index.js
+++ b/node_modules/@babel/types/lib/asserts/generated/index.js
--- a/node_modules/@babel/types/lib/ast-types/generated/index.js
+++ b/node_modules/@babel/types/lib/ast-types/generated/index.js
--- a/node_modules/@babel/types/lib/builders/builder.js
+++ b/node_modules/@babel/types/lib/builders/builder.js
@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = builder;
+
+var _definitions = require("../definitions");
+
+var _validate = require("../validators/validate");
+
+function builder() {
+  const type = this;
+  const keys = _definitions.BUILDER_KEYS[type];
+  const countArgs = arguments.length;
+
+  if (countArgs > keys.length) {
+    throw new Error(`${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`);
+  }
+
+  const node = {
+    type
+  };
+
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i];
+    const field = _definitions.NODE_FIELDS[type][key];
+    let arg;
+    if (i < countArgs) arg = arguments[i];
+
+    if (arg === undefined) {
+      arg = Array.isArray(field.default) ? [] : field.default;
+    }
+
+    node[key] = arg;
+  }
+
+  for (const key in node) {
+    (0, _validate.default)(node, key, node[key]);
+  }
+
+  return node;
+}
--- a/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
+++ b/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createFlowUnionType;
+
+var _generated = require("../generated");
+
+var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates");
+
+function createFlowUnionType(types) {
+  const flattened = (0, _removeTypeDuplicates.default)(types);
+
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return (0, _generated.unionTypeAnnotation)(flattened);
+  }
+}
--- a/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
+++ b/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _generated = require("../generated");
+
+var _default = createTypeAnnotationBasedOnTypeof;
+exports.default = _default;
+
+function createTypeAnnotationBasedOnTypeof(type) {
+  switch (type) {
+    case "string":
+      return (0, _generated.stringTypeAnnotation)();
+
+    case "number":
+      return (0, _generated.numberTypeAnnotation)();
+
+    case "undefined":
+      return (0, _generated.voidTypeAnnotation)();
+
+    case "boolean":
+      return (0, _generated.booleanTypeAnnotation)();
+
+    case "function":
+      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function"));
+
+    case "object":
+      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
+
+    case "symbol":
+      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
+
+    case "bigint":
+      return (0, _generated.anyTypeAnnotation)();
+  }
+
+  throw new Error("Invalid typeof value: " + type);
+}
--- a/node_modules/@babel/types/lib/builders/generated/index.js
+++ b/node_modules/@babel/types/lib/builders/generated/index.js
--- a/node_modules/@babel/types/lib/builders/generated/uppercase.js
+++ b/node_modules/@babel/types/lib/builders/generated/uppercase.js
--- a/node_modules/@babel/types/lib/builders/react/buildChildren.js
+++ b/node_modules/@babel/types/lib/builders/react/buildChildren.js
@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildChildren;
+
+var _generated = require("../../validators/generated");
+
+var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild");
+
+function buildChildren(node) {
+  const elements = [];
+
+  for (let i = 0; i < node.children.length; i++) {
+    let child = node.children[i];
+
+    if ((0, _generated.isJSXText)(child)) {
+      (0, _cleanJSXElementLiteralChild.default)(child, elements);
+      continue;
+    }
+
+    if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
+    if ((0, _generated.isJSXEmptyExpression)(child)) continue;
+    elements.push(child);
+  }
+
+  return elements;
+}
--- a/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
+++ b/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createTSUnionType;
+
+var _generated = require("../generated");
+
+var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates");
+
+function createTSUnionType(typeAnnotations) {
+  const types = typeAnnotations.map(type => type.typeAnnotation);
+  const flattened = (0, _removeTypeDuplicates.default)(types);
+
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return (0, _generated.tsUnionType)(flattened);
+  }
+}
--- a/node_modules/@babel/types/lib/clone/clone.js
+++ b/node_modules/@babel/types/lib/clone/clone.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = clone;
+
+var _cloneNode = require("./cloneNode");
+
+function clone(node) {
+  return (0, _cloneNode.default)(node, false);
+}
--- a/node_modules/@babel/types/lib/clone/cloneDeep.js
+++ b/node_modules/@babel/types/lib/clone/cloneDeep.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneDeep;
+
+var _cloneNode = require("./cloneNode");
+
+function cloneDeep(node) {
+  return (0, _cloneNode.default)(node);
+}
--- a/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js
+++ b/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneDeepWithoutLoc;
+
+var _cloneNode = require("./cloneNode");
+
+function cloneDeepWithoutLoc(node) {
+  return (0, _cloneNode.default)(node, true, true);
+}
--- a/node_modules/@babel/types/lib/clone/cloneNode.js
+++ b/node_modules/@babel/types/lib/clone/cloneNode.js
@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneNode;
+
+var _definitions = require("../definitions");
+
+var _generated = require("../validators/generated");
+
+const has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+function cloneIfNode(obj, deep, withoutLoc) {
+  if (obj && typeof obj.type === "string") {
+    return cloneNode(obj, deep, withoutLoc);
+  }
+
+  return obj;
+}
+
+function cloneIfNodeOrArray(obj, deep, withoutLoc) {
+  if (Array.isArray(obj)) {
+    return obj.map(node => cloneIfNode(node, deep, withoutLoc));
+  }
+
+  return cloneIfNode(obj, deep, withoutLoc);
+}
+
+function cloneNode(node, deep = true, withoutLoc = false) {
+  if (!node) return node;
+  const {
+    type
+  } = node;
+  const newNode = {
+    type: node.type
+  };
+
+  if ((0, _generated.isIdentifier)(node)) {
+    newNode.name = node.name;
+
+    if (has(node, "optional") && typeof node.optional === "boolean") {
+      newNode.optional = node.optional;
+    }
+
+    if (has(node, "typeAnnotation")) {
+      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc) : node.typeAnnotation;
+    }
+  } else if (!has(_definitions.NODE_FIELDS, type)) {
+    throw new Error(`Unknown node type: "${type}"`);
+  } else {
+    for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
+      if (has(node, field)) {
+        if (deep) {
+          newNode[field] = (0, _generated.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc) : cloneIfNodeOrArray(node[field], true, withoutLoc);
+        } else {
+          newNode[field] = node[field];
+        }
+      }
+    }
+  }
+
+  if (has(node, "loc")) {
+    if (withoutLoc) {
+      newNode.loc = null;
+    } else {
+      newNode.loc = node.loc;
+    }
+  }
+
+  if (has(node, "leadingComments")) {
+    newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc);
+  }
+
+  if (has(node, "innerComments")) {
+    newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc);
+  }
+
+  if (has(node, "trailingComments")) {
+    newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc);
+  }
+
+  if (has(node, "extra")) {
+    newNode.extra = Object.assign({}, node.extra);
+  }
+
+  return newNode;
+}
+
+function maybeCloneComments(comments, deep, withoutLoc) {
+  if (!comments || !deep) {
+    return comments;
+  }
+
+  return comments.map(({
+    type,
+    value,
+    loc
+  }) => {
+    if (withoutLoc) {
+      return {
+        type,
+        value,
+        loc: null
+      };
+    }
+
+    return {
+      type,
+      value,
+      loc
+    };
+  });
+}
--- a/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
+++ b/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneWithoutLoc;
+
+var _cloneNode = require("./cloneNode");
+
+function cloneWithoutLoc(node) {
+  return (0, _cloneNode.default)(node, false, true);
+}
--- a/node_modules/@babel/types/lib/comments/addComment.js
+++ b/node_modules/@babel/types/lib/comments/addComment.js
@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComment;
+
+var _addComments = require("./addComments");
+
+function addComment(node, type, content, line) {
+  return (0, _addComments.default)(node, type, [{
+    type: line ? "CommentLine" : "CommentBlock",
+    value: content
+  }]);
+}
--- a/node_modules/@babel/types/lib/comments/addComments.js
+++ b/node_modules/@babel/types/lib/comments/addComments.js
@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addComments;
+
+function addComments(node, type, comments) {
+  if (!comments || !node) return node;
+  const key = `${type}Comments`;
+
+  if (node[key]) {
+    if (type === "leading") {
+      node[key] = comments.concat(node[key]);
+    } else {
+      node[key].push(...comments);
+    }
+  } else {
+    node[key] = comments;
+  }
+
+  return node;
+}
--- a/node_modules/@babel/types/lib/comments/inheritInnerComments.js
+++ b/node_modules/@babel/types/lib/comments/inheritInnerComments.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritInnerComments;
+
+var _inherit = require("../utils/inherit");
+
+function inheritInnerComments(child, parent) {
+  (0, _inherit.default)("innerComments", child, parent);
+}
--- a/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
+++ b/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritLeadingComments;
+
+var _inherit = require("../utils/inherit");
+
+function inheritLeadingComments(child, parent) {
+  (0, _inherit.default)("leadingComments", child, parent);
+}
--- a/node_modules/@babel/types/lib/comments/inheritTrailingComments.js
+++ b/node_modules/@babel/types/lib/comments/inheritTrailingComments.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritTrailingComments;
+
+var _inherit = require("../utils/inherit");
+
+function inheritTrailingComments(child, parent) {
+  (0, _inherit.default)("trailingComments", child, parent);
+}
--- a/node_modules/@babel/types/lib/comments/inheritsComments.js
+++ b/node_modules/@babel/types/lib/comments/inheritsComments.js
@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inheritsComments;
+
+var _inheritTrailingComments = require("./inheritTrailingComments");
+
+var _inheritLeadingComments = require("./inheritLeadingComments");
+
+var _inheritInnerComments = require("./inheritInnerComments");
+
+function inheritsComments(child, parent) {
+  (0, _inheritTrailingComments.default)(child, parent);
+  (0, _inheritLeadingComments.default)(child, parent);
+  (0, _inheritInnerComments.default)(child, parent);
+  return child;
+}
--- a/node_modules/@babel/types/lib/comments/removeComments.js
+++ b/node_modules/@babel/types/lib/comments/removeComments.js
@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeComments;
+
+var _constants = require("../constants");
+
+function removeComments(node) {
+  _constants.COMMENT_KEYS.forEach(key => {
+    node[key] = null;
+  });
+
+  return node;
+}
--- a/node_modules/@babel/types/lib/constants/generated/index.js
+++ b/node_modules/@babel/types/lib/constants/generated/index.js
@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0;
+
+var _definitions = require("../../definitions");
+
+const STANDARDIZED_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Standardized"];
+exports.STANDARDIZED_TYPES = STANDARDIZED_TYPES;
+const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"];
+exports.EXPRESSION_TYPES = EXPRESSION_TYPES;
+const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"];
+exports.BINARY_TYPES = BINARY_TYPES;
+const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"];
+exports.SCOPABLE_TYPES = SCOPABLE_TYPES;
+const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"];
+exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES;
+const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"];
+exports.BLOCK_TYPES = BLOCK_TYPES;
+const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"];
+exports.STATEMENT_TYPES = STATEMENT_TYPES;
+const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"];
+exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES;
+const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"];
+exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES;
+const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"];
+exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES;
+const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"];
+exports.LOOP_TYPES = LOOP_TYPES;
+const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"];
+exports.WHILE_TYPES = WHILE_TYPES;
+const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
+exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES;
+const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"];
+exports.FOR_TYPES = FOR_TYPES;
+const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"];
+exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES;
+const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"];
+exports.FUNCTION_TYPES = FUNCTION_TYPES;
+const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"];
+exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES;
+const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"];
+exports.PUREISH_TYPES = PUREISH_TYPES;
+const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"];
+exports.DECLARATION_TYPES = DECLARATION_TYPES;
+const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"];
+exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES;
+const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"];
+exports.LVAL_TYPES = LVAL_TYPES;
+const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"];
+exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES;
+const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"];
+exports.LITERAL_TYPES = LITERAL_TYPES;
+const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"];
+exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES;
+const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
+exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES;
+const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"];
+exports.METHOD_TYPES = METHOD_TYPES;
+const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"];
+exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES;
+const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"];
+exports.PROPERTY_TYPES = PROPERTY_TYPES;
+const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"];
+exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES;
+const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"];
+exports.PATTERN_TYPES = PATTERN_TYPES;
+const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"];
+exports.CLASS_TYPES = CLASS_TYPES;
+const MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"];
+exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES;
+const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
+exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES;
+const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
+exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES;
+const ACCESSOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Accessor"];
+exports.ACCESSOR_TYPES = ACCESSOR_TYPES;
+const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"];
+exports.PRIVATE_TYPES = PRIVATE_TYPES;
+const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"];
+exports.FLOW_TYPES = FLOW_TYPES;
+const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
+exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
+const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
+exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;
+const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
+exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES;
+const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"];
+exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES;
+const ENUMBODY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumBody"];
+exports.ENUMBODY_TYPES = ENUMBODY_TYPES;
+const ENUMMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumMember"];
+exports.ENUMMEMBER_TYPES = ENUMMEMBER_TYPES;
+const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"];
+exports.JSX_TYPES = JSX_TYPES;
+const MISCELLANEOUS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Miscellaneous"];
+exports.MISCELLANEOUS_TYPES = MISCELLANEOUS_TYPES;
+const TYPESCRIPT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TypeScript"];
+exports.TYPESCRIPT_TYPES = TYPESCRIPT_TYPES;
+const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"];
+exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES;
+const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"];
+exports.TSTYPE_TYPES = TSTYPE_TYPES;
+const TSBASETYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSBaseType"];
+exports.TSBASETYPE_TYPES = TSBASETYPE_TYPES;
--- a/node_modules/@babel/types/lib/constants/index.js
+++ b/node_modules/@babel/types/lib/constants/index.js
@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.NOT_LOCAL_BINDING = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BLOCK_SCOPED_SYMBOL = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0;
+const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
+exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS;
+const FLATTENABLE_KEYS = ["body", "expressions"];
+exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS;
+const FOR_INIT_KEYS = ["left", "init"];
+exports.FOR_INIT_KEYS = FOR_INIT_KEYS;
+const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
+exports.COMMENT_KEYS = COMMENT_KEYS;
+const LOGICAL_OPERATORS = ["||", "&&", "??"];
+exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS;
+const UPDATE_OPERATORS = ["++", "--"];
+exports.UPDATE_OPERATORS = UPDATE_OPERATORS;
+const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
+exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS;
+const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
+exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS;
+const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
+exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS;
+const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
+exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS;
+const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
+const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS];
+exports.BINARY_OPERATORS = BINARY_OPERATORS;
+const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
+exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS;
+const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
+exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
+const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
+exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS;
+const STRING_UNARY_OPERATORS = ["typeof"];
+exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS;
+const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
+exports.UNARY_OPERATORS = UNARY_OPERATORS;
+const INHERIT_KEYS = {
+  optional: ["typeAnnotation", "typeParameters", "returnType"],
+  force: ["start", "loc", "end"]
+};
+exports.INHERIT_KEYS = INHERIT_KEYS;
+const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
+exports.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL;
+const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding");
+exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING;
--- a/node_modules/@babel/types/lib/converters/Scope.js
+++ b/node_modules/@babel/types/lib/converters/Scope.js
--- a/node_modules/@babel/types/lib/converters/ensureBlock.js
+++ b/node_modules/@babel/types/lib/converters/ensureBlock.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ensureBlock;
+
+var _toBlock = require("./toBlock");
+
+function ensureBlock(node, key = "body") {
+  return node[key] = (0, _toBlock.default)(node[key], node);
+}
--- a/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js
+++ b/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js
@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = gatherSequenceExpressions;
+
+var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers");
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+var _cloneNode = require("../clone/cloneNode");
+
+function gatherSequenceExpressions(nodes, scope, declars) {
+  const exprs = [];
+  let ensureLastUndefined = true;
+
+  for (const node of nodes) {
+    if (!(0, _generated.isEmptyStatement)(node)) {
+      ensureLastUndefined = false;
+    }
+
+    if ((0, _generated.isExpression)(node)) {
+      exprs.push(node);
+    } else if ((0, _generated.isExpressionStatement)(node)) {
+      exprs.push(node.expression);
+    } else if ((0, _generated.isVariableDeclaration)(node)) {
+      if (node.kind !== "var") return;
+
+      for (const declar of node.declarations) {
+        const bindings = (0, _getBindingIdentifiers.default)(declar);
+
+        for (const key of Object.keys(bindings)) {
+          declars.push({
+            kind: node.kind,
+            id: (0, _cloneNode.default)(bindings[key])
+          });
+        }
+
+        if (declar.init) {
+          exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init));
+        }
+      }
+
+      ensureLastUndefined = true;
+    } else if ((0, _generated.isIfStatement)(node)) {
+      const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
+      const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
+      if (!consequent || !alternate) return;
+      exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate));
+    } else if ((0, _generated.isBlockStatement)(node)) {
+      const body = gatherSequenceExpressions(node.body, scope, declars);
+      if (!body) return;
+      exprs.push(body);
+    } else if ((0, _generated.isEmptyStatement)(node)) {
+      if (nodes.indexOf(node) === 0) {
+        ensureLastUndefined = true;
+      }
+    } else {
+      return;
+    }
+  }
+
+  if (ensureLastUndefined) {
+    exprs.push(scope.buildUndefinedNode());
+  }
+
+  if (exprs.length === 1) {
+    return exprs[0];
+  } else {
+    return (0, _generated2.sequenceExpression)(exprs);
+  }
+}
--- a/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js
+++ b/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js
@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toBindingIdentifierName;
+
+var _toIdentifier = require("./toIdentifier");
+
+function toBindingIdentifierName(name) {
+  name = (0, _toIdentifier.default)(name);
+  if (name === "eval" || name === "arguments") name = "_" + name;
+  return name;
+}
--- a/node_modules/@babel/types/lib/converters/toBlock.js
+++ b/node_modules/@babel/types/lib/converters/toBlock.js
@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toBlock;
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+function toBlock(node, parent) {
+  if ((0, _generated.isBlockStatement)(node)) {
+    return node;
+  }
+
+  let blockNodes = [];
+
+  if ((0, _generated.isEmptyStatement)(node)) {
+    blockNodes = [];
+  } else {
+    if (!(0, _generated.isStatement)(node)) {
+      if ((0, _generated.isFunction)(parent)) {
+        node = (0, _generated2.returnStatement)(node);
+      } else {
+        node = (0, _generated2.expressionStatement)(node);
+      }
+    }
+
+    blockNodes = [node];
+  }
+
+  return (0, _generated2.blockStatement)(blockNodes);
+}
--- a/node_modules/@babel/types/lib/converters/toComputedKey.js
+++ b/node_modules/@babel/types/lib/converters/toComputedKey.js
@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toComputedKey;
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+function toComputedKey(node, key = node.key || node.property) {
+  if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name);
+  return key;
+}
--- a/node_modules/@babel/types/lib/converters/toExpression.js
+++ b/node_modules/@babel/types/lib/converters/toExpression.js
@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _generated = require("../validators/generated");
+
+var _default = toExpression;
+exports.default = _default;
+
+function toExpression(node) {
+  if ((0, _generated.isExpressionStatement)(node)) {
+    node = node.expression;
+  }
+
+  if ((0, _generated.isExpression)(node)) {
+    return node;
+  }
+
+  if ((0, _generated.isClass)(node)) {
+    node.type = "ClassExpression";
+  } else if ((0, _generated.isFunction)(node)) {
+    node.type = "FunctionExpression";
+  }
+
+  if (!(0, _generated.isExpression)(node)) {
+    throw new Error(`cannot turn ${node.type} to an expression`);
+  }
+
+  return node;
+}
--- a/node_modules/@babel/types/lib/converters/toIdentifier.js
+++ b/node_modules/@babel/types/lib/converters/toIdentifier.js
@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toIdentifier;
+
+var _isValidIdentifier = require("../validators/isValidIdentifier");
+
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+
+function toIdentifier(input) {
+  input = input + "";
+  let name = "";
+
+  for (const c of input) {
+    name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-";
+  }
+
+  name = name.replace(/^[-0-9]+/, "");
+  name = name.replace(/[-\s]+(.)?/g, function (match, c) {
+    return c ? c.toUpperCase() : "";
+  });
+
+  if (!(0, _isValidIdentifier.default)(name)) {
+    name = `_${name}`;
+  }
+
+  return name || "_";
+}
--- a/node_modules/@babel/types/lib/converters/toKeyAlias.js
+++ b/node_modules/@babel/types/lib/converters/toKeyAlias.js
@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toKeyAlias;
+
+var _generated = require("../validators/generated");
+
+var _cloneNode = require("../clone/cloneNode");
+
+var _removePropertiesDeep = require("../modifications/removePropertiesDeep");
+
+function toKeyAlias(node, key = node.key) {
+  let alias;
+
+  if (node.kind === "method") {
+    return toKeyAlias.increment() + "";
+  } else if ((0, _generated.isIdentifier)(key)) {
+    alias = key.name;
+  } else if ((0, _generated.isStringLiteral)(key)) {
+    alias = JSON.stringify(key.value);
+  } else {
+    alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key)));
+  }
+
+  if (node.computed) {
+    alias = `[${alias}]`;
+  }
+
+  if (node.static) {
+    alias = `static:${alias}`;
+  }
+
+  return alias;
+}
+
+toKeyAlias.uid = 0;
+
+toKeyAlias.increment = function () {
+  if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {
+    return toKeyAlias.uid = 0;
+  } else {
+    return toKeyAlias.uid++;
+  }
+};
--- a/node_modules/@babel/types/lib/converters/toSequenceExpression.js
+++ b/node_modules/@babel/types/lib/converters/toSequenceExpression.js
@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toSequenceExpression;
+
+var _gatherSequenceExpressions = require("./gatherSequenceExpressions");
+
+function toSequenceExpression(nodes, scope) {
+  if (!(nodes != null && nodes.length)) return;
+  const declars = [];
+  const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
+  if (!result) return;
+
+  for (const declar of declars) {
+    scope.push(declar);
+  }
+
+  return result;
+}
--- a/node_modules/@babel/types/lib/converters/toStatement.js
+++ b/node_modules/@babel/types/lib/converters/toStatement.js
@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _generated = require("../validators/generated");
+
+var _generated2 = require("../builders/generated");
+
+var _default = toStatement;
+exports.default = _default;
+
+function toStatement(node, ignore) {
+  if ((0, _generated.isStatement)(node)) {
+    return node;
+  }
+
+  let mustHaveId = false;
+  let newType;
+
+  if ((0, _generated.isClass)(node)) {
+    mustHaveId = true;
+    newType = "ClassDeclaration";
+  } else if ((0, _generated.isFunction)(node)) {
+    mustHaveId = true;
+    newType = "FunctionDeclaration";
+  } else if ((0, _generated.isAssignmentExpression)(node)) {
+    return (0, _generated2.expressionStatement)(node);
+  }
+
+  if (mustHaveId && !node.id) {
+    newType = false;
+  }
+
+  if (!newType) {
+    if (ignore) {
+      return false;
+    } else {
+      throw new Error(`cannot turn ${node.type} to a statement`);
+    }
+  }
+
+  node.type = newType;
+  return node;
+}
--- a/node_modules/@babel/types/lib/converters/valueToNode.js
+++ b/node_modules/@babel/types/lib/converters/valueToNode.js
@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _isValidIdentifier = require("../validators/isValidIdentifier");
+
+var _generated = require("../builders/generated");
+
+var _default = valueToNode;
+exports.default = _default;
+const objectToString = Function.call.bind(Object.prototype.toString);
+
+function isRegExp(value) {
+  return objectToString(value) === "[object RegExp]";
+}
+
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Object.prototype.toString.call(value) !== "[object Object]") {
+    return false;
+  }
+
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || Object.getPrototypeOf(proto) === null;
+}
+
+function valueToNode(value) {
+  if (value === undefined) {
+    return (0, _generated.identifier)("undefined");
+  }
+
+  if (value === true || value === false) {
+    return (0, _generated.booleanLiteral)(value);
+  }
+
+  if (value === null) {
+    return (0, _generated.nullLiteral)();
+  }
+
+  if (typeof value === "string") {
+    return (0, _generated.stringLiteral)(value);
+  }
+
+  if (typeof value === "number") {
+    let result;
+
+    if (Number.isFinite(value)) {
+      result = (0, _generated.numericLiteral)(Math.abs(value));
+    } else {
+      let numerator;
+
+      if (Number.isNaN(value)) {
+        numerator = (0, _generated.numericLiteral)(0);
+      } else {
+        numerator = (0, _generated.numericLiteral)(1);
+      }
+
+      result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0));
+    }
+
+    if (value < 0 || Object.is(value, -0)) {
+      result = (0, _generated.unaryExpression)("-", result);
+    }
+
+    return result;
+  }
+
+  if (isRegExp(value)) {
+    const pattern = value.source;
+    const flags = value.toString().match(/\/([a-z]+|)$/)[1];
+    return (0, _generated.regExpLiteral)(pattern, flags);
+  }
+
+  if (Array.isArray(value)) {
+    return (0, _generated.arrayExpression)(value.map(valueToNode));
+  }
+
+  if (isPlainObject(value)) {
+    const props = [];
+
+    for (const key of Object.keys(value)) {
+      let nodeKey;
+
+      if ((0, _isValidIdentifier.default)(key)) {
+        nodeKey = (0, _generated.identifier)(key);
+      } else {
+        nodeKey = (0, _generated.stringLiteral)(key);
+      }
+
+      props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key])));
+    }
+
+    return (0, _generated.objectExpression)(props);
+  }
+
+  throw new Error("don't know how to turn this value into a node");
+}
--- a/node_modules/@babel/types/lib/definitions/core.js
+++ b/node_modules/@babel/types/lib/definitions/core.js
--- a/node_modules/@babel/types/lib/definitions/experimental.js
+++ b/node_modules/@babel/types/lib/definitions/experimental.js
@ -0,0 +1,133 @@
+"use strict";
+
+var _utils = require("./utils");
+
+(0, _utils.default)("ArgumentPlaceholder", {});
+(0, _utils.default)("BindExpression", {
+  visitor: ["object", "callee"],
+  aliases: ["Expression"],
+  fields: !process.env.BABEL_TYPES_8_BREAKING ? {
+    object: {
+      validate: Object.assign(() => {}, {
+        oneOfNodeTypes: ["Expression"]
+      })
+    },
+    callee: {
+      validate: Object.assign(() => {}, {
+        oneOfNodeTypes: ["Expression"]
+      })
+    }
+  } : {
+    object: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    callee: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("ImportAttribute", {
+  visitor: ["key", "value"],
+  fields: {
+    key: {
+      validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
+    },
+    value: {
+      validate: (0, _utils.assertNodeType)("StringLiteral")
+    }
+  }
+});
+(0, _utils.default)("Decorator", {
+  visitor: ["expression"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+(0, _utils.default)("DoExpression", {
+  visitor: ["body"],
+  builder: ["body", "async"],
+  aliases: ["Expression"],
+  fields: {
+    body: {
+      validate: (0, _utils.assertNodeType)("BlockStatement")
+    },
+    async: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      default: false
+    }
+  }
+});
+(0, _utils.default)("ExportDefaultSpecifier", {
+  visitor: ["exported"],
+  aliases: ["ModuleSpecifier"],
+  fields: {
+    exported: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    }
+  }
+});
+(0, _utils.default)("RecordExpression", {
+  visitor: ["properties"],
+  aliases: ["Expression"],
+  fields: {
+    properties: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement")))
+    }
+  }
+});
+(0, _utils.default)("TupleExpression", {
+  fields: {
+    elements: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))),
+      default: []
+    }
+  },
+  visitor: ["elements"],
+  aliases: ["Expression"]
+});
+(0, _utils.default)("DecimalLiteral", {
+  builder: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  },
+  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+(0, _utils.default)("ModuleExpression", {
+  visitor: ["body"],
+  fields: {
+    body: {
+      validate: (0, _utils.assertNodeType)("Program")
+    }
+  },
+  aliases: ["Expression"]
+});
+(0, _utils.default)("TopicReference", {
+  aliases: ["Expression"]
+});
+(0, _utils.default)("PipelineTopicExpression", {
+  builder: ["expression"],
+  visitor: ["expression"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  },
+  aliases: ["Expression"]
+});
+(0, _utils.default)("PipelineBareFunction", {
+  builder: ["callee"],
+  visitor: ["callee"],
+  fields: {
+    callee: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  },
+  aliases: ["Expression"]
+});
+(0, _utils.default)("PipelinePrimaryTopicReference", {
+  aliases: ["Expression"]
+});
--- a/node_modules/@babel/types/lib/definitions/flow.js
+++ b/node_modules/@babel/types/lib/definitions/flow.js
@ -0,0 +1,474 @@
+"use strict";
+
+var _utils = require("./utils");
+
+const defineType = (0, _utils.defineAliasedType)("Flow");
+
+const defineInterfaceishType = (name, typeParameterType = "TypeParameterDeclaration") => {
+  defineType(name, {
+    builder: ["id", "typeParameters", "extends", "body"],
+    visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"],
+    aliases: ["FlowDeclaration", "Statement", "Declaration"],
+    fields: {
+      id: (0, _utils.validateType)("Identifier"),
+      typeParameters: (0, _utils.validateOptionalType)(typeParameterType),
+      extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+      mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+      implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")),
+      body: (0, _utils.validateType)("ObjectTypeAnnotation")
+    }
+  });
+};
+
+defineType("AnyTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("ArrayTypeAnnotation", {
+  visitor: ["elementType"],
+  aliases: ["FlowType"],
+  fields: {
+    elementType: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("BooleanTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("BooleanLiteralTypeAnnotation", {
+  builder: ["value"],
+  aliases: ["FlowType"],
+  fields: {
+    value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("NullLiteralTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("ClassImplements", {
+  visitor: ["id", "typeParameters"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+  }
+});
+defineInterfaceishType("DeclareClass");
+defineType("DeclareFunction", {
+  visitor: ["id"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
+  }
+});
+defineInterfaceishType("DeclareInterface");
+defineType("DeclareModule", {
+  builder: ["id", "body", "kind"],
+  visitor: ["id", "body"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    body: (0, _utils.validateType)("BlockStatement"),
+    kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
+  }
+});
+defineType("DeclareModuleExports", {
+  visitor: ["typeAnnotation"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+  }
+});
+defineType("DeclareTypeAlias", {
+  visitor: ["id", "typeParameters", "right"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    right: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("DeclareOpaqueType", {
+  visitor: ["id", "typeParameters", "supertype"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    supertype: (0, _utils.validateOptionalType)("FlowType"),
+    impltype: (0, _utils.validateOptionalType)("FlowType")
+  }
+});
+defineType("DeclareVariable", {
+  visitor: ["id"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier")
+  }
+});
+defineType("DeclareExportDeclaration", {
+  visitor: ["declaration", "specifiers", "source"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    declaration: (0, _utils.validateOptionalType)("Flow"),
+    specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
+    source: (0, _utils.validateOptionalType)("StringLiteral"),
+    default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("DeclareExportAllDeclaration", {
+  visitor: ["source"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    source: (0, _utils.validateType)("StringLiteral"),
+    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
+  }
+});
+defineType("DeclaredPredicate", {
+  visitor: ["value"],
+  aliases: ["FlowPredicate"],
+  fields: {
+    value: (0, _utils.validateType)("Flow")
+  }
+});
+defineType("ExistsTypeAnnotation", {
+  aliases: ["FlowType"]
+});
+defineType("FunctionTypeAnnotation", {
+  visitor: ["typeParameters", "params", "rest", "returnType"],
+  aliases: ["FlowType"],
+  fields: {
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
+    rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+    this: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+    returnType: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("FunctionTypeParam", {
+  visitor: ["name", "typeAnnotation"],
+  fields: {
+    name: (0, _utils.validateOptionalType)("Identifier"),
+    typeAnnotation: (0, _utils.validateType)("FlowType"),
+    optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("GenericTypeAnnotation", {
+  visitor: ["id", "typeParameters"],
+  aliases: ["FlowType"],
+  fields: {
+    id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+  }
+});
+defineType("InferredPredicate", {
+  aliases: ["FlowPredicate"]
+});
+defineType("InterfaceExtends", {
+  visitor: ["id", "typeParameters"],
+  fields: {
+    id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+  }
+});
+defineInterfaceishType("InterfaceDeclaration");
+defineType("InterfaceTypeAnnotation", {
+  visitor: ["extends", "body"],
+  aliases: ["FlowType"],
+  fields: {
+    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+    body: (0, _utils.validateType)("ObjectTypeAnnotation")
+  }
+});
+defineType("IntersectionTypeAnnotation", {
+  visitor: ["types"],
+  aliases: ["FlowType"],
+  fields: {
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
+});
+defineType("MixedTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("EmptyTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("NullableTypeAnnotation", {
+  visitor: ["typeAnnotation"],
+  aliases: ["FlowType"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("NumberLiteralTypeAnnotation", {
+  builder: ["value"],
+  aliases: ["FlowType"],
+  fields: {
+    value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
+  }
+});
+defineType("NumberTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("ObjectTypeAnnotation", {
+  visitor: ["properties", "indexers", "callProperties", "internalSlots"],
+  aliases: ["FlowType"],
+  builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
+  fields: {
+    properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
+    indexers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeIndexer")),
+    callProperties: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeCallProperty")),
+    internalSlots: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeInternalSlot")),
+    exact: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      default: false
+    },
+    inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("ObjectTypeInternalSlot", {
+  visitor: ["id", "value", "optional", "static", "method"],
+  aliases: ["UserWhitespacable"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    value: (0, _utils.validateType)("FlowType"),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("ObjectTypeCallProperty", {
+  visitor: ["value"],
+  aliases: ["UserWhitespacable"],
+  fields: {
+    value: (0, _utils.validateType)("FlowType"),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("ObjectTypeIndexer", {
+  visitor: ["id", "key", "value", "variance"],
+  aliases: ["UserWhitespacable"],
+  fields: {
+    id: (0, _utils.validateOptionalType)("Identifier"),
+    key: (0, _utils.validateType)("FlowType"),
+    value: (0, _utils.validateType)("FlowType"),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    variance: (0, _utils.validateOptionalType)("Variance")
+  }
+});
+defineType("ObjectTypeProperty", {
+  visitor: ["key", "value", "variance"],
+  aliases: ["UserWhitespacable"],
+  fields: {
+    key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    value: (0, _utils.validateType)("FlowType"),
+    kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    variance: (0, _utils.validateOptionalType)("Variance"),
+    method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("ObjectTypeSpreadProperty", {
+  visitor: ["argument"],
+  aliases: ["UserWhitespacable"],
+  fields: {
+    argument: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("OpaqueType", {
+  visitor: ["id", "typeParameters", "supertype", "impltype"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    supertype: (0, _utils.validateOptionalType)("FlowType"),
+    impltype: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("QualifiedTypeIdentifier", {
+  visitor: ["id", "qualification"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
+  }
+});
+defineType("StringLiteralTypeAnnotation", {
+  builder: ["value"],
+  aliases: ["FlowType"],
+  fields: {
+    value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
+  }
+});
+defineType("StringTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("SymbolTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("ThisTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("TupleTypeAnnotation", {
+  visitor: ["types"],
+  aliases: ["FlowType"],
+  fields: {
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
+});
+defineType("TypeofTypeAnnotation", {
+  visitor: ["argument"],
+  aliases: ["FlowType"],
+  fields: {
+    argument: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("TypeAlias", {
+  visitor: ["id", "typeParameters", "right"],
+  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    right: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("TypeAnnotation", {
+  visitor: ["typeAnnotation"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("TypeCastExpression", {
+  visitor: ["expression", "typeAnnotation"],
+  aliases: ["ExpressionWrapper", "Expression"],
+  fields: {
+    expression: (0, _utils.validateType)("Expression"),
+    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+  }
+});
+defineType("TypeParameter", {
+  visitor: ["bound", "default", "variance"],
+  fields: {
+    name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
+    default: (0, _utils.validateOptionalType)("FlowType"),
+    variance: (0, _utils.validateOptionalType)("Variance")
+  }
+});
+defineType("TypeParameterDeclaration", {
+  visitor: ["params"],
+  fields: {
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
+  }
+});
+defineType("TypeParameterInstantiation", {
+  visitor: ["params"],
+  fields: {
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
+});
+defineType("UnionTypeAnnotation", {
+  visitor: ["types"],
+  aliases: ["FlowType"],
+  fields: {
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
+});
+defineType("Variance", {
+  builder: ["kind"],
+  fields: {
+    kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
+  }
+});
+defineType("VoidTypeAnnotation", {
+  aliases: ["FlowType", "FlowBaseAnnotation"]
+});
+defineType("EnumDeclaration", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "body"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"])
+  }
+});
+defineType("EnumBooleanBody", {
+  aliases: ["EnumBody"],
+  visitor: ["members"],
+  fields: {
+    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    members: (0, _utils.validateArrayOfType)("EnumBooleanMember"),
+    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("EnumNumberBody", {
+  aliases: ["EnumBody"],
+  visitor: ["members"],
+  fields: {
+    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    members: (0, _utils.validateArrayOfType)("EnumNumberMember"),
+    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("EnumStringBody", {
+  aliases: ["EnumBody"],
+  visitor: ["members"],
+  fields: {
+    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"]),
+    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("EnumSymbolBody", {
+  aliases: ["EnumBody"],
+  visitor: ["members"],
+  fields: {
+    members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"),
+    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
+defineType("EnumBooleanMember", {
+  aliases: ["EnumMember"],
+  visitor: ["id"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    init: (0, _utils.validateType)("BooleanLiteral")
+  }
+});
+defineType("EnumNumberMember", {
+  aliases: ["EnumMember"],
+  visitor: ["id", "init"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    init: (0, _utils.validateType)("NumericLiteral")
+  }
+});
+defineType("EnumStringMember", {
+  aliases: ["EnumMember"],
+  visitor: ["id", "init"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    init: (0, _utils.validateType)("StringLiteral")
+  }
+});
+defineType("EnumDefaultedMember", {
+  aliases: ["EnumMember"],
+  visitor: ["id"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier")
+  }
+});
+defineType("IndexedAccessType", {
+  visitor: ["objectType", "indexType"],
+  aliases: ["FlowType"],
+  fields: {
+    objectType: (0, _utils.validateType)("FlowType"),
+    indexType: (0, _utils.validateType)("FlowType")
+  }
+});
+defineType("OptionalIndexedAccessType", {
+  visitor: ["objectType", "indexType"],
+  aliases: ["FlowType"],
+  fields: {
+    objectType: (0, _utils.validateType)("FlowType"),
+    indexType: (0, _utils.validateType)("FlowType"),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
+});
--- a/node_modules/@babel/types/lib/definitions/index.js
+++ b/node_modules/@babel/types/lib/definitions/index.js
@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ALIAS_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.ALIAS_KEYS;
+  }
+});
+Object.defineProperty(exports, "BUILDER_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.BUILDER_KEYS;
+  }
+});
+Object.defineProperty(exports, "DEPRECATED_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.DEPRECATED_KEYS;
+  }
+});
+Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.FLIPPED_ALIAS_KEYS;
+  }
+});
+Object.defineProperty(exports, "NODE_FIELDS", {
+  enumerable: true,
+  get: function () {
+    return _utils.NODE_FIELDS;
+  }
+});
+Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", {
+  enumerable: true,
+  get: function () {
+    return _utils.NODE_PARENT_VALIDATIONS;
+  }
+});
+Object.defineProperty(exports, "PLACEHOLDERS", {
+  enumerable: true,
+  get: function () {
+    return _placeholders.PLACEHOLDERS;
+  }
+});
+Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", {
+  enumerable: true,
+  get: function () {
+    return _placeholders.PLACEHOLDERS_ALIAS;
+  }
+});
+Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", {
+  enumerable: true,
+  get: function () {
+    return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS;
+  }
+});
+exports.TYPES = void 0;
+Object.defineProperty(exports, "VISITOR_KEYS", {
+  enumerable: true,
+  get: function () {
+    return _utils.VISITOR_KEYS;
+  }
+});
+
+var _toFastProperties = require("to-fast-properties");
+
+require("./core");
+
+require("./flow");
+
+require("./jsx");
+
+require("./misc");
+
+require("./experimental");
+
+require("./typescript");
+
+var _utils = require("./utils");
+
+var _placeholders = require("./placeholders");
+
+_toFastProperties(_utils.VISITOR_KEYS);
+
+_toFastProperties(_utils.ALIAS_KEYS);
+
+_toFastProperties(_utils.FLIPPED_ALIAS_KEYS);
+
+_toFastProperties(_utils.NODE_FIELDS);
+
+_toFastProperties(_utils.BUILDER_KEYS);
+
+_toFastProperties(_utils.DEPRECATED_KEYS);
+
+_toFastProperties(_placeholders.PLACEHOLDERS_ALIAS);
+
+_toFastProperties(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS);
+
+const TYPES = [].concat(Object.keys(_utils.VISITOR_KEYS), Object.keys(_utils.FLIPPED_ALIAS_KEYS), Object.keys(_utils.DEPRECATED_KEYS));
+exports.TYPES = TYPES;
--- a/node_modules/@babel/types/lib/definitions/jsx.js
+++ b/node_modules/@babel/types/lib/definitions/jsx.js
@ -0,0 +1,156 @@
+"use strict";
+
+var _utils = require("./utils");
+
+const defineType = (0, _utils.defineAliasedType)("JSX");
+defineType("JSXAttribute", {
+  visitor: ["name", "value"],
+  aliases: ["Immutable"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
+    },
+    value: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
+    }
+  }
+});
+defineType("JSXClosingElement", {
+  visitor: ["name"],
+  aliases: ["Immutable"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
+    }
+  }
+});
+defineType("JSXElement", {
+  builder: ["openingElement", "closingElement", "children", "selfClosing"],
+  visitor: ["openingElement", "children", "closingElement"],
+  aliases: ["Immutable", "Expression"],
+  fields: {
+    openingElement: {
+      validate: (0, _utils.assertNodeType)("JSXOpeningElement")
+    },
+    closingElement: {
+      optional: true,
+      validate: (0, _utils.assertNodeType)("JSXClosingElement")
+    },
+    children: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
+    },
+    selfClosing: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    }
+  }
+});
+defineType("JSXEmptyExpression", {});
+defineType("JSXExpressionContainer", {
+  visitor: ["expression"],
+  aliases: ["Immutable"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression")
+    }
+  }
+});
+defineType("JSXSpreadChild", {
+  visitor: ["expression"],
+  aliases: ["Immutable"],
+  fields: {
+    expression: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+defineType("JSXIdentifier", {
+  builder: ["name"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  }
+});
+defineType("JSXMemberExpression", {
+  visitor: ["object", "property"],
+  fields: {
+    object: {
+      validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
+    },
+    property: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier")
+    }
+  }
+});
+defineType("JSXNamespacedName", {
+  visitor: ["namespace", "name"],
+  fields: {
+    namespace: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier")
+    },
+    name: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier")
+    }
+  }
+});
+defineType("JSXOpeningElement", {
+  builder: ["name", "attributes", "selfClosing"],
+  visitor: ["name", "attributes"],
+  aliases: ["Immutable"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
+    },
+    selfClosing: {
+      default: false
+    },
+    attributes: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
+    },
+    typeParameters: {
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      optional: true
+    }
+  }
+});
+defineType("JSXSpreadAttribute", {
+  visitor: ["argument"],
+  fields: {
+    argument: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
+});
+defineType("JSXText", {
+  aliases: ["Immutable"],
+  builder: ["value"],
+  fields: {
+    value: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  }
+});
+defineType("JSXFragment", {
+  builder: ["openingFragment", "closingFragment", "children"],
+  visitor: ["openingFragment", "children", "closingFragment"],
+  aliases: ["Immutable", "Expression"],
+  fields: {
+    openingFragment: {
+      validate: (0, _utils.assertNodeType)("JSXOpeningFragment")
+    },
+    closingFragment: {
+      validate: (0, _utils.assertNodeType)("JSXClosingFragment")
+    },
+    children: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
+    }
+  }
+});
+defineType("JSXOpeningFragment", {
+  aliases: ["Immutable"]
+});
+defineType("JSXClosingFragment", {
+  aliases: ["Immutable"]
+});
--- a/node_modules/@babel/types/lib/definitions/misc.js
+++ b/node_modules/@babel/types/lib/definitions/misc.js
@ -0,0 +1,32 @@
+"use strict";
+
+var _utils = require("./utils");
+
+var _placeholders = require("./placeholders");
+
+const defineType = (0, _utils.defineAliasedType)("Miscellaneous");
+{
+  defineType("Noop", {
+    visitor: []
+  });
+}
+defineType("Placeholder", {
+  visitor: [],
+  builder: ["expectedNode", "name"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertNodeType)("Identifier")
+    },
+    expectedNode: {
+      validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS)
+    }
+  }
+});
+defineType("V8IntrinsicIdentifier", {
+  builder: ["name"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertValueType)("string")
+    }
+  }
+});
--- a/node_modules/@babel/types/lib/definitions/placeholders.js
+++ b/node_modules/@babel/types/lib/definitions/placeholders.js
@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0;
+
+var _utils = require("./utils");
+
+const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
+exports.PLACEHOLDERS = PLACEHOLDERS;
+const PLACEHOLDERS_ALIAS = {
+  Declaration: ["Statement"],
+  Pattern: ["PatternLike", "LVal"]
+};
+exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS;
+
+for (const type of PLACEHOLDERS) {
+  const alias = _utils.ALIAS_KEYS[type];
+  if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias;
+}
+
+const PLACEHOLDERS_FLIPPED_ALIAS = {};
+exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS;
+Object.keys(PLACEHOLDERS_ALIAS).forEach(type => {
+  PLACEHOLDERS_ALIAS[type].forEach(alias => {
+    if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {
+      PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];
+    }
+
+    PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type);
+  });
+});
--- a/node_modules/@babel/types/lib/definitions/typescript.js
+++ b/node_modules/@babel/types/lib/definitions/typescript.js
@ -0,0 +1,470 @@
+"use strict";
+
+var _utils = require("./utils");
+
+var _core = require("./core");
+
+var _is = require("../validators/is");
+
+const defineType = (0, _utils.defineAliasedType)("TypeScript");
+const bool = (0, _utils.assertValueType)("boolean");
+const tSFunctionTypeAnnotationCommon = {
+  returnType: {
+    validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
+    optional: true
+  },
+  typeParameters: {
+    validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
+    optional: true
+  }
+};
+defineType("TSParameterProperty", {
+  aliases: ["LVal"],
+  visitor: ["parameter"],
+  fields: {
+    accessibility: {
+      validate: (0, _utils.assertOneOf)("public", "private", "protected"),
+      optional: true
+    },
+    readonly: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    },
+    parameter: {
+      validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
+    },
+    override: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    },
+    decorators: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+      optional: true
+    }
+  }
+});
+defineType("TSDeclareFunction", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "typeParameters", "params", "returnType"],
+  fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
+});
+defineType("TSDeclareMethod", {
+  visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
+  fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
+});
+defineType("TSQualifiedName", {
+  aliases: ["TSEntityName"],
+  visitor: ["left", "right"],
+  fields: {
+    left: (0, _utils.validateType)("TSEntityName"),
+    right: (0, _utils.validateType)("Identifier")
+  }
+});
+const signatureDeclarationCommon = {
+  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+  ["parameters"]: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
+  ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation")
+};
+const callConstructSignatureDeclaration = {
+  aliases: ["TSTypeElement"],
+  visitor: ["typeParameters", "parameters", "typeAnnotation"],
+  fields: signatureDeclarationCommon
+};
+defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
+defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
+const namedTypeElementCommon = {
+  key: (0, _utils.validateType)("Expression"),
+  computed: (0, _utils.validate)(bool),
+  optional: (0, _utils.validateOptional)(bool)
+};
+defineType("TSPropertySignature", {
+  aliases: ["TSTypeElement"],
+  visitor: ["key", "typeAnnotation", "initializer"],
+  fields: Object.assign({}, namedTypeElementCommon, {
+    readonly: (0, _utils.validateOptional)(bool),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+    initializer: (0, _utils.validateOptionalType)("Expression"),
+    kind: {
+      validate: (0, _utils.assertOneOf)("get", "set")
+    }
+  })
+});
+defineType("TSMethodSignature", {
+  aliases: ["TSTypeElement"],
+  visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
+  fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon, {
+    kind: {
+      validate: (0, _utils.assertOneOf)("method", "get", "set")
+    }
+  })
+});
+defineType("TSIndexSignature", {
+  aliases: ["TSTypeElement"],
+  visitor: ["parameters", "typeAnnotation"],
+  fields: {
+    readonly: (0, _utils.validateOptional)(bool),
+    static: (0, _utils.validateOptional)(bool),
+    parameters: (0, _utils.validateArrayOfType)("Identifier"),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
+  }
+});
+const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
+
+for (const type of tsKeywordTypes) {
+  defineType(type, {
+    aliases: ["TSType", "TSBaseType"],
+    visitor: [],
+    fields: {}
+  });
+}
+
+defineType("TSThisType", {
+  aliases: ["TSType", "TSBaseType"],
+  visitor: [],
+  fields: {}
+});
+const fnOrCtrBase = {
+  aliases: ["TSType"],
+  visitor: ["typeParameters", "parameters", "typeAnnotation"]
+};
+defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, {
+  fields: signatureDeclarationCommon
+}));
+defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, {
+  fields: Object.assign({}, signatureDeclarationCommon, {
+    abstract: (0, _utils.validateOptional)(bool)
+  })
+}));
+defineType("TSTypeReference", {
+  aliases: ["TSType"],
+  visitor: ["typeName", "typeParameters"],
+  fields: {
+    typeName: (0, _utils.validateType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+  }
+});
+defineType("TSTypePredicate", {
+  aliases: ["TSType"],
+  visitor: ["parameterName", "typeAnnotation"],
+  builder: ["parameterName", "typeAnnotation", "asserts"],
+  fields: {
+    parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+    asserts: (0, _utils.validateOptional)(bool)
+  }
+});
+defineType("TSTypeQuery", {
+  aliases: ["TSType"],
+  visitor: ["exprName"],
+  fields: {
+    exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"])
+  }
+});
+defineType("TSTypeLiteral", {
+  aliases: ["TSType"],
+  visitor: ["members"],
+  fields: {
+    members: (0, _utils.validateArrayOfType)("TSTypeElement")
+  }
+});
+defineType("TSArrayType", {
+  aliases: ["TSType"],
+  visitor: ["elementType"],
+  fields: {
+    elementType: (0, _utils.validateType)("TSType")
+  }
+});
+defineType("TSTupleType", {
+  aliases: ["TSType"],
+  visitor: ["elementTypes"],
+  fields: {
+    elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
+  }
+});
+defineType("TSOptionalType", {
+  aliases: ["TSType"],
+  visitor: ["typeAnnotation"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+defineType("TSRestType", {
+  aliases: ["TSType"],
+  visitor: ["typeAnnotation"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+defineType("TSNamedTupleMember", {
+  visitor: ["label", "elementType"],
+  builder: ["label", "elementType", "optional"],
+  fields: {
+    label: (0, _utils.validateType)("Identifier"),
+    optional: {
+      validate: bool,
+      default: false
+    },
+    elementType: (0, _utils.validateType)("TSType")
+  }
+});
+const unionOrIntersection = {
+  aliases: ["TSType"],
+  visitor: ["types"],
+  fields: {
+    types: (0, _utils.validateArrayOfType)("TSType")
+  }
+};
+defineType("TSUnionType", unionOrIntersection);
+defineType("TSIntersectionType", unionOrIntersection);
+defineType("TSConditionalType", {
+  aliases: ["TSType"],
+  visitor: ["checkType", "extendsType", "trueType", "falseType"],
+  fields: {
+    checkType: (0, _utils.validateType)("TSType"),
+    extendsType: (0, _utils.validateType)("TSType"),
+    trueType: (0, _utils.validateType)("TSType"),
+    falseType: (0, _utils.validateType)("TSType")
+  }
+});
+defineType("TSInferType", {
+  aliases: ["TSType"],
+  visitor: ["typeParameter"],
+  fields: {
+    typeParameter: (0, _utils.validateType)("TSTypeParameter")
+  }
+});
+defineType("TSParenthesizedType", {
+  aliases: ["TSType"],
+  visitor: ["typeAnnotation"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+defineType("TSTypeOperator", {
+  aliases: ["TSType"],
+  visitor: ["typeAnnotation"],
+  fields: {
+    operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+defineType("TSIndexedAccessType", {
+  aliases: ["TSType"],
+  visitor: ["objectType", "indexType"],
+  fields: {
+    objectType: (0, _utils.validateType)("TSType"),
+    indexType: (0, _utils.validateType)("TSType")
+  }
+});
+defineType("TSMappedType", {
+  aliases: ["TSType"],
+  visitor: ["typeParameter", "typeAnnotation", "nameType"],
+  fields: {
+    readonly: (0, _utils.validateOptional)(bool),
+    typeParameter: (0, _utils.validateType)("TSTypeParameter"),
+    optional: (0, _utils.validateOptional)(bool),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSType"),
+    nameType: (0, _utils.validateOptionalType)("TSType")
+  }
+});
+defineType("TSLiteralType", {
+  aliases: ["TSType", "TSBaseType"],
+  visitor: ["literal"],
+  fields: {
+    literal: {
+      validate: function () {
+        const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral");
+        const unaryOperator = (0, _utils.assertOneOf)("-");
+        const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral");
+
+        function validator(parent, key, node) {
+          if ((0, _is.default)("UnaryExpression", node)) {
+            unaryOperator(node, "operator", node.operator);
+            unaryExpression(node, "argument", node.argument);
+          } else {
+            literal(parent, key, node);
+          }
+        }
+
+        validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "UnaryExpression"];
+        return validator;
+      }()
+    }
+  }
+});
+defineType("TSExpressionWithTypeArguments", {
+  aliases: ["TSType"],
+  visitor: ["expression", "typeParameters"],
+  fields: {
+    expression: (0, _utils.validateType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+  }
+});
+defineType("TSInterfaceDeclaration", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "typeParameters", "extends", "body"],
+  fields: {
+    declare: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
+    body: (0, _utils.validateType)("TSInterfaceBody")
+  }
+});
+defineType("TSInterfaceBody", {
+  visitor: ["body"],
+  fields: {
+    body: (0, _utils.validateArrayOfType)("TSTypeElement")
+  }
+});
+defineType("TSTypeAliasDeclaration", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "typeParameters", "typeAnnotation"],
+  fields: {
+    declare: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+defineType("TSAsExpression", {
+  aliases: ["Expression"],
+  visitor: ["expression", "typeAnnotation"],
+  fields: {
+    expression: (0, _utils.validateType)("Expression"),
+    typeAnnotation: (0, _utils.validateType)("TSType")
+  }
+});
+defineType("TSTypeAssertion", {
+  aliases: ["Expression"],
+  visitor: ["typeAnnotation", "expression"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("TSType"),
+    expression: (0, _utils.validateType)("Expression")
+  }
+});
+defineType("TSEnumDeclaration", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "members"],
+  fields: {
+    declare: (0, _utils.validateOptional)(bool),
+    const: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    members: (0, _utils.validateArrayOfType)("TSEnumMember"),
+    initializer: (0, _utils.validateOptionalType)("Expression")
+  }
+});
+defineType("TSEnumMember", {
+  visitor: ["id", "initializer"],
+  fields: {
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    initializer: (0, _utils.validateOptionalType)("Expression")
+  }
+});
+defineType("TSModuleDeclaration", {
+  aliases: ["Statement", "Declaration"],
+  visitor: ["id", "body"],
+  fields: {
+    declare: (0, _utils.validateOptional)(bool),
+    global: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
+  }
+});
+defineType("TSModuleBlock", {
+  aliases: ["Scopable", "Block", "BlockParent"],
+  visitor: ["body"],
+  fields: {
+    body: (0, _utils.validateArrayOfType)("Statement")
+  }
+});
+defineType("TSImportType", {
+  aliases: ["TSType"],
+  visitor: ["argument", "qualifier", "typeParameters"],
+  fields: {
+    argument: (0, _utils.validateType)("StringLiteral"),
+    qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+  }
+});
+defineType("TSImportEqualsDeclaration", {
+  aliases: ["Statement"],
+  visitor: ["id", "moduleReference"],
+  fields: {
+    isExport: (0, _utils.validate)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]),
+    importKind: {
+      validate: (0, _utils.assertOneOf)("type", "value"),
+      optional: true
+    }
+  }
+});
+defineType("TSExternalModuleReference", {
+  visitor: ["expression"],
+  fields: {
+    expression: (0, _utils.validateType)("StringLiteral")
+  }
+});
+defineType("TSNonNullExpression", {
+  aliases: ["Expression"],
+  visitor: ["expression"],
+  fields: {
+    expression: (0, _utils.validateType)("Expression")
+  }
+});
+defineType("TSExportAssignment", {
+  aliases: ["Statement"],
+  visitor: ["expression"],
+  fields: {
+    expression: (0, _utils.validateType)("Expression")
+  }
+});
+defineType("TSNamespaceExportDeclaration", {
+  aliases: ["Statement"],
+  visitor: ["id"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier")
+  }
+});
+defineType("TSTypeAnnotation", {
+  visitor: ["typeAnnotation"],
+  fields: {
+    typeAnnotation: {
+      validate: (0, _utils.assertNodeType)("TSType")
+    }
+  }
+});
+defineType("TSTypeParameterInstantiation", {
+  visitor: ["params"],
+  fields: {
+    params: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
+    }
+  }
+});
+defineType("TSTypeParameterDeclaration", {
+  visitor: ["params"],
+  fields: {
+    params: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
+    }
+  }
+});
+defineType("TSTypeParameter", {
+  builder: ["constraint", "default", "name"],
+  visitor: ["constraint", "default"],
+  fields: {
+    name: {
+      validate: (0, _utils.assertValueType)("string")
+    },
+    constraint: {
+      validate: (0, _utils.assertNodeType)("TSType"),
+      optional: true
+    },
+    default: {
+      validate: (0, _utils.assertNodeType)("TSType"),
+      optional: true
+    }
+  }
+});
--- a/node_modules/@babel/types/lib/definitions/utils.js
+++ b/node_modules/@babel/types/lib/definitions/utils.js
@ -0,0 +1,343 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VISITOR_KEYS = exports.NODE_PARENT_VALIDATIONS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.ALIAS_KEYS = void 0;
+exports.arrayOf = arrayOf;
+exports.arrayOfType = arrayOfType;
+exports.assertEach = assertEach;
+exports.assertNodeOrValueType = assertNodeOrValueType;
+exports.assertNodeType = assertNodeType;
+exports.assertOneOf = assertOneOf;
+exports.assertOptionalChainStart = assertOptionalChainStart;
+exports.assertShape = assertShape;
+exports.assertValueType = assertValueType;
+exports.chain = chain;
+exports.default = defineType;
+exports.defineAliasedType = defineAliasedType;
+exports.typeIs = typeIs;
+exports.validate = validate;
+exports.validateArrayOfType = validateArrayOfType;
+exports.validateOptional = validateOptional;
+exports.validateOptionalType = validateOptionalType;
+exports.validateType = validateType;
+
+var _is = require("../validators/is");
+
+var _validate = require("../validators/validate");
+
+const VISITOR_KEYS = {};
+exports.VISITOR_KEYS = VISITOR_KEYS;
+const ALIAS_KEYS = {};
+exports.ALIAS_KEYS = ALIAS_KEYS;
+const FLIPPED_ALIAS_KEYS = {};
+exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
+const NODE_FIELDS = {};
+exports.NODE_FIELDS = NODE_FIELDS;
+const BUILDER_KEYS = {};
+exports.BUILDER_KEYS = BUILDER_KEYS;
+const DEPRECATED_KEYS = {};
+exports.DEPRECATED_KEYS = DEPRECATED_KEYS;
+const NODE_PARENT_VALIDATIONS = {};
+exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
+
+function getType(val) {
+  if (Array.isArray(val)) {
+    return "array";
+  } else if (val === null) {
+    return "null";
+  } else {
+    return typeof val;
+  }
+}
+
+function validate(validate) {
+  return {
+    validate
+  };
+}
+
+function typeIs(typeName) {
+  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
+}
+
+function validateType(typeName) {
+  return validate(typeIs(typeName));
+}
+
+function validateOptional(validate) {
+  return {
+    validate,
+    optional: true
+  };
+}
+
+function validateOptionalType(typeName) {
+  return {
+    validate: typeIs(typeName),
+    optional: true
+  };
+}
+
+function arrayOf(elementType) {
+  return chain(assertValueType("array"), assertEach(elementType));
+}
+
+function arrayOfType(typeName) {
+  return arrayOf(typeIs(typeName));
+}
+
+function validateArrayOfType(typeName) {
+  return validate(arrayOfType(typeName));
+}
+
+function assertEach(callback) {
+  function validator(node, key, val) {
+    if (!Array.isArray(val)) return;
+
+    for (let i = 0; i < val.length; i++) {
+      const subkey = `${key}[${i}]`;
+      const v = val[i];
+      callback(node, subkey, v);
+      if (process.env.BABEL_TYPES_8_BREAKING) (0, _validate.validateChild)(node, subkey, v);
+    }
+  }
+
+  validator.each = callback;
+  return validator;
+}
+
+function assertOneOf(...values) {
+  function validate(node, key, val) {
+    if (values.indexOf(val) < 0) {
+      throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
+    }
+  }
+
+  validate.oneOf = values;
+  return validate;
+}
+
+function assertNodeType(...types) {
+  function validate(node, key, val) {
+    for (const type of types) {
+      if ((0, _is.default)(type, val)) {
+        (0, _validate.validateChild)(node, key, val);
+        return;
+      }
+    }
+
+    throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
+  }
+
+  validate.oneOfNodeTypes = types;
+  return validate;
+}
+
+function assertNodeOrValueType(...types) {
+  function validate(node, key, val) {
+    for (const type of types) {
+      if (getType(val) === type || (0, _is.default)(type, val)) {
+        (0, _validate.validateChild)(node, key, val);
+        return;
+      }
+    }
+
+    throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
+  }
+
+  validate.oneOfNodeOrValueTypes = types;
+  return validate;
+}
+
+function assertValueType(type) {
+  function validate(node, key, val) {
+    const valid = getType(val) === type;
+
+    if (!valid) {
+      throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
+    }
+  }
+
+  validate.type = type;
+  return validate;
+}
+
+function assertShape(shape) {
+  function validate(node, key, val) {
+    const errors = [];
+
+    for (const property of Object.keys(shape)) {
+      try {
+        (0, _validate.validateField)(node, property, val[property], shape[property]);
+      } catch (error) {
+        if (error instanceof TypeError) {
+          errors.push(error.message);
+          continue;
+        }
+
+        throw error;
+      }
+    }
+
+    if (errors.length) {
+      throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`);
+    }
+  }
+
+  validate.shapeOf = shape;
+  return validate;
+}
+
+function assertOptionalChainStart() {
+  function validate(node) {
+    var _current;
+
+    let current = node;
+
+    while (node) {
+      const {
+        type
+      } = current;
+
+      if (type === "OptionalCallExpression") {
+        if (current.optional) return;
+        current = current.callee;
+        continue;
+      }
+
+      if (type === "OptionalMemberExpression") {
+        if (current.optional) return;
+        current = current.object;
+        continue;
+      }
+
+      break;
+    }
+
+    throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`);
+  }
+
+  return validate;
+}
+
+function chain(...fns) {
+  function validate(...args) {
+    for (const fn of fns) {
+      fn(...args);
+    }
+  }
+
+  validate.chainOf = fns;
+
+  if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) {
+    throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`);
+  }
+
+  return validate;
+}
+
+const validTypeOpts = ["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate"];
+const validFieldKeys = ["default", "optional", "validate"];
+
+function defineAliasedType(...aliases) {
+  return (type, opts = {}) => {
+    let defined = opts.aliases;
+
+    if (!defined) {
+      var _store$opts$inherits$, _defined;
+
+      if (opts.inherits) defined = (_store$opts$inherits$ = store[opts.inherits].aliases) == null ? void 0 : _store$opts$inherits$.slice();
+      (_defined = defined) != null ? _defined : defined = [];
+      opts.aliases = defined;
+    }
+
+    const additional = aliases.filter(a => !defined.includes(a));
+    defined.unshift(...additional);
+    return defineType(type, opts);
+  };
+}
+
+function defineType(type, opts = {}) {
+  const inherits = opts.inherits && store[opts.inherits] || {};
+  let fields = opts.fields;
+
+  if (!fields) {
+    fields = {};
+
+    if (inherits.fields) {
+      const keys = Object.getOwnPropertyNames(inherits.fields);
+
+      for (const key of keys) {
+        const field = inherits.fields[key];
+        const def = field.default;
+
+        if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") {
+          throw new Error("field defaults can only be primitives or empty arrays currently");
+        }
+
+        fields[key] = {
+          default: Array.isArray(def) ? [] : def,
+          optional: field.optional,
+          validate: field.validate
+        };
+      }
+    }
+  }
+
+  const visitor = opts.visitor || inherits.visitor || [];
+  const aliases = opts.aliases || inherits.aliases || [];
+  const builder = opts.builder || inherits.builder || opts.visitor || [];
+
+  for (const k of Object.keys(opts)) {
+    if (validTypeOpts.indexOf(k) === -1) {
+      throw new Error(`Unknown type option "${k}" on ${type}`);
+    }
+  }
+
+  if (opts.deprecatedAlias) {
+    DEPRECATED_KEYS[opts.deprecatedAlias] = type;
+  }
+
+  for (const key of visitor.concat(builder)) {
+    fields[key] = fields[key] || {};
+  }
+
+  for (const key of Object.keys(fields)) {
+    const field = fields[key];
+
+    if (field.default !== undefined && builder.indexOf(key) === -1) {
+      field.optional = true;
+    }
+
+    if (field.default === undefined) {
+      field.default = null;
+    } else if (!field.validate && field.default != null) {
+      field.validate = assertValueType(getType(field.default));
+    }
+
+    for (const k of Object.keys(field)) {
+      if (validFieldKeys.indexOf(k) === -1) {
+        throw new Error(`Unknown field key "${k}" on ${type}.${key}`);
+      }
+    }
+  }
+
+  VISITOR_KEYS[type] = opts.visitor = visitor;
+  BUILDER_KEYS[type] = opts.builder = builder;
+  NODE_FIELDS[type] = opts.fields = fields;
+  ALIAS_KEYS[type] = opts.aliases = aliases;
+  aliases.forEach(alias => {
+    FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
+    FLIPPED_ALIAS_KEYS[alias].push(type);
+  });
+
+  if (opts.validate) {
+    NODE_PARENT_VALIDATIONS[type] = opts.validate;
+  }
+
+  store[type] = opts;
+}
+
+const store = {};
--- a/node_modules/@babel/types/lib/index-legacy.d.ts
+++ b/node_modules/@babel/types/lib/index-legacy.d.ts
--- a/node_modules/@babel/types/lib/index.d.ts
+++ b/node_modules/@babel/types/lib/index.d.ts
--- a/node_modules/@babel/types/lib/index.js
+++ b/node_modules/@babel/types/lib/index.js
@ -0,0 +1,647 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  react: true,
+  assertNode: true,
+  createTypeAnnotationBasedOnTypeof: true,
+  createUnionTypeAnnotation: true,
+  createFlowUnionType: true,
+  createTSUnionType: true,
+  cloneNode: true,
+  clone: true,
+  cloneDeep: true,
+  cloneDeepWithoutLoc: true,
+  cloneWithoutLoc: true,
+  addComment: true,
+  addComments: true,
+  inheritInnerComments: true,
+  inheritLeadingComments: true,
+  inheritsComments: true,
+  inheritTrailingComments: true,
+  removeComments: true,
+  ensureBlock: true,
+  toBindingIdentifierName: true,
+  toBlock: true,
+  toComputedKey: true,
+  toExpression: true,
+  toIdentifier: true,
+  toKeyAlias: true,
+  toSequenceExpression: true,
+  toStatement: true,
+  valueToNode: true,
+  appendToMemberExpression: true,
+  inherits: true,
+  prependToMemberExpression: true,
+  removeProperties: true,
+  removePropertiesDeep: true,
+  removeTypeDuplicates: true,
+  getBindingIdentifiers: true,
+  getOuterBindingIdentifiers: true,
+  traverse: true,
+  traverseFast: true,
+  shallowEqual: true,
+  is: true,
+  isBinding: true,
+  isBlockScoped: true,
+  isImmutable: true,
+  isLet: true,
+  isNode: true,
+  isNodesEquivalent: true,
+  isPlaceholderType: true,
+  isReferenced: true,
+  isScope: true,
+  isSpecifierDefault: true,
+  isType: true,
+  isValidES3Identifier: true,
+  isValidIdentifier: true,
+  isVar: true,
+  matchesPattern: true,
+  validate: true,
+  buildMatchMemberExpression: true
+};
+Object.defineProperty(exports, "addComment", {
+  enumerable: true,
+  get: function () {
+    return _addComment.default;
+  }
+});
+Object.defineProperty(exports, "addComments", {
+  enumerable: true,
+  get: function () {
+    return _addComments.default;
+  }
+});
+Object.defineProperty(exports, "appendToMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _appendToMemberExpression.default;
+  }
+});
+Object.defineProperty(exports, "assertNode", {
+  enumerable: true,
+  get: function () {
+    return _assertNode.default;
+  }
+});
+Object.defineProperty(exports, "buildMatchMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _buildMatchMemberExpression.default;
+  }
+});
+Object.defineProperty(exports, "clone", {
+  enumerable: true,
+  get: function () {
+    return _clone.default;
+  }
+});
+Object.defineProperty(exports, "cloneDeep", {
+  enumerable: true,
+  get: function () {
+    return _cloneDeep.default;
+  }
+});
+Object.defineProperty(exports, "cloneDeepWithoutLoc", {
+  enumerable: true,
+  get: function () {
+    return _cloneDeepWithoutLoc.default;
+  }
+});
+Object.defineProperty(exports, "cloneNode", {
+  enumerable: true,
+  get: function () {
+    return _cloneNode.default;
+  }
+});
+Object.defineProperty(exports, "cloneWithoutLoc", {
+  enumerable: true,
+  get: function () {
+    return _cloneWithoutLoc.default;
+  }
+});
+Object.defineProperty(exports, "createFlowUnionType", {
+  enumerable: true,
+  get: function () {
+    return _createFlowUnionType.default;
+  }
+});
+Object.defineProperty(exports, "createTSUnionType", {
+  enumerable: true,
+  get: function () {
+    return _createTSUnionType.default;
+  }
+});
+Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
+  enumerable: true,
+  get: function () {
+    return _createTypeAnnotationBasedOnTypeof.default;
+  }
+});
+Object.defineProperty(exports, "createUnionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _createFlowUnionType.default;
+  }
+});
+Object.defineProperty(exports, "ensureBlock", {
+  enumerable: true,
+  get: function () {
+    return _ensureBlock.default;
+  }
+});
+Object.defineProperty(exports, "getBindingIdentifiers", {
+  enumerable: true,
+  get: function () {
+    return _getBindingIdentifiers.default;
+  }
+});
+Object.defineProperty(exports, "getOuterBindingIdentifiers", {
+  enumerable: true,
+  get: function () {
+    return _getOuterBindingIdentifiers.default;
+  }
+});
+Object.defineProperty(exports, "inheritInnerComments", {
+  enumerable: true,
+  get: function () {
+    return _inheritInnerComments.default;
+  }
+});
+Object.defineProperty(exports, "inheritLeadingComments", {
+  enumerable: true,
+  get: function () {
+    return _inheritLeadingComments.default;
+  }
+});
+Object.defineProperty(exports, "inheritTrailingComments", {
+  enumerable: true,
+  get: function () {
+    return _inheritTrailingComments.default;
+  }
+});
+Object.defineProperty(exports, "inherits", {
+  enumerable: true,
+  get: function () {
+    return _inherits.default;
+  }
+});
+Object.defineProperty(exports, "inheritsComments", {
+  enumerable: true,
+  get: function () {
+    return _inheritsComments.default;
+  }
+});
+Object.defineProperty(exports, "is", {
+  enumerable: true,
+  get: function () {
+    return _is.default;
+  }
+});
+Object.defineProperty(exports, "isBinding", {
+  enumerable: true,
+  get: function () {
+    return _isBinding.default;
+  }
+});
+Object.defineProperty(exports, "isBlockScoped", {
+  enumerable: true,
+  get: function () {
+    return _isBlockScoped.default;
+  }
+});
+Object.defineProperty(exports, "isImmutable", {
+  enumerable: true,
+  get: function () {
+    return _isImmutable.default;
+  }
+});
+Object.defineProperty(exports, "isLet", {
+  enumerable: true,
+  get: function () {
+    return _isLet.default;
+  }
+});
+Object.defineProperty(exports, "isNode", {
+  enumerable: true,
+  get: function () {
+    return _isNode.default;
+  }
+});
+Object.defineProperty(exports, "isNodesEquivalent", {
+  enumerable: true,
+  get: function () {
+    return _isNodesEquivalent.default;
+  }
+});
+Object.defineProperty(exports, "isPlaceholderType", {
+  enumerable: true,
+  get: function () {
+    return _isPlaceholderType.default;
+  }
+});
+Object.defineProperty(exports, "isReferenced", {
+  enumerable: true,
+  get: function () {
+    return _isReferenced.default;
+  }
+});
+Object.defineProperty(exports, "isScope", {
+  enumerable: true,
+  get: function () {
+    return _isScope.default;
+  }
+});
+Object.defineProperty(exports, "isSpecifierDefault", {
+  enumerable: true,
+  get: function () {
+    return _isSpecifierDefault.default;
+  }
+});
+Object.defineProperty(exports, "isType", {
+  enumerable: true,
+  get: function () {
+    return _isType.default;
+  }
+});
+Object.defineProperty(exports, "isValidES3Identifier", {
+  enumerable: true,
+  get: function () {
+    return _isValidES3Identifier.default;
+  }
+});
+Object.defineProperty(exports, "isValidIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _isValidIdentifier.default;
+  }
+});
+Object.defineProperty(exports, "isVar", {
+  enumerable: true,
+  get: function () {
+    return _isVar.default;
+  }
+});
+Object.defineProperty(exports, "matchesPattern", {
+  enumerable: true,
+  get: function () {
+    return _matchesPattern.default;
+  }
+});
+Object.defineProperty(exports, "prependToMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _prependToMemberExpression.default;
+  }
+});
+exports.react = void 0;
+Object.defineProperty(exports, "removeComments", {
+  enumerable: true,
+  get: function () {
+    return _removeComments.default;
+  }
+});
+Object.defineProperty(exports, "removeProperties", {
+  enumerable: true,
+  get: function () {
+    return _removeProperties.default;
+  }
+});
+Object.defineProperty(exports, "removePropertiesDeep", {
+  enumerable: true,
+  get: function () {
+    return _removePropertiesDeep.default;
+  }
+});
+Object.defineProperty(exports, "removeTypeDuplicates", {
+  enumerable: true,
+  get: function () {
+    return _removeTypeDuplicates.default;
+  }
+});
+Object.defineProperty(exports, "shallowEqual", {
+  enumerable: true,
+  get: function () {
+    return _shallowEqual.default;
+  }
+});
+Object.defineProperty(exports, "toBindingIdentifierName", {
+  enumerable: true,
+  get: function () {
+    return _toBindingIdentifierName.default;
+  }
+});
+Object.defineProperty(exports, "toBlock", {
+  enumerable: true,
+  get: function () {
+    return _toBlock.default;
+  }
+});
+Object.defineProperty(exports, "toComputedKey", {
+  enumerable: true,
+  get: function () {
+    return _toComputedKey.default;
+  }
+});
+Object.defineProperty(exports, "toExpression", {
+  enumerable: true,
+  get: function () {
+    return _toExpression.default;
+  }
+});
+Object.defineProperty(exports, "toIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _toIdentifier.default;
+  }
+});
+Object.defineProperty(exports, "toKeyAlias", {
+  enumerable: true,
+  get: function () {
+    return _toKeyAlias.default;
+  }
+});
+Object.defineProperty(exports, "toSequenceExpression", {
+  enumerable: true,
+  get: function () {
+    return _toSequenceExpression.default;
+  }
+});
+Object.defineProperty(exports, "toStatement", {
+  enumerable: true,
+  get: function () {
+    return _toStatement.default;
+  }
+});
+Object.defineProperty(exports, "traverse", {
+  enumerable: true,
+  get: function () {
+    return _traverse.default;
+  }
+});
+Object.defineProperty(exports, "traverseFast", {
+  enumerable: true,
+  get: function () {
+    return _traverseFast.default;
+  }
+});
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () {
+    return _validate.default;
+  }
+});
+Object.defineProperty(exports, "valueToNode", {
+  enumerable: true,
+  get: function () {
+    return _valueToNode.default;
+  }
+});
+
+var _isReactComponent = require("./validators/react/isReactComponent");
+
+var _isCompatTag = require("./validators/react/isCompatTag");
+
+var _buildChildren = require("./builders/react/buildChildren");
+
+var _assertNode = require("./asserts/assertNode");
+
+var _generated = require("./asserts/generated");
+
+Object.keys(_generated).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generated[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generated[key];
+    }
+  });
+});
+
+var _createTypeAnnotationBasedOnTypeof = require("./builders/flow/createTypeAnnotationBasedOnTypeof");
+
+var _createFlowUnionType = require("./builders/flow/createFlowUnionType");
+
+var _createTSUnionType = require("./builders/typescript/createTSUnionType");
+
+var _generated2 = require("./builders/generated");
+
+Object.keys(_generated2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generated2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generated2[key];
+    }
+  });
+});
+
+var _uppercase = require("./builders/generated/uppercase");
+
+Object.keys(_uppercase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _uppercase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _uppercase[key];
+    }
+  });
+});
+
+var _cloneNode = require("./clone/cloneNode");
+
+var _clone = require("./clone/clone");
+
+var _cloneDeep = require("./clone/cloneDeep");
+
+var _cloneDeepWithoutLoc = require("./clone/cloneDeepWithoutLoc");
+
+var _cloneWithoutLoc = require("./clone/cloneWithoutLoc");
+
+var _addComment = require("./comments/addComment");
+
+var _addComments = require("./comments/addComments");
+
+var _inheritInnerComments = require("./comments/inheritInnerComments");
+
+var _inheritLeadingComments = require("./comments/inheritLeadingComments");
+
+var _inheritsComments = require("./comments/inheritsComments");
+
+var _inheritTrailingComments = require("./comments/inheritTrailingComments");
+
+var _removeComments = require("./comments/removeComments");
+
+var _generated3 = require("./constants/generated");
+
+Object.keys(_generated3).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generated3[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generated3[key];
+    }
+  });
+});
+
+var _constants = require("./constants");
+
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _constants[key];
+    }
+  });
+});
+
+var _ensureBlock = require("./converters/ensureBlock");
+
+var _toBindingIdentifierName = require("./converters/toBindingIdentifierName");
+
+var _toBlock = require("./converters/toBlock");
+
+var _toComputedKey = require("./converters/toComputedKey");
+
+var _toExpression = require("./converters/toExpression");
+
+var _toIdentifier = require("./converters/toIdentifier");
+
+var _toKeyAlias = require("./converters/toKeyAlias");
+
+var _toSequenceExpression = require("./converters/toSequenceExpression");
+
+var _toStatement = require("./converters/toStatement");
+
+var _valueToNode = require("./converters/valueToNode");
+
+var _definitions = require("./definitions");
+
+Object.keys(_definitions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _definitions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _definitions[key];
+    }
+  });
+});
+
+var _appendToMemberExpression = require("./modifications/appendToMemberExpression");
+
+var _inherits = require("./modifications/inherits");
+
+var _prependToMemberExpression = require("./modifications/prependToMemberExpression");
+
+var _removeProperties = require("./modifications/removeProperties");
+
+var _removePropertiesDeep = require("./modifications/removePropertiesDeep");
+
+var _removeTypeDuplicates = require("./modifications/flow/removeTypeDuplicates");
+
+var _getBindingIdentifiers = require("./retrievers/getBindingIdentifiers");
+
+var _getOuterBindingIdentifiers = require("./retrievers/getOuterBindingIdentifiers");
+
+var _traverse = require("./traverse/traverse");
+
+Object.keys(_traverse).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _traverse[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _traverse[key];
+    }
+  });
+});
+
+var _traverseFast = require("./traverse/traverseFast");
+
+var _shallowEqual = require("./utils/shallowEqual");
+
+var _is = require("./validators/is");
+
+var _isBinding = require("./validators/isBinding");
+
+var _isBlockScoped = require("./validators/isBlockScoped");
+
+var _isImmutable = require("./validators/isImmutable");
+
+var _isLet = require("./validators/isLet");
+
+var _isNode = require("./validators/isNode");
+
+var _isNodesEquivalent = require("./validators/isNodesEquivalent");
+
+var _isPlaceholderType = require("./validators/isPlaceholderType");
+
+var _isReferenced = require("./validators/isReferenced");
+
+var _isScope = require("./validators/isScope");
+
+var _isSpecifierDefault = require("./validators/isSpecifierDefault");
+
+var _isType = require("./validators/isType");
+
+var _isValidES3Identifier = require("./validators/isValidES3Identifier");
+
+var _isValidIdentifier = require("./validators/isValidIdentifier");
+
+var _isVar = require("./validators/isVar");
+
+var _matchesPattern = require("./validators/matchesPattern");
+
+var _validate = require("./validators/validate");
+
+var _buildMatchMemberExpression = require("./validators/buildMatchMemberExpression");
+
+var _generated4 = require("./validators/generated");
+
+Object.keys(_generated4).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generated4[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generated4[key];
+    }
+  });
+});
+
+var _generated5 = require("./ast-types/generated");
+
+Object.keys(_generated5).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generated5[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generated5[key];
+    }
+  });
+});
+const react = {
+  isReactComponent: _isReactComponent.default,
+  isCompatTag: _isCompatTag.default,
+  buildChildren: _buildChildren.default
+};
+exports.react = react;
--- a/node_modules/@babel/types/lib/index.js.flow
+++ b/node_modules/@babel/types/lib/index.js.flow
--- a/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js
+++ b/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js
@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = appendToMemberExpression;
+
+var _generated = require("../builders/generated");
+
+function appendToMemberExpression(member, append, computed = false) {
+  member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed);
+  member.property = append;
+  member.computed = !!computed;
+  return member;
+}
--- a/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js
+++ b/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js
@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeTypeDuplicates;
+
+var _generated = require("../../validators/generated");
+
+function getQualifiedName(node) {
+  return (0, _generated.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
+}
+
+function removeTypeDuplicates(nodes) {
+  const generics = {};
+  const bases = {};
+  const typeGroups = new Set();
+  const types = [];
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (!node) continue;
+
+    if (types.indexOf(node) >= 0) {
+      continue;
+    }
+
+    if ((0, _generated.isAnyTypeAnnotation)(node)) {
+      return [node];
+    }
+
+    if ((0, _generated.isFlowBaseAnnotation)(node)) {
+      bases[node.type] = node;
+      continue;
+    }
+
+    if ((0, _generated.isUnionTypeAnnotation)(node)) {
+      if (!typeGroups.has(node.types)) {
+        nodes = nodes.concat(node.types);
+        typeGroups.add(node.types);
+      }
+
+      continue;
+    }
+
+    if ((0, _generated.isGenericTypeAnnotation)(node)) {
+      const name = getQualifiedName(node.id);
+
+      if (generics[name]) {
+        let existing = generics[name];
+
+        if (existing.typeParameters) {
+          if (node.typeParameters) {
+            existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params));
+          }
+        } else {
+          existing = node.typeParameters;
+        }
+      } else {
+        generics[name] = node;
+      }
+
+      continue;
+    }
+
+    types.push(node);
+  }
+
+  for (const type of Object.keys(bases)) {
+    types.push(bases[type]);
+  }
+
+  for (const name of Object.keys(generics)) {
+    types.push(generics[name]);
+  }
+
+  return types;
+}
--- a/node_modules/@babel/types/lib/modifications/inherits.js
+++ b/node_modules/@babel/types/lib/modifications/inherits.js
@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inherits;
+
+var _constants = require("../constants");
+
+var _inheritsComments = require("../comments/inheritsComments");
+
+function inherits(child, parent) {
+  if (!child || !parent) return child;
+
+  for (const key of _constants.INHERIT_KEYS.optional) {
+    if (child[key] == null) {
+      child[key] = parent[key];
+    }
+  }
+
+  for (const key of Object.keys(parent)) {
+    if (key[0] === "_" && key !== "__clone") child[key] = parent[key];
+  }
+
+  for (const key of _constants.INHERIT_KEYS.force) {
+    child[key] = parent[key];
+  }
+
+  (0, _inheritsComments.default)(child, parent);
+  return child;
+}
--- a/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js
+++ b/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js
@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = prependToMemberExpression;
+
+var _generated = require("../builders/generated");
+
+function prependToMemberExpression(member, prepend) {
+  member.object = (0, _generated.memberExpression)(prepend, member.object);
+  return member;
+}
--- a/node_modules/@babel/types/lib/modifications/removeProperties.js
+++ b/node_modules/@babel/types/lib/modifications/removeProperties.js
@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeProperties;
+
+var _constants = require("../constants");
+
+const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
+
+const CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
+
+function removeProperties(node, opts = {}) {
+  const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
+
+  for (const key of map) {
+    if (node[key] != null) node[key] = undefined;
+  }
+
+  for (const key of Object.keys(node)) {
+    if (key[0] === "_" && node[key] != null) node[key] = undefined;
+  }
+
+  const symbols = Object.getOwnPropertySymbols(node);
+
+  for (const sym of symbols) {
+    node[sym] = null;
+  }
+}
--- a/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js
+++ b/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js
@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removePropertiesDeep;
+
+var _traverseFast = require("../traverse/traverseFast");
+
+var _removeProperties = require("./removeProperties");
+
+function removePropertiesDeep(tree, opts) {
+  (0, _traverseFast.default)(tree, _removeProperties.default, opts);
+  return tree;
+}
--- a/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js
+++ b/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js
@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeTypeDuplicates;
+
+var _generated = require("../../validators/generated");
+
+function removeTypeDuplicates(nodes) {
+  const generics = {};
+  const bases = {};
+  const typeGroups = new Set();
+  const types = [];
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (!node) continue;
+
+    if (types.indexOf(node) >= 0) {
+      continue;
+    }
+
+    if ((0, _generated.isTSAnyKeyword)(node)) {
+      return [node];
+    }
+
+    if ((0, _generated.isTSBaseType)(node)) {
+      bases[node.type] = node;
+      continue;
+    }
+
+    if ((0, _generated.isTSUnionType)(node)) {
+      if (!typeGroups.has(node.types)) {
+        nodes.push(...node.types);
+        typeGroups.add(node.types);
+      }
+
+      continue;
+    }
+
+    types.push(node);
+  }
+
+  for (const type of Object.keys(bases)) {
+    types.push(bases[type]);
+  }
+
+  for (const name of Object.keys(generics)) {
+    types.push(generics[name]);
+  }
+
+  return types;
+}
--- a/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js
+++ b/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js
@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getBindingIdentifiers;
+
+var _generated = require("../validators/generated");
+
+function getBindingIdentifiers(node, duplicates, outerOnly) {
+  let search = [].concat(node);
+  const ids = Object.create(null);
+
+  while (search.length) {
+    const id = search.shift();
+    if (!id) continue;
+    const keys = getBindingIdentifiers.keys[id.type];
+
+    if ((0, _generated.isIdentifier)(id)) {
+      if (duplicates) {
+        const _ids = ids[id.name] = ids[id.name] || [];
+
+        _ids.push(id);
+      } else {
+        ids[id.name] = id;
+      }
+
+      continue;
+    }
+
+    if ((0, _generated.isExportDeclaration)(id) && !(0, _generated.isExportAllDeclaration)(id)) {
+      if ((0, _generated.isDeclaration)(id.declaration)) {
+        search.push(id.declaration);
+      }
+
+      continue;
+    }
+
+    if (outerOnly) {
+      if ((0, _generated.isFunctionDeclaration)(id)) {
+        search.push(id.id);
+        continue;
+      }
+
+      if ((0, _generated.isFunctionExpression)(id)) {
+        continue;
+      }
+    }
+
+    if (keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+
+        if (id[key]) {
+          search = search.concat(id[key]);
+        }
+      }
+    }
+  }
+
+  return ids;
+}
+
+getBindingIdentifiers.keys = {
+  DeclareClass: ["id"],
+  DeclareFunction: ["id"],
+  DeclareModule: ["id"],
+  DeclareVariable: ["id"],
+  DeclareInterface: ["id"],
+  DeclareTypeAlias: ["id"],
+  DeclareOpaqueType: ["id"],
+  InterfaceDeclaration: ["id"],
+  TypeAlias: ["id"],
+  OpaqueType: ["id"],
+  CatchClause: ["param"],
+  LabeledStatement: ["label"],
+  UnaryExpression: ["argument"],
+  AssignmentExpression: ["left"],
+  ImportSpecifier: ["local"],
+  ImportNamespaceSpecifier: ["local"],
+  ImportDefaultSpecifier: ["local"],
+  ImportDeclaration: ["specifiers"],
+  ExportSpecifier: ["exported"],
+  ExportNamespaceSpecifier: ["exported"],
+  ExportDefaultSpecifier: ["exported"],
+  FunctionDeclaration: ["id", "params"],
+  FunctionExpression: ["id", "params"],
+  ArrowFunctionExpression: ["params"],
+  ObjectMethod: ["params"],
+  ClassMethod: ["params"],
+  ClassPrivateMethod: ["params"],
+  ForInStatement: ["left"],
+  ForOfStatement: ["left"],
+  ClassDeclaration: ["id"],
+  ClassExpression: ["id"],
+  RestElement: ["argument"],
+  UpdateExpression: ["argument"],
+  ObjectProperty: ["value"],
+  AssignmentPattern: ["left"],
+  ArrayPattern: ["elements"],
+  ObjectPattern: ["properties"],
+  VariableDeclaration: ["declarations"],
+  VariableDeclarator: ["id"]
+};
--- a/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js
+++ b/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js
@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _getBindingIdentifiers = require("./getBindingIdentifiers");
+
+var _default = getOuterBindingIdentifiers;
+exports.default = _default;
+
+function getOuterBindingIdentifiers(node, duplicates) {
+  return (0, _getBindingIdentifiers.default)(node, duplicates, true);
+}
--- a/node_modules/@babel/types/lib/traverse/traverse.js
+++ b/node_modules/@babel/types/lib/traverse/traverse.js
@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = traverse;
+
+var _definitions = require("../definitions");
+
+function traverse(node, handlers, state) {
+  if (typeof handlers === "function") {
+    handlers = {
+      enter: handlers
+    };
+  }
+
+  const {
+    enter,
+    exit
+  } = handlers;
+  traverseSimpleImpl(node, enter, exit, state, []);
+}
+
+function traverseSimpleImpl(node, enter, exit, state, ancestors) {
+  const keys = _definitions.VISITOR_KEYS[node.type];
+  if (!keys) return;
+  if (enter) enter(node, ancestors, state);
+
+  for (const key of keys) {
+    const subNode = node[key];
+
+    if (Array.isArray(subNode)) {
+      for (let i = 0; i < subNode.length; i++) {
+        const child = subNode[i];
+        if (!child) continue;
+        ancestors.push({
+          node,
+          key,
+          index: i
+        });
+        traverseSimpleImpl(child, enter, exit, state, ancestors);
+        ancestors.pop();
+      }
+    } else if (subNode) {
+      ancestors.push({
+        node,
+        key
+      });
+      traverseSimpleImpl(subNode, enter, exit, state, ancestors);
+      ancestors.pop();
+    }
+  }
+
+  if (exit) exit(node, ancestors, state);
+}
--- a/node_modules/@babel/types/lib/traverse/traverseFast.js
+++ b/node_modules/@babel/types/lib/traverse/traverseFast.js
@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = traverseFast;
+
+var _definitions = require("../definitions");
+
+function traverseFast(node, enter, opts) {
+  if (!node) return;
+  const keys = _definitions.VISITOR_KEYS[node.type];
+  if (!keys) return;
+  opts = opts || {};
+  enter(node, opts);
+
+  for (const key of keys) {
+    const subNode = node[key];
+
+    if (Array.isArray(subNode)) {
+      for (const node of subNode) {
+        traverseFast(node, enter, opts);
+      }
+    } else {
+      traverseFast(subNode, enter, opts);
+    }
+  }
+}
--- a/node_modules/@babel/types/lib/utils/inherit.js
+++ b/node_modules/@babel/types/lib/utils/inherit.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inherit;
+
+function inherit(key, child, parent) {
+  if (child && parent) {
+    child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean)));
+  }
+}
--- a/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js
+++ b/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js
@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cleanJSXElementLiteralChild;
+
+var _generated = require("../../builders/generated");
+
+function cleanJSXElementLiteralChild(child, args) {
+  const lines = child.value.split(/\r\n|\n|\r/);
+  let lastNonEmptyLine = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/[^ \t]/)) {
+      lastNonEmptyLine = i;
+    }
+  }
+
+  let str = "";
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isFirstLine = i === 0;
+    const isLastLine = i === lines.length - 1;
+    const isLastNonEmptyLine = i === lastNonEmptyLine;
+    let trimmedLine = line.replace(/\t/g, " ");
+
+    if (!isFirstLine) {
+      trimmedLine = trimmedLine.replace(/^[ ]+/, "");
+    }
+
+    if (!isLastLine) {
+      trimmedLine = trimmedLine.replace(/[ ]+$/, "");
+    }
+
+    if (trimmedLine) {
+      if (!isLastNonEmptyLine) {
+        trimmedLine += " ";
+      }
+
+      str += trimmedLine;
+    }
+  }
+
+  if (str) args.push((0, _generated.stringLiteral)(str));
+}
--- a/node_modules/@babel/types/lib/utils/shallowEqual.js
+++ b/node_modules/@babel/types/lib/utils/shallowEqual.js
@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = shallowEqual;
+
+function shallowEqual(actual, expected) {
+  const keys = Object.keys(expected);
+
+  for (const key of keys) {
+    if (actual[key] !== expected[key]) {
+      return false;
+    }
+  }
+
+  return true;
+}
--- a/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js
+++ b/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js
@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildMatchMemberExpression;
+
+var _matchesPattern = require("./matchesPattern");
+
+function buildMatchMemberExpression(match, allowPartial) {
+  const parts = match.split(".");
+  return member => (0, _matchesPattern.default)(member, parts, allowPartial);
+}
--- a/node_modules/@babel/types/lib/validators/generated/index.js
+++ b/node_modules/@babel/types/lib/validators/generated/index.js
--- a/node_modules/@babel/types/lib/validators/is.js
+++ b/node_modules/@babel/types/lib/validators/is.js
@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = is;
+
+var _shallowEqual = require("../utils/shallowEqual");
+
+var _isType = require("./isType");
+
+var _isPlaceholderType = require("./isPlaceholderType");
+
+var _definitions = require("../definitions");
+
+function is(type, node, opts) {
+  if (!node) return false;
+  const matches = (0, _isType.default)(node.type, type);
+
+  if (!matches) {
+    if (!opts && node.type === "Placeholder" && type in _definitions.FLIPPED_ALIAS_KEYS) {
+      return (0, _isPlaceholderType.default)(node.expectedNode, type);
+    }
+
+    return false;
+  }
+
+  if (typeof opts === "undefined") {
+    return true;
+  } else {
+    return (0, _shallowEqual.default)(node, opts);
+  }
+}
--- a/node_modules/@babel/types/lib/validators/isBinding.js
+++ b/node_modules/@babel/types/lib/validators/isBinding.js
@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isBinding;
+
+var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers");
+
+function isBinding(node, parent, grandparent) {
+  if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") {
+    return false;
+  }
+
+  const keys = _getBindingIdentifiers.default.keys[parent.type];
+
+  if (keys) {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const val = parent[key];
+
+      if (Array.isArray(val)) {
+        if (val.indexOf(node) >= 0) return true;
+      } else {
+        if (val === node) return true;
+      }
+    }
+  }
+
+  return false;
+}
--- a/node_modules/@babel/types/lib/validators/isBlockScoped.js
+++ b/node_modules/@babel/types/lib/validators/isBlockScoped.js
@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isBlockScoped;
+
+var _generated = require("./generated");
+
+var _isLet = require("./isLet");
+
+function isBlockScoped(node) {
+  return (0, _generated.isFunctionDeclaration)(node) || (0, _generated.isClassDeclaration)(node) || (0, _isLet.default)(node);
+}
--- a/node_modules/@babel/types/lib/validators/isImmutable.js
+++ b/node_modules/@babel/types/lib/validators/isImmutable.js
@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isImmutable;
+
+var _isType = require("./isType");
+
+var _generated = require("./generated");
+
+function isImmutable(node) {
+  if ((0, _isType.default)(node.type, "Immutable")) return true;
+
+  if ((0, _generated.isIdentifier)(node)) {
+    if (node.name === "undefined") {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  return false;
+}
--- a/node_modules/@babel/types/lib/validators/isLet.js
+++ b/node_modules/@babel/types/lib/validators/isLet.js
@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isLet;
+
+var _generated = require("./generated");
+
+var _constants = require("../constants");
+
+function isLet(node) {
+  return (0, _generated.isVariableDeclaration)(node) && (node.kind !== "var" || node[_constants.BLOCK_SCOPED_SYMBOL]);
+}
--- a/node_modules/@babel/types/lib/validators/isNode.js
+++ b/node_modules/@babel/types/lib/validators/isNode.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNode;
+
+var _definitions = require("../definitions");
+
+function isNode(node) {
+  return !!(node && _definitions.VISITOR_KEYS[node.type]);
+}
--- a/node_modules/@babel/types/lib/validators/isNodesEquivalent.js
+++ b/node_modules/@babel/types/lib/validators/isNodesEquivalent.js
@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNodesEquivalent;
+
+var _definitions = require("../definitions");
+
+function isNodesEquivalent(a, b) {
+  if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
+    return a === b;
+  }
+
+  if (a.type !== b.type) {
+    return false;
+  }
+
+  const fields = Object.keys(_definitions.NODE_FIELDS[a.type] || a.type);
+  const visitorKeys = _definitions.VISITOR_KEYS[a.type];
+
+  for (const field of fields) {
+    if (typeof a[field] !== typeof b[field]) {
+      return false;
+    }
+
+    if (a[field] == null && b[field] == null) {
+      continue;
+    } else if (a[field] == null || b[field] == null) {
+      return false;
+    }
+
+    if (Array.isArray(a[field])) {
+      if (!Array.isArray(b[field])) {
+        return false;
+      }
+
+      if (a[field].length !== b[field].length) {
+        return false;
+      }
+
+      for (let i = 0; i < a[field].length; i++) {
+        if (!isNodesEquivalent(a[field][i], b[field][i])) {
+          return false;
+        }
+      }
+
+      continue;
+    }
+
+    if (typeof a[field] === "object" && !(visitorKeys != null && visitorKeys.includes(field))) {
+      for (const key of Object.keys(a[field])) {
+        if (a[field][key] !== b[field][key]) {
+          return false;
+        }
+      }
+
+      continue;
+    }
+
+    if (!isNodesEquivalent(a[field], b[field])) {
+      return false;
+    }
+  }
+
+  return true;
+}
--- a/node_modules/@babel/types/lib/validators/isPlaceholderType.js
+++ b/node_modules/@babel/types/lib/validators/isPlaceholderType.js
@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isPlaceholderType;
+
+var _definitions = require("../definitions");
+
+function isPlaceholderType(placeholderType, targetType) {
+  if (placeholderType === targetType) return true;
+  const aliases = _definitions.PLACEHOLDERS_ALIAS[placeholderType];
+
+  if (aliases) {
+    for (const alias of aliases) {
+      if (targetType === alias) return true;
+    }
+  }
+
+  return false;
+}
--- a/node_modules/@babel/types/lib/validators/isReferenced.js
+++ b/node_modules/@babel/types/lib/validators/isReferenced.js
@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isReferenced;
+
+function isReferenced(node, parent, grandparent) {
+  switch (parent.type) {
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      if (parent.property === node) {
+        return !!parent.computed;
+      }
+
+      return parent.object === node;
+
+    case "JSXMemberExpression":
+      return parent.object === node;
+
+    case "VariableDeclarator":
+      return parent.init === node;
+
+    case "ArrowFunctionExpression":
+      return parent.body === node;
+
+    case "PrivateName":
+      return false;
+
+    case "ClassMethod":
+    case "ClassPrivateMethod":
+    case "ObjectMethod":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+
+      return false;
+
+    case "ObjectProperty":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+
+      return !grandparent || grandparent.type !== "ObjectPattern";
+
+    case "ClassProperty":
+    case "ClassAccessorProperty":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+
+      return true;
+
+    case "ClassPrivateProperty":
+      return parent.key !== node;
+
+    case "ClassDeclaration":
+    case "ClassExpression":
+      return parent.superClass === node;
+
+    case "AssignmentExpression":
+      return parent.right === node;
+
+    case "AssignmentPattern":
+      return parent.right === node;
+
+    case "LabeledStatement":
+      return false;
+
+    case "CatchClause":
+      return false;
+
+    case "RestElement":
+      return false;
+
+    case "BreakStatement":
+    case "ContinueStatement":
+      return false;
+
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+      return false;
+
+    case "ExportNamespaceSpecifier":
+    case "ExportDefaultSpecifier":
+      return false;
+
+    case "ExportSpecifier":
+      if (grandparent != null && grandparent.source) {
+        return false;
+      }
+
+      return parent.local === node;
+
+    case "ImportDefaultSpecifier":
+    case "ImportNamespaceSpecifier":
+    case "ImportSpecifier":
+      return false;
+
+    case "ImportAttribute":
+      return false;
+
+    case "JSXAttribute":
+      return false;
+
+    case "ObjectPattern":
+    case "ArrayPattern":
+      return false;
+
+    case "MetaProperty":
+      return false;
+
+    case "ObjectTypeProperty":
+      return parent.key !== node;
+
+    case "TSEnumMember":
+      return parent.id !== node;
+
+    case "TSPropertySignature":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+
+      return true;
+  }
+
+  return true;
+}
--- a/node_modules/@babel/types/lib/validators/isScope.js
+++ b/node_modules/@babel/types/lib/validators/isScope.js
@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isScope;
+
+var _generated = require("./generated");
+
+function isScope(node, parent) {
+  if ((0, _generated.isBlockStatement)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) {
+    return false;
+  }
+
+  if ((0, _generated.isPattern)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) {
+    return true;
+  }
+
+  return (0, _generated.isScopable)(node);
+}
--- a/node_modules/@babel/types/lib/validators/isSpecifierDefault.js
+++ b/node_modules/@babel/types/lib/validators/isSpecifierDefault.js
@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isSpecifierDefault;
+
+var _generated = require("./generated");
+
+function isSpecifierDefault(specifier) {
+  return (0, _generated.isImportDefaultSpecifier)(specifier) || (0, _generated.isIdentifier)(specifier.imported || specifier.exported, {
+    name: "default"
+  });
+}
--- a/node_modules/@babel/types/lib/validators/isType.js
+++ b/node_modules/@babel/types/lib/validators/isType.js
@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isType;
+
+var _definitions = require("../definitions");
+
+function isType(nodeType, targetType) {
+  if (nodeType === targetType) return true;
+  if (_definitions.ALIAS_KEYS[targetType]) return false;
+  const aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType];
+
+  if (aliases) {
+    if (aliases[0] === nodeType) return true;
+
+    for (const alias of aliases) {
+      if (nodeType === alias) return true;
+    }
+  }
+
+  return false;
+}
--- a/node_modules/@babel/types/lib/validators/isValidES3Identifier.js
+++ b/node_modules/@babel/types/lib/validators/isValidES3Identifier.js
@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isValidES3Identifier;
+
+var _isValidIdentifier = require("./isValidIdentifier");
+
+const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]);
+
+function isValidES3Identifier(name) {
+  return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
+}
--- a/node_modules/@babel/types/lib/validators/isValidIdentifier.js
+++ b/node_modules/@babel/types/lib/validators/isValidIdentifier.js
@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isValidIdentifier;
+
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+
+function isValidIdentifier(name, reserved = true) {
+  if (typeof name !== "string") return false;
+
+  if (reserved) {
+    if ((0, _helperValidatorIdentifier.isKeyword)(name) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name, true)) {
+      return false;
+    }
+  }
+
+  return (0, _helperValidatorIdentifier.isIdentifierName)(name);
+}
--- a/node_modules/@babel/types/lib/validators/isVar.js
+++ b/node_modules/@babel/types/lib/validators/isVar.js
@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isVar;
+
+var _generated = require("./generated");
+
+var _constants = require("../constants");
+
+function isVar(node) {
+  return (0, _generated.isVariableDeclaration)(node, {
+    kind: "var"
+  }) && !node[_constants.BLOCK_SCOPED_SYMBOL];
+}
--- a/node_modules/@babel/types/lib/validators/matchesPattern.js
+++ b/node_modules/@babel/types/lib/validators/matchesPattern.js
@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = matchesPattern;
+
+var _generated = require("./generated");
+
+function matchesPattern(member, match, allowPartial) {
+  if (!(0, _generated.isMemberExpression)(member)) return false;
+  const parts = Array.isArray(match) ? match : match.split(".");
+  const nodes = [];
+  let node;
+
+  for (node = member; (0, _generated.isMemberExpression)(node); node = node.object) {
+    nodes.push(node.property);
+  }
+
+  nodes.push(node);
+  if (nodes.length < parts.length) return false;
+  if (!allowPartial && nodes.length > parts.length) return false;
+
+  for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
+    const node = nodes[j];
+    let value;
+
+    if ((0, _generated.isIdentifier)(node)) {
+      value = node.name;
+    } else if ((0, _generated.isStringLiteral)(node)) {
+      value = node.value;
+    } else if ((0, _generated.isThisExpression)(node)) {
+      value = "this";
+    } else {
+      return false;
+    }
+
+    if (parts[i] !== value) return false;
+  }
+
+  return true;
+}
--- a/Show More
+++ b/Show More