format: prettify entire project

.gitattributes

@@ -0,0 +1,8 @@
+* text=auto
+*.sh text eol=lf
+*.js text eol=lf
+*.ts text eol=lf
+*.json text eol=lf
+*.md text eol=lf
+*.html text eol=lf
+*.css text eol=lf

.prettierrc

@@ -0,0 +1,20 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "quoteProps": "as-needed",
+  "jsxSingleQuote": false,
+  "bracketSpacing": true,
+  "objectWrap": "preserve",
+  "arrowParens": "always",
+  "trailingComma": "es5",
+  "proseWrap": "preserve",
+  "htmlWhitespaceSensitivity": "css",
+  "embeddedLanguageFormatting": "auto",
+  "singleAttributePerLine": false,
+  "endOfLine": "lf",
+  "experimentalTernaries": true,
+  "bracketSameLine": true
+}

README.md

@@ -24,9 +24,11 @@ COD Tracker provides a clean interface to fetch, display, and export Call of Dut
 - Call of Duty account with API security settings set to "ALL"
 
 ## Authentication Setup
+
 <!-- <div align="center">
   <img src="https://img.shields.io/badge/IMPORTANT-Authentication_Required-red" alt="Authentication Required"/>
 </div> -->
+
 ### Changing Account API Privacy Settings
 
 To use this application, you need to update your Call of Duty profile settings:
@@ -41,14 +43,14 @@ To use this application, you need to update your Call of Duty profile settings:
 ### Obtaining Your SSO Token
 
 <table>
-<tr>
+<tr></tr>
 <td width="60%">
 
 The application requires an authentication token to access the Call of Duty API:
 
 1. Log in to [Call of Duty](https://profile.callofduty.com/cod/profile)
 2. Open developer tools (F12 or right-click → Inspect)
-3. Navigate to: **Application** → **Storage** → **Cookies** → **https://profile.callofduty.com**
+3. Navigate to: **Application** → **Storage** → **Cookies** → **<https://profile.callofduty.com>**
 4. Find and copy the value of `ACT_SSO_COOKIE`
 5. Paste this token into the "SSO Token" field
 
@@ -57,7 +59,7 @@ The application requires an authentication token to access the Call of Duty API:
 </td>
 <td width="40%">
 
-```
+```plaintext
 Application
  └─ Storage
     └─ Cookies
@@ -75,17 +77,20 @@ The SSO token typically expires after 24 hours. If you encounter authentication
 ## Installation
 
 1. Clone the repository:
+
    ```bash
    git clone https://git.rimmyscorner.com/Rim/codtracker-js.git && cd codtracker-js
    ```
 
 2. Start the application:
+
    ```bash
    npm run start
    ```
 
 3. Open your browser and navigate to:
-   ```
+
+   ```bash
    http://127.0.0.1:3513
    ```
 

app.js

@@ -1,7 +1,7 @@
-const express = require("express");
+const express = require('express');
-const path = require("path");
+const path = require('path');
-const bodyParser = require("body-parser");
+const bodyParser = require('body-parser');
-const API = require("./src/js/index.js");
+const API = require('./src/js/index.js');
 const { logger } = require('./src/js/logger');
 const favicon = require('serve-favicon');
 const app = express();
@@ -10,15 +10,20 @@ const port = process.env.PORT || 3512;
 app.set('trust proxy', true);
 
 // Middleware
-app.use(bodyParser.json({ limit: "10mb" }));
+app.use(bodyParser.json({ limit: '10mb' }));
-app.use(bodyParser.urlencoded({ extended: true, limit: "10mb" }));
+app.use(bodyParser.urlencoded({ extended: true, limit: '10mb' }));
 app.use(express.static(__dirname));
 app.use(express.static(path.join(__dirname, 'public')));
 app.use('/images', express.static(path.join(__dirname, 'src/images')));
 app.use(favicon(path.join(__dirname, 'src', 'images', 'favicon.ico')));
-app.use(bodyParser.json({ limit: "10mb", verify: (req, res, buf) => {
+app.use(
+  bodyParser.json({
+    limit: '10mb',
+    verify: (req, res, buf) => {
       req.rawBody = buf.toString();
-}}));
+    },
+  })
+);
 // app.use(express.raw({ type: 'application/json', limit: '10mb' }));
 
 const fs = require('fs');
@@ -27,27 +32,32 @@ const fs = require('fs');
 let keyReplacements = {};
 
 try {
-  const replacementsPath = path.join(__dirname, "src", "data", "replacements.json");
+  const replacementsPath = path.join(
+    __dirname,
+    'src',
+    'data',
+    'replacements.json'
+  );
   if (fs.existsSync(replacementsPath)) {
     const replacementsContent = fs.readFileSync(replacementsPath, 'utf8');
     keyReplacements = JSON.parse(replacementsContent);
     // logger.debug("Replacements loaded successfully");
   } else {
-    logger.warn("replacements.json not found, key replacement disabled");
+    logger.warn('replacements.json not found, key replacement disabled');
   }
 } catch (error) {
-  logger.error("Error loading replacements file:", { error: error.message });
+  logger.error('Error loading replacements file:', { error: error.message });
 }
 
 const replaceJsonKeys = (obj) => {
   if (!obj || typeof obj !== 'object') return obj;
 
   if (Array.isArray(obj)) {
-      return obj.map(item => replaceJsonKeys(item));
+    return obj.map((item) => replaceJsonKeys(item));
   }
 
   const newObj = {};
-    Object.keys(obj).forEach(key => {
+  Object.keys(obj).forEach((key) => {
     // Replace key if it exists in replacements
     const newKey = keyReplacements[key] || key;
 
@@ -68,7 +78,7 @@ const replaceJsonKeys = (obj) => {
   });
 
   return newObj;
-  };
+};
 
 // Utility regex function
 const sanitizeJsonOutput = (data) => {
@@ -78,7 +88,8 @@ const sanitizeJsonOutput = (data) => {
   const jsonString = JSON.stringify(data);
 
   // Define regex pattern that matches HTML entities
-    const regexPattern = /<span class=".*?">|<\/span>|">/g;
+  const regexPattern =
+    /<span class=".*?">|<\/span>|">/g;
 
   // Replace unwanted patterns
   const sanitizedString = jsonString.replace(regexPattern, '');
@@ -87,13 +98,16 @@ const sanitizeJsonOutput = (data) => {
   try {
     return JSON.parse(sanitizedString);
   } catch (e) {
-      console.error("Error parsing sanitized JSON:", e);
+    console.error('Error parsing sanitized JSON:', e);
     return data; // Return original data if parsing fails
   }
-  };
+};
 
 // Replace the processJsonOutput function with this more efficient version
-const processJsonOutput = (data, options = { sanitize: true, replaceKeys: true }) => {
+const processJsonOutput = (
+  data,
+  options = { sanitize: true, replaceKeys: true }
+) => {
   // Use a more efficient deep clone approach instead of JSON.parse(JSON.stringify())
   function deepClone(obj) {
     if (obj === null || typeof obj !== 'object') {
@@ -101,11 +115,11 @@ const processJsonOutput = (data, options = { sanitize: true, replaceKeys: true }
     }
 
     if (Array.isArray(obj)) {
-      return obj.map(item => deepClone(item));
+      return obj.map((item) => deepClone(item));
     }
 
     const clone = {};
-    Object.keys(obj).forEach(key => {
+    Object.keys(obj).forEach((key) => {
       clone[key] = deepClone(obj[key]);
     });
 
@@ -141,7 +155,9 @@ const timeoutPromise = (ms) => {
 // Helper function to ensure login
 const ensureLogin = async (ssoToken) => {
   if (!activeSessions.has(ssoToken)) {
-    logger.info(`Attempting to login with SSO token: ${ssoToken.substring(0, 5)}...`);
+    logger.info(
+      `Attempting to login with SSO token: ${ssoToken.substring(0, 5)}...`
+    );
     // logger.info(`Attempting to login with SSO token: ${ssoToken}`);
     const loginResult = await Promise.race([
       API.login(ssoToken),
@@ -152,35 +168,35 @@ const ensureLogin = async (ssoToken) => {
     logger.debug(`Session created at: ${new Date().toISOString()}`);
     activeSessions.set(ssoToken, new Date());
   } else {
-    logger.debug("Using existing session");
+    logger.debug('Using existing session');
   }
 };
 
 // Helper function to handle API errors
 const handleApiError = (error, res) => {
-  logger.error("API Error:", error);
+  logger.error('API Error:', error);
   logger.error(`Error Stack: ${error.stack}`);
   logger.error(`Error Time: ${new Date().toISOString()}`);
 
   // Try to extract more useful information from the error
-  let errorMessage = error.message || "Unknown API error";
+  let errorMessage = error.message || 'Unknown API error';
-  let errorName = error.name || "ApiError";
+  let errorName = error.name || 'ApiError';
 
   // Handle the specific JSON parsing error
-  if (errorName === "SyntaxError" && errorMessage.includes("JSON")) {
+  if (errorName === 'SyntaxError' && errorMessage.includes('JSON')) {
-    logger.debug("JSON parsing error detected");
+    logger.debug('JSON parsing error detected');
     return res.status(200).json({
-      status: "error",
+      status: 'error',
       message:
-        "Failed to parse API response. This usually means the SSO token is invalid or expired.",
+        'Failed to parse API response. This usually means the SSO token is invalid or expired.',
-      error_type: "InvalidResponseError",
+      error_type: 'InvalidResponseError',
       timestamp: new Date().toISOString(),
     });
   }
 
   // Send a more graceful response
   return res.status(200).json({
-    status: "error",
+    status: 'error',
     message: errorMessage,
     error_type: errorName,
     timestamp: new Date().toISOString(),
@@ -188,20 +204,34 @@ const handleApiError = (error, res) => {
 };
 
 // API endpoint to fetch stats
-app.post("/api/stats", async (req, res) => {
+app.post('/api/stats', async (req, res) => {
-  logger.debug("Received request for /api/stats");
+  logger.debug('Received request for /api/stats');
-  logger.debug(`Request IP: ${req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress}`);
+  logger.debug(
-  logger.debug(`Request JSON: ${JSON.stringify({
+    `Request IP: ${
+      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
+    }`
+  );
+  logger.debug(
+    `Request JSON: ${JSON.stringify({
       username: req.body.username,
       platform: req.body.platform,
       game: req.body.game,
       apiCall: req.body.apiCall,
       sanitize: req.body.sanitize,
-    replaceKeys: req.body.replaceKeys
+      replaceKeys: req.body.replaceKeys,
-  })}`);
+    })}`
+  );
 
   try {
-    const { username, ssoToken, platform, game, apiCall, sanitize, replaceKeys } = req.body;
+    const {
+      username,
+      ssoToken,
+      platform,
+      game,
+      apiCall,
+      sanitize,
+      replaceKeys,
+    } = req.body;
 
     /*
     logger.debug(
@@ -217,17 +247,17 @@ app.post("/api/stats", async (req, res) => {
     logger.debug("====================="); */
 
     if (!ssoToken) {
-      return res.status(400).json({ error: "SSO Token is required" });
+      return res.status(400).json({ error: 'SSO Token is required' });
     }
 
     // For mapList, username is not required
-    if (apiCall !== "mapList" && !username) {
+    if (apiCall !== 'mapList' && !username) {
-      return res.status(400).json({ error: "Username is required" });
+      return res.status(400).json({ error: 'Username is required' });
     }
 
     // Clear previous session if it exists
     if (activeSessions.has(ssoToken)) {
-      logger.debug("Clearing previous session");
+      logger.debug('Clearing previous session');
       activeSessions.delete(ssoToken);
     }
 
@@ -235,12 +265,12 @@ app.post("/api/stats", async (req, res) => {
     try {
       await ensureLogin(ssoToken);
     } catch (loginError) {
-      console.error("Login error:", loginError);
+      console.error('Login error:', loginError);
       return res.status(200).json({
-        status: "error",
+        status: 'error',
-        error_type: "LoginError",
+        error_type: 'LoginError',
-        message: "SSO token login failed",
+        message: 'SSO token login failed',
-        details: loginError.message || "Unknown login error",
+        details: loginError.message || 'Unknown login error',
         timestamp: new Date().toISOString(),
       });
     }
@@ -254,11 +284,11 @@ app.post("/api/stats", async (req, res) => {
     };
 
     // Check if the platform is valid for the game
-    const requiresUno = ["mw2", "wz2", "mw3", "wzm"].includes(game);
+    const requiresUno = ['mw2', 'wz2', 'mw3', 'wzm'].includes(game);
-    if (requiresUno && platform !== "uno" && apiCall !== "mapList") {
+    if (requiresUno && platform !== 'uno' && apiCall !== 'mapList') {
       logger.warn(`${game} requires Uno ID`);
       return res.status(200).json({
-        status: "error",
+        status: 'error',
         message: `${game} requires Uno ID (numerical ID)`,
         timestamp: new Date().toISOString(),
       });
@@ -270,131 +300,131 @@ app.post("/api/stats", async (req, res) => {
       );
       let data;
 
-      if (apiCall === "fullData") {
+      if (apiCall === 'fullData') {
         // Fetch lifetime stats based on game
         switch (game) {
-          case "mw":
+          case 'mw':
             data = await fetchWithTimeout(() =>
               API.ModernWarfare.fullData(username, platform)
             );
             break;
-          case "wz":
+          case 'wz':
             data = await fetchWithTimeout(() =>
               API.Warzone.fullData(username, platform)
             );
             break;
-          case "mw2":
+          case 'mw2':
             data = await fetchWithTimeout(() =>
               API.ModernWarfare2.fullData(username)
             );
             break;
-          case "wz2":
+          case 'wz2':
             data = await fetchWithTimeout(() =>
               API.Warzone2.fullData(username)
             );
             break;
-          case "mw3":
+          case 'mw3':
             data = await fetchWithTimeout(() =>
               API.ModernWarfare3.fullData(username)
             );
             break;
-          case "cw":
+          case 'cw':
             data = await fetchWithTimeout(() =>
               API.ColdWar.fullData(username, platform)
             );
             break;
-          case "vg":
+          case 'vg':
             data = await fetchWithTimeout(() =>
               API.Vanguard.fullData(username, platform)
             );
             break;
-          case "wzm":
+          case 'wzm':
             data = await fetchWithTimeout(() =>
               API.WarzoneMobile.fullData(username)
             );
             break;
           default:
             return res.status(200).json({
-              status: "error",
+              status: 'error',
-              message: "Invalid game selected",
+              message: 'Invalid game selected',
               timestamp: new Date().toISOString(),
             });
         }
-      } else if (apiCall === "combatHistory") {
+      } else if (apiCall === 'combatHistory') {
         // Fetch recent match history based on game
         switch (game) {
-          case "mw":
+          case 'mw':
             data = await fetchWithTimeout(() =>
               API.ModernWarfare.combatHistory(username, platform)
             );
             break;
-          case "wz":
+          case 'wz':
             data = await fetchWithTimeout(() =>
               API.Warzone.combatHistory(username, platform)
             );
             break;
-          case "mw2":
+          case 'mw2':
             data = await fetchWithTimeout(() =>
               API.ModernWarfare2.combatHistory(username)
             );
             break;
-          case "wz2":
+          case 'wz2':
             data = await fetchWithTimeout(() =>
               API.Warzone2.combatHistory(username)
             );
             break;
-          case "mw3":
+          case 'mw3':
             data = await fetchWithTimeout(() =>
               API.ModernWarfare3.combatHistory(username)
             );
             break;
-          case "cw":
+          case 'cw':
             data = await fetchWithTimeout(() =>
               API.ColdWar.combatHistory(username, platform)
             );
             break;
-          case "vg":
+          case 'vg':
             data = await fetchWithTimeout(() =>
               API.Vanguard.combatHistory(username, platform)
             );
             break;
-          case "wzm":
+          case 'wzm':
             data = await fetchWithTimeout(() =>
               API.WarzoneMobile.combatHistory(username)
             );
             break;
           default:
             return res.status(200).json({
-              status: "error",
+              status: 'error',
-              message: "Invalid game selected",
+              message: 'Invalid game selected',
               timestamp: new Date().toISOString(),
             });
         }
-      } else if (apiCall === "mapList") {
+      } else if (apiCall === 'mapList') {
         // Fetch map list (only valid for MW)
-        if (game === "mw") {
+        if (game === 'mw') {
           data = await fetchWithTimeout(() =>
             API.ModernWarfare.mapList(platform)
           );
         } else {
           return res.status(200).json({
-            status: "error",
+            status: 'error',
-            message: "Map list is only available for Modern Warfare",
+            message: 'Map list is only available for Modern Warfare',
             timestamp: new Date().toISOString(),
           });
         }
       }
 
-      logger.debug("Data fetched successfully");
+      logger.debug('Data fetched successfully');
       logger.debug(`Response Size: ~${JSON.stringify(data).length / 1024} KB`);
       logger.debug(`Response Time: ${new Date().toISOString()}`);
 
       // Safely handle the response data
       if (!data) {
-        logger.warn("No data returned from API");
+        logger.warn('No data returned from API');
         return res.json({
-          status: "partial_success",
+          status: 'partial_success',
-          message: "No data returned from API, but no error thrown",
+          message: 'No data returned from API, but no error thrown',
           data: null,
           timestamp: new Date().toISOString(),
         });
@@ -413,32 +443,39 @@ app.post("/api/stats", async (req, res) => {
       return handleApiError(apiError, res);
     }
   } catch (serverError) {
-    console.error("Server Error:", serverError);
+    console.error('Server Error:', serverError);
 
     // Return a structured error response even for unexpected errors
     return res.status(200).json({
-      status: "server_error",
+      status: 'server_error',
-      message: "The server encountered an unexpected error",
+      message: 'The server encountered an unexpected error',
-      error_details: serverError.message || "Unknown server error",
+      error_details: serverError.message || 'Unknown server error',
       timestamp: new Date().toISOString(),
     });
   }
 });
 
 // API endpoint to fetch recent matches
-app.post("/api/matches", async (req, res) => {
+app.post('/api/matches', async (req, res) => {
-  logger.debug("Received request for /api/matches");
+  logger.debug('Received request for /api/matches');
-  logger.debug(`Request IP: ${req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress}`);
+  logger.debug(
-  logger.debug(`Request JSON: ${JSON.stringify({
+    `Request IP: ${
+      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
+    }`
+  );
+  logger.debug(
+    `Request JSON: ${JSON.stringify({
       username: req.body.username,
       platform: req.body.platform,
       game: req.body.game,
       sanitize: req.body.sanitize,
-    replaceKeys: req.body.replaceKeys
+      replaceKeys: req.body.replaceKeys,
-  })}`);
+    })}`
+  );
 
   try {
-    const { username, ssoToken, platform, game, sanitize, replaceKeys } = req.body;
+    const { username, ssoToken, platform, game, sanitize, replaceKeys } =
+      req.body;
 
     /*
     logger.debug(
@@ -455,17 +492,17 @@ app.post("/api/matches", async (req, res) => {
     if (!username || !ssoToken) {
       return res
         .status(400)
-        .json({ error: "Username and SSO Token are required" });
+        .json({ error: 'Username and SSO Token are required' });
     }
 
     try {
       await ensureLogin(ssoToken);
     } catch (loginError) {
       return res.status(200).json({
-        status: "error",
+        status: 'error',
-        error_type: "LoginError",
+        error_type: 'LoginError',
-        message: "SSO token login failed",
+        message: 'SSO token login failed',
-        details: loginError.message || "Unknown login error",
+        details: loginError.message || 'Unknown login error',
         timestamp: new Date().toISOString(),
       });
     }
@@ -485,10 +522,10 @@ app.post("/api/matches", async (req, res) => {
       let data;
 
       // Check if the platform is valid for the game
-      const requiresUno = ["mw2", "wz2", "mw3", "wzm"].includes(game);
+      const requiresUno = ['mw2', 'wz2', 'mw3', 'wzm'].includes(game);
-      if (requiresUno && platform !== "uno") {
+      if (requiresUno && platform !== 'uno') {
         return res.status(200).json({
-          status: "error",
+          status: 'error',
           message: `${game} requires Uno ID (numerical ID)`,
           timestamp: new Date().toISOString(),
         });
@@ -496,50 +533,50 @@ app.post("/api/matches", async (req, res) => {
 
       // Fetch combat history based on game
       switch (game) {
-        case "mw":
+        case 'mw':
           data = await fetchWithTimeout(() =>
             API.ModernWarfare.combatHistory(username, platform)
           );
           break;
-        case "wz":
+        case 'wz':
           data = await fetchWithTimeout(() =>
             API.Warzone.combatHistory(username, platform)
           );
           break;
-        case "mw2":
+        case 'mw2':
           data = await fetchWithTimeout(() =>
             API.ModernWarfare2.combatHistory(username)
           );
           break;
-        case "wz2":
+        case 'wz2':
           data = await fetchWithTimeout(() =>
             API.Warzone2.combatHistory(username)
           );
           break;
-        case "mw3":
+        case 'mw3':
           data = await fetchWithTimeout(() =>
             API.ModernWarfare3.combatHistory(username)
           );
           break;
-        case "cw":
+        case 'cw':
           data = await fetchWithTimeout(() =>
             API.ColdWar.combatHistory(username, platform)
           );
           break;
-        case "vg":
+        case 'vg':
           data = await fetchWithTimeout(() =>
             API.Vanguard.combatHistory(username, platform)
           );
           break;
-        case "wzm":
+        case 'wzm':
           data = await fetchWithTimeout(() =>
             API.WarzoneMobile.combatHistory(username)
           );
           break;
         default:
           return res.status(200).json({
-            status: "error",
+            status: 'error',
-            message: "Invalid game selected",
+            message: 'Invalid game selected',
             timestamp: new Date().toISOString(),
           });
       }
@@ -556,29 +593,36 @@ app.post("/api/matches", async (req, res) => {
     }
   } catch (serverError) {
     return res.status(200).json({
-      status: "server_error",
+      status: 'server_error',
-      message: "The server encountered an unexpected error",
+      message: 'The server encountered an unexpected error',
-      error_details: serverError.message || "Unknown server error",
+      error_details: serverError.message || 'Unknown server error',
       timestamp: new Date().toISOString(),
     });
   }
 });
 
 // API endpoint to fetch match info
-app.post("/api/matchInfo", async (req, res) => {
+app.post('/api/matchInfo', async (req, res) => {
-  logger.debug("Received request for /api/matchInfo");
+  logger.debug('Received request for /api/matchInfo');
-  logger.debug(`Request IP: ${req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress}`);
+  logger.debug(
-  logger.debug(`Request JSON: ${JSON.stringify({
+    `Request IP: ${
+      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
+    }`
+  );
+  logger.debug(
+    `Request JSON: ${JSON.stringify({
       matchId: req.body.matchId,
       platform: req.body.platform,
       game: req.body.game,
       sanitize: req.body.sanitize,
-    replaceKeys: req.body.replaceKeys
+      replaceKeys: req.body.replaceKeys,
-  })}`);
+    })}`
+  );
 
   try {
-    const { matchId, ssoToken, platform, game, sanitize, replaceKeys } = req.body;
+    const { matchId, ssoToken, platform, game, sanitize, replaceKeys } =
-    const mode = "mp";
+      req.body;
+    const mode = 'mp';
 
     /*
     logger.debug(
@@ -595,17 +639,17 @@ app.post("/api/matchInfo", async (req, res) => {
     if (!matchId || !ssoToken) {
       return res
         .status(400)
-        .json({ error: "Match ID and SSO Token are required" });
+        .json({ error: 'Match ID and SSO Token are required' });
     }
 
     try {
       await ensureLogin(ssoToken);
     } catch (loginError) {
       return res.status(200).json({
-        status: "error",
+        status: 'error',
-        error_type: "LoginError",
+        error_type: 'LoginError',
-        message: "SSO token login failed",
+        message: 'SSO token login failed',
-        details: loginError.message || "Unknown login error",
+        details: loginError.message || 'Unknown login error',
         timestamp: new Date().toISOString(),
       });
     }
@@ -624,48 +668,48 @@ app.post("/api/matchInfo", async (req, res) => {
 
       // Fetch match info based on game
       switch (game) {
-        case "mw":
+        case 'mw':
           data = await fetchWithTimeout(() =>
             API.ModernWarfare.matchInfo(matchId, platform)
           );
           break;
-        case "wz":
+        case 'wz':
           data = await fetchWithTimeout(() =>
             API.Warzone.matchInfo(matchId, platform)
           );
           break;
-        case "mw2":
+        case 'mw2':
           data = await fetchWithTimeout(() =>
             API.ModernWarfare2.matchInfo(matchId)
           );
           break;
-        case "wz2":
+        case 'wz2':
           data = await fetchWithTimeout(() => API.Warzone2.matchInfo(matchId));
           break;
-        case "mw3":
+        case 'mw3':
           data = await fetchWithTimeout(() =>
             API.ModernWarfare3.matchInfo(matchId)
           );
           break;
-        case "cw":
+        case 'cw':
           data = await fetchWithTimeout(() =>
             API.ColdWar.matchInfo(matchId, platform)
           );
           break;
-        case "vg":
+        case 'vg':
           data = await fetchWithTimeout(() =>
             API.Vanguard.matchInfo(matchId, platform)
           );
           break;
-        case "wzm":
+        case 'wzm':
           data = await fetchWithTimeout(() =>
             API.WarzoneMobile.matchInfo(matchId)
           );
           break;
         default:
           return res.status(200).json({
-            status: "error",
+            status: 'error',
-            message: "Invalid game selected",
+            message: 'Invalid game selected',
             timestamp: new Date().toISOString(),
           });
       }
@@ -682,28 +726,35 @@ app.post("/api/matchInfo", async (req, res) => {
     }
   } catch (serverError) {
     return res.status(200).json({
-      status: "server_error",
+      status: 'server_error',
-      message: "The server encountered an unexpected error",
+      message: 'The server encountered an unexpected error',
-      error_details: serverError.message || "Unknown server error",
+      error_details: serverError.message || 'Unknown server error',
       timestamp: new Date().toISOString(),
     });
   }
 });
 
 // API endpoint for user-related API calls
-app.post("/api/user", async (req, res) => {
+app.post('/api/user', async (req, res) => {
-  logger.debug("Received request for /api/user");
+  logger.debug('Received request for /api/user');
-  logger.debug(`Request IP: ${req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress}`);
+  logger.debug(
-  logger.debug(`Request JSON: ${JSON.stringify({
+    `Request IP: ${
+      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
+    }`
+  );
+  logger.debug(
+    `Request JSON: ${JSON.stringify({
       username: req.body.username,
       platform: req.body.platform,
       userCall: req.body.userCall,
       sanitize: req.body.sanitize,
-    replaceKeys: req.body.replaceKeys
+      replaceKeys: req.body.replaceKeys,
-  })}`);
+    })}`
+  );
 
   try {
-    const { username, ssoToken, platform, userCall, sanitize, replaceKeys } = req.body;
+    const { username, ssoToken, platform, userCall, sanitize, replaceKeys } =
+      req.body;
 
     /*
     logger.debug(
@@ -718,29 +769,29 @@ app.post("/api/user", async (req, res) => {
     logger.debug("========================="); */
 
     if (!ssoToken) {
-      return res.status(400).json({ error: "SSO Token is required" });
+      return res.status(400).json({ error: 'SSO Token is required' });
     }
 
     // For eventFeed and identities, username is not required
     if (
       !username &&
-      userCall !== "eventFeed" &&
+      userCall !== 'eventFeed' &&
-      userCall !== "friendFeed" &&
+      userCall !== 'friendFeed' &&
-      userCall !== "identities"
+      userCall !== 'identities'
     ) {
       return res
         .status(400)
-        .json({ error: "Username is required for this API call" });
+        .json({ error: 'Username is required for this API call' });
     }
 
     try {
       await ensureLogin(ssoToken);
     } catch (loginError) {
       return res.status(200).json({
-        status: "error",
+        status: 'error',
-        error_type: "LoginError",
+        error_type: 'LoginError',
-        message: "SSO token login failed",
+        message: 'SSO token login failed',
-        details: loginError.message || "Unknown login error",
+        details: loginError.message || 'Unknown login error',
         timestamp: new Date().toISOString(),
       });
     }
@@ -759,28 +810,28 @@ app.post("/api/user", async (req, res) => {
 
       // Fetch user data based on userCall
       switch (userCall) {
-        case "codPoints":
+        case 'codPoints':
           data = await fetchWithTimeout(() =>
             API.Me.codPoints(username, platform)
           );
           break;
-        case "connectedAccounts":
+        case 'connectedAccounts':
           data = await fetchWithTimeout(() =>
             API.Me.connectedAccounts(username, platform)
           );
           break;
-        case "eventFeed":
+        case 'eventFeed':
           data = await fetchWithTimeout(() => API.Me.eventFeed());
           break;
-        case "friendFeed":
+        case 'friendFeed':
           data = await fetchWithTimeout(() =>
             API.Me.friendFeed(username, platform)
           );
           break;
-        case "identities":
+        case 'identities':
           data = await fetchWithTimeout(() => API.Me.loggedInIdentities());
           break;
-        case "friendsList":
+        case 'friendsList':
           data = await fetchWithTimeout(() => API.Me.friendsList());
           break;
         // case "settings":
@@ -790,8 +841,8 @@ app.post("/api/user", async (req, res) => {
         //   break;
         default:
           return res.status(200).json({
-            status: "error",
+            status: 'error',
-            message: "Invalid user API call selected",
+            message: 'Invalid user API call selected',
             timestamp: new Date().toISOString(),
           });
       }
@@ -808,24 +859,30 @@ app.post("/api/user", async (req, res) => {
     }
   } catch (serverError) {
     return res.status(200).json({
-      status: "server_error",
+      status: 'server_error',
-      message: "The server encountered an unexpected error",
+      message: 'The server encountered an unexpected error',
-      error_details: serverError.message || "Unknown server error",
+      error_details: serverError.message || 'Unknown server error',
       timestamp: new Date().toISOString(),
     });
   }
 });
 
 // API endpoint for fuzzy search
-app.post("/api/search", async (req, res) => {
+app.post('/api/search', async (req, res) => {
-  logger.debug("Received request for /api/search");
+  logger.debug('Received request for /api/search');
-  logger.debug(`Request IP: ${req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress}`);
+  logger.debug(
-  logger.debug(`Request JSON: ${JSON.stringify({
+    `Request IP: ${
+      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
+    }`
+  );
+  logger.debug(
+    `Request JSON: ${JSON.stringify({
       username: req.body.username,
       platform: req.body.platform,
       sanitize: req.body.sanitize,
-    replaceKeys: req.body.replaceKeys
+      replaceKeys: req.body.replaceKeys,
-})}`);
+    })}`
+  );
 
   try {
     const { username, ssoToken, platform, sanitize, replaceKeys } = req.body;
@@ -844,17 +901,17 @@ app.post("/api/search", async (req, res) => {
     if (!username || !ssoToken) {
       return res
         .status(400)
-        .json({ error: "Username and SSO Token are required" });
+        .json({ error: 'Username and SSO Token are required' });
     }
 
     try {
       await ensureLogin(ssoToken);
     } catch (loginError) {
       return res.status(200).json({
-        status: "error",
+        status: 'error',
-        error_type: "LoginError",
+        error_type: 'LoginError',
-        message: "SSO token login failed",
+        message: 'SSO token login failed',
-        details: loginError.message || "Unknown login error",
+        details: loginError.message || 'Unknown login error',
         timestamp: new Date().toISOString(),
       });
     }
@@ -888,18 +945,18 @@ app.post("/api/search", async (req, res) => {
     }
   } catch (serverError) {
     return res.status(200).json({
-      status: "server_error",
+      status: 'server_error',
-      message: "The server encountered an unexpected error",
+      message: 'The server encountered an unexpected error',
-      error_details: serverError.message || "Unknown server error",
+      error_details: serverError.message || 'Unknown server error',
       timestamp: new Date().toISOString(),
     });
   }
 });
 
-
 // Improved logging endpoint
 app.post('/api/log', (req, res) => {
-  const clientIP = req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress;
+  const clientIP =
+    req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress;
   const userAgent = req.headers['user-agent'];
   const referer = req.headers['referer'];
   const origin = req.headers['origin'];
@@ -926,17 +983,16 @@ app.post('/api/log', (req, res) => {
         origin,
         requestHeaders: sanitizeHeaders(req.headers),
         serverTimestamp: new Date().toISOString(),
-        requestId: req.id || Math.random().toString(36).substring(2, 15)
+        requestId: req.id || Math.random().toString(36).substring(2, 15),
-      }
+      },
     };
 
     // Use the dedicated user activity logger
     logger.userActivity(enrichedLog.eventType || 'unknown', enrichedLog);
-    
   } catch (error) {
     logger.error('Error processing log data', {
       error: error.message,
-      rawBody: typeof req.body === 'object' ? '[Object]' : req.body
+      rawBody: typeof req.body === 'object' ? '[Object]' : req.body,
     });
   }
 
@@ -950,7 +1006,7 @@ function sanitizeHeaders(headers) {
 
   // Remove potential sensitive information
   const sensitiveHeaders = ['authorization', 'cookie', 'set-cookie'];
-  sensitiveHeaders.forEach(header => {
+  sensitiveHeaders.forEach((header) => {
     if (safeHeaders[header]) {
       safeHeaders[header] = '[REDACTED]';
     }
@@ -969,13 +1025,13 @@ function storeLogInDatabase(logData) {
 */
 
 // Basic health check endpoint
-app.get("/health", (req, res) => {
+app.get('/health', (req, res) => {
-  res.json({ status: "ok", timestamp: new Date().toISOString() });
+  res.json({ status: 'ok', timestamp: new Date().toISOString() });
 });
 
 // Serve the main HTML file
-app.get("/", (req, res) => {
+app.get('/', (req, res) => {
-  res.sendFile(path.join(__dirname, "src", "index.html"));
+  res.sendFile(path.join(__dirname, 'src', 'index.html'));
 });
 
 // Start the server

node_modules/.bin/acorn.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\acorn\bin\acorn" %*

node_modules/.bin/glob.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\glob\dist\esm\bin.mjs" %*

node_modules/.bin/he.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\he\bin\he" %*

node_modules/.bin/html-minifier.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\html-minifier\cli.js" %*

node_modules/.bin/jsesc.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\jsesc\bin\jsesc" %*

node_modules/.bin/mime.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\mime\cli.js" %*

node_modules/.bin/parser

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
+else 
+  exec node  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
+fi

node_modules/.bin/parser.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\@babel\parser\bin\babel-parser.js" %*

node_modules/.bin/parser.ps1

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

node_modules/.bin/pkg-fetch.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\pkg-fetch\lib-es5\bin.js" %*

node_modules/.bin/pkg.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\pkg\lib-es5\bin.js" %*

node_modules/.bin/prebuild-install.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\prebuild-install\bin.js" %*

node_modules/.bin/prettier

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../prettier/bin/prettier.cjs" "$@"
+else 
+  exec node  "$basedir/../prettier/bin/prettier.cjs" "$@"
+fi

node_modules/.bin/prettier.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\prettier\bin\prettier.cjs" %*

node_modules/.bin/prettier.ps1

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

node_modules/.bin/rc.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\rc\cli.js" %*

node_modules/.bin/resolve.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\resolve\bin\resolve" %*

node_modules/.bin/semver.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\semver\bin\semver.js" %*

node_modules/.bin/terser.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\terser\bin\terser" %*

node_modules/.bin/uglifyjs.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\uglify-js\bin\uglifyjs" %*

node_modules/@babel/generator/lib/buffer.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = void 0;
 
@@ -10,7 +10,7 @@ function SourcePos() {
     identifierName: undefined,
     line: undefined,
     column: undefined,
-    filename: undefined
+    filename: undefined,
   };
 }
 
@@ -19,12 +19,12 @@ const SPACES_RE = /^[ \t]+$/;
 class Buffer {
   constructor(map) {
     this._map = null;
-    this._buf = "";
+    this._buf = '';
     this._last = 0;
     this._queue = [];
     this._position = {
       line: 1,
-      column: 0
+      column: 0,
     };
     this._sourcePosition = SourcePos();
     this._disallowedPop = null;
@@ -40,27 +40,27 @@ class Buffer {
       decodedMap: map == null ? void 0 : map.getDecoded(),
 
       get map() {
-        return result.map = map ? map.get() : null;
+        return (result.map = map ? map.get() : null);
       },
 
       set map(value) {
-        Object.defineProperty(result, "map", {
+        Object.defineProperty(result, 'map', {
           value,
-          writable: true
+          writable: true,
         });
       },
 
       get rawMappings() {
-        return result.rawMappings = map == null ? void 0 : map.getRawMappings();
+        return (result.rawMappings =
+          map == null ? void 0 : map.getRawMappings());
       },
 
       set rawMappings(value) {
-        Object.defineProperty(result, "rawMappings", {
+        Object.defineProperty(result, 'rawMappings', {
           value,
-          writable: true
+          writable: true,
         });
-      }
+      },
-
     };
     return result;
   }
@@ -68,29 +68,19 @@ class Buffer {
   append(str) {
     this._flush();
 
-    const {
+    const { line, column, filename, identifierName } = this._sourcePosition;
-      line,
-      column,
-      filename,
-      identifierName
-    } = this._sourcePosition;
 
     this._append(str, line, column, identifierName, filename);
   }
 
   queue(str) {
-    if (str === "\n") {
+    if (str === '\n') {
       while (this._queue.length > 0 && SPACES_RE.test(this._queue[0][0])) {
         this._queue.shift();
       }
     }
 
-    const {
+    const { line, column, filename, identifierName } = this._sourcePosition;
-      line,
-      column,
-      filename,
-      identifierName
-    } = this._sourcePosition;
 
     this._queue.unshift([str, line, column, identifierName, filename]);
   }
@@ -102,7 +92,7 @@ class Buffer {
   _flush() {
     let item;
 
-    while (item = this._queue.pop()) {
+    while ((item = this._queue.pop())) {
       this._append(...item);
     }
   }
@@ -110,7 +100,7 @@ class Buffer {
   _append(str, line, column, identifierName, filename) {
     this._buf += str;
     this._last = str.charCodeAt(str.length - 1);
-    let i = str.indexOf("\n");
+    let i = str.indexOf('\n');
     let last = 0;
 
     if (i !== 0) {
@@ -126,7 +116,7 @@ class Buffer {
         this._mark(++line, 0, identifierName, filename);
       }
 
-      i = str.indexOf("\n", last);
+      i = str.indexOf('\n', last);
     }
 
     this._position.column += str.length - last;
@@ -135,17 +125,19 @@ class Buffer {
   _mark(line, column, identifierName, filename) {
     var _this$_map;
 
-    (_this$_map = this._map) == null ? void 0 : _this$_map.mark(this._position, line, column, identifierName, filename);
+    (_this$_map = this._map) == null ?
+      void 0
+    : _this$_map.mark(this._position, line, column, identifierName, filename);
   }
 
   removeTrailingNewline() {
-    if (this._queue.length > 0 && this._queue[0][0] === "\n") {
+    if (this._queue.length > 0 && this._queue[0][0] === '\n') {
       this._queue.shift();
     }
   }
 
   removeLastSemicolon() {
-    if (this._queue.length > 0 && this._queue[0][0] === ";") {
+    if (this._queue.length > 0 && this._queue[0][0] === ';') {
       this._queue.shift();
     }
   }
@@ -185,11 +177,11 @@ class Buffer {
   }
 
   exactSource(loc, cb) {
-    this.source("start", loc);
+    this.source('start', loc);
     cb();
-    this.source("end", loc);
+    this.source('end', loc);
 
-    this._disallowPop("start", loc);
+    this._disallowPop('start', loc);
   }
 
   source(prop, loc) {
@@ -207,7 +199,12 @@ class Buffer {
     this.source(prop, loc);
     cb();
 
-    if (!this._disallowedPop || this._disallowedPop.line !== originalLine || this._disallowedPop.column !== originalColumn || this._disallowedPop.filename !== originalFilename) {
+    if (
+      !this._disallowedPop ||
+      this._disallowedPop.line !== originalLine ||
+      this._disallowedPop.column !== originalColumn ||
+      this._disallowedPop.filename !== originalFilename
+    ) {
       this._sourcePosition.line = originalLine;
       this._sourcePosition.column = originalColumn;
       this._sourcePosition.filename = originalFilename;
@@ -223,7 +220,9 @@ class Buffer {
 
   _normalizePosition(prop, loc, targetObj) {
     const pos = loc ? loc[prop] : null;
-    targetObj.identifierName = prop === "start" && (loc == null ? void 0 : loc.identifierName) || undefined;
+    targetObj.identifierName =
+      (prop === 'start' && (loc == null ? void 0 : loc.identifierName)) ||
+      undefined;
     targetObj.line = pos == null ? void 0 : pos.line;
     targetObj.column = pos == null ? void 0 : pos.column;
     targetObj.filename = loc == null ? void 0 : loc.filename;
@@ -231,24 +230,25 @@ class Buffer {
   }
 
   getCurrentColumn() {
-    const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
+    const extra = this._queue.reduce((acc, item) => item[0] + acc, '');
 
-    const lastIndex = extra.lastIndexOf("\n");
+    const lastIndex = extra.lastIndexOf('\n');
-    return lastIndex === -1 ? this._position.column + extra.length : extra.length - 1 - lastIndex;
+    return lastIndex === -1 ?
+        this._position.column + extra.length
+      : extra.length - 1 - lastIndex;
   }
 
   getCurrentLine() {
-    const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
+    const extra = this._queue.reduce((acc, item) => item[0] + acc, '');
 
     let count = 0;
 
     for (let i = 0; i < extra.length; i++) {
-      if (extra[i] === "\n") count++;
+      if (extra[i] === '\n') count++;
     }
 
     return this._position.line + count;
   }
-
 }
 
 exports.default = Buffer;

node_modules/@babel/generator/lib/generators/base.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.BlockStatement = BlockStatement;
 exports.Directive = Directive;
@@ -29,26 +29,29 @@ function Program(node) {
 function BlockStatement(node) {
   var _node$directives;
 
-  this.token("{");
+  this.token('{');
   this.printInnerComments(node);
-  const hasDirectives = (_node$directives = node.directives) == null ? void 0 : _node$directives.length;
+  const hasDirectives =
+    (_node$directives = node.directives) == null ?
+      void 0
+    : _node$directives.length;
 
   if (node.body.length || hasDirectives) {
     this.newline();
     this.printSequence(node.directives, node, {
-      indent: true
+      indent: true,
     });
     if (hasDirectives) this.newline();
     this.printSequence(node.body, node, {
-      indent: true
+      indent: true,
     });
     this.removeTrailingNewline();
-    this.source("end", node.loc);
+    this.source('end', node.loc);
     if (!this.endsWith(10)) this.newline();
     this.rightBrace();
   } else {
-    this.source("end", node.loc);
+    this.source('end', node.loc);
-    this.token("}");
+    this.token('}');
   }
 }
 
@@ -68,16 +71,17 @@ function DirectiveLiteral(node) {
     return;
   }
 
-  const {
+  const { value } = node;
-    value
-  } = node;
 
   if (!unescapedDoubleQuoteRE.test(value)) {
     this.token(`"${value}"`);
   } else if (!unescapedSingleQuoteRE.test(value)) {
     this.token(`'${value}'`);
   } else {
-    throw new Error("Malformed AST: it is not possible to print a directive containing" + " both unescaped single and double quotes.");
+    throw new Error(
+      'Malformed AST: it is not possible to print a directive containing' +
+        ' both unescaped single and double quotes.'
+    );
   }
 }
 
@@ -86,11 +90,11 @@ function InterpreterDirective(node) {
 }
 
 function Placeholder(node) {
-  this.token("%%");
+  this.token('%%');
   this.print(node.name);
-  this.token("%%");
+  this.token('%%');
 
-  if (node.expectedNode === "Statement") {
+  if (node.expectedNode === 'Statement') {
     this.semicolon();
   }
 }

node_modules/@babel/generator/lib/generators/classes.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.ClassAccessorProperty = ClassAccessorProperty;
 exports.ClassBody = ClassBody;
@@ -13,29 +13,29 @@ exports.ClassProperty = ClassProperty;
 exports.StaticBlock = StaticBlock;
 exports._classMethodHead = _classMethodHead;
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
-const {
+const { isExportDefaultDeclaration, isExportNamedDeclaration } = _t;
-  isExportDefaultDeclaration,
-  isExportNamedDeclaration
-} = _t;
 
 function ClassDeclaration(node, parent) {
-  if (!this.format.decoratorsBeforeExport || !isExportDefaultDeclaration(parent) && !isExportNamedDeclaration(parent)) {
+  if (
+    !this.format.decoratorsBeforeExport ||
+    (!isExportDefaultDeclaration(parent) && !isExportNamedDeclaration(parent))
+  ) {
     this.printJoin(node.decorators, node);
   }
 
   if (node.declare) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
   if (node.abstract) {
-    this.word("abstract");
+    this.word('abstract');
     this.space();
   }
 
-  this.word("class");
+  this.word('class');
   this.printInnerComments(node);
 
   if (node.id) {
@@ -47,7 +47,7 @@ function ClassDeclaration(node, parent) {
 
   if (node.superClass) {
     this.space();
-    this.word("extends");
+    this.word('extends');
     this.space();
     this.print(node.superClass, node);
     this.print(node.superTypeParameters, node);
@@ -55,7 +55,7 @@ function ClassDeclaration(node, parent) {
 
   if (node.implements) {
     this.space();
-    this.word("implements");
+    this.word('implements');
     this.space();
     this.printList(node.implements, node);
   }
@@ -65,11 +65,11 @@ function ClassDeclaration(node, parent) {
 }
 
 function ClassBody(node) {
-  this.token("{");
+  this.token('{');
   this.printInnerComments(node);
 
   if (node.body.length === 0) {
-    this.token("}");
+    this.token('}');
   } else {
     this.newline();
     this.indent();
@@ -82,13 +82,13 @@ function ClassBody(node) {
 
 function ClassProperty(node) {
   this.printJoin(node.decorators, node);
-  this.source("end", node.key.loc);
+  this.source('end', node.key.loc);
   this.tsPrintClassMemberModifiers(node, true);
 
   if (node.computed) {
-    this.token("[");
+    this.token('[');
     this.print(node.key, node);
-    this.token("]");
+    this.token(']');
   } else {
     this._variance(node);
 
@@ -96,18 +96,18 @@ function ClassProperty(node) {
   }
 
   if (node.optional) {
-    this.token("?");
+    this.token('?');
   }
 
   if (node.definite) {
-    this.token("!");
+    this.token('!');
   }
 
   this.print(node.typeAnnotation, node);
 
   if (node.value) {
     this.space();
-    this.token("=");
+    this.token('=');
     this.space();
     this.print(node.value, node);
   }
@@ -117,16 +117,16 @@ function ClassProperty(node) {
 
 function ClassAccessorProperty(node) {
   this.printJoin(node.decorators, node);
-  this.source("end", node.key.loc);
+  this.source('end', node.key.loc);
   this.tsPrintClassMemberModifiers(node, true);
-  this.word("accessor");
+  this.word('accessor');
   this.printInnerComments(node);
   this.space();
 
   if (node.computed) {
-    this.token("[");
+    this.token('[');
     this.print(node.key, node);
-    this.token("]");
+    this.token(']');
   } else {
     this._variance(node);
 
@@ -134,18 +134,18 @@ function ClassAccessorProperty(node) {
   }
 
   if (node.optional) {
-    this.token("?");
+    this.token('?');
   }
 
   if (node.definite) {
-    this.token("!");
+    this.token('!');
   }
 
   this.print(node.typeAnnotation, node);
 
   if (node.value) {
     this.space();
-    this.token("=");
+    this.token('=');
     this.space();
     this.print(node.value, node);
   }
@@ -157,7 +157,7 @@ function ClassPrivateProperty(node) {
   this.printJoin(node.decorators, node);
 
   if (node.static) {
-    this.word("static");
+    this.word('static');
     this.space();
   }
 
@@ -166,7 +166,7 @@ function ClassPrivateProperty(node) {
 
   if (node.value) {
     this.space();
-    this.token("=");
+    this.token('=');
     this.space();
     this.print(node.value, node);
   }
@@ -190,23 +190,23 @@ function ClassPrivateMethod(node) {
 
 function _classMethodHead(node) {
   this.printJoin(node.decorators, node);
-  this.source("end", node.key.loc);
+  this.source('end', node.key.loc);
   this.tsPrintClassMemberModifiers(node, false);
 
   this._methodHead(node);
 }
 
 function StaticBlock(node) {
-  this.word("static");
+  this.word('static');
   this.space();
-  this.token("{");
+  this.token('{');
 
   if (node.body.length === 0) {
-    this.token("}");
+    this.token('}');
   } else {
     this.newline();
     this.printSequence(node.body, node, {
-      indent: true
+      indent: true,
     });
     this.rightBrace();
   }

node_modules/@babel/generator/lib/generators/expressions.js

@@ -1,9 +1,12 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
-exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression;
+exports.LogicalExpression =
+  exports.BinaryExpression =
+  exports.AssignmentExpression =
+    AssignmentExpression;
 exports.AssignmentPattern = AssignmentPattern;
 exports.AwaitExpression = void 0;
 exports.BindExpression = BindExpression;
@@ -30,19 +33,19 @@ exports.UpdateExpression = UpdateExpression;
 exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
 exports.YieldExpression = void 0;
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
-var n = require("../node");
+var n = require('../node');
 
-const {
+const { isCallExpression, isLiteral, isMemberExpression, isNewExpression } = _t;
-  isCallExpression,
-  isLiteral,
-  isMemberExpression,
-  isNewExpression
-} = _t;
 
 function UnaryExpression(node) {
-  if (node.operator === "void" || node.operator === "delete" || node.operator === "typeof" || node.operator === "throw") {
+  if (
+    node.operator === 'void' ||
+    node.operator === 'delete' ||
+    node.operator === 'typeof' ||
+    node.operator === 'throw'
+  ) {
     this.word(node.operator);
     this.space();
   } else {
@@ -54,19 +57,19 @@ function UnaryExpression(node) {
 
 function DoExpression(node) {
   if (node.async) {
-    this.word("async");
+    this.word('async');
     this.space();
   }
 
-  this.word("do");
+  this.word('do');
   this.space();
   this.print(node.body, node);
 }
 
 function ParenthesizedExpression(node) {
-  this.token("(");
+  this.token('(');
   this.print(node.expression, node);
-  this.token(")");
+  this.token(')');
 }
 
 function UpdateExpression(node) {
@@ -84,23 +87,30 @@ function UpdateExpression(node) {
 function ConditionalExpression(node) {
   this.print(node.test, node);
   this.space();
-  this.token("?");
+  this.token('?');
   this.space();
   this.print(node.consequent, node);
   this.space();
-  this.token(":");
+  this.token(':');
   this.space();
   this.print(node.alternate, node);
 }
 
 function NewExpression(node, parent) {
-  this.word("new");
+  this.word('new');
   this.space();
   this.print(node.callee, node);
 
-  if (this.format.minified && node.arguments.length === 0 && !node.optional && !isCallExpression(parent, {
+  if (
-    callee: node
+    this.format.minified &&
-  }) && !isMemberExpression(parent) && !isNewExpression(parent)) {
+    node.arguments.length === 0 &&
+    !node.optional &&
+    !isCallExpression(parent, {
+      callee: node,
+    }) &&
+    !isMemberExpression(parent) &&
+    !isNewExpression(parent)
+  ) {
     return;
   }
 
@@ -108,12 +118,12 @@ function NewExpression(node, parent) {
   this.print(node.typeParameters, node);
 
   if (node.optional) {
-    this.token("?.");
+    this.token('?.');
   }
 
-  this.token("(");
+  this.token('(');
   this.printList(node.arguments, node);
-  this.token(")");
+  this.token(')');
 }
 
 function SequenceExpression(node) {
@@ -121,20 +131,24 @@ function SequenceExpression(node) {
 }
 
 function ThisExpression() {
-  this.word("this");
+  this.word('this');
 }
 
 function Super() {
-  this.word("super");
+  this.word('super');
 }
 
 function isDecoratorMemberExpression(node) {
   switch (node.type) {
-    case "Identifier":
+    case 'Identifier':
       return true;
 
-    case "MemberExpression":
+    case 'MemberExpression':
-      return !node.computed && node.property.type === "Identifier" && isDecoratorMemberExpression(node.object);
+      return (
+        !node.computed &&
+        node.property.type === 'Identifier' &&
+        isDecoratorMemberExpression(node.object)
+      );
 
     default:
       return false;
@@ -142,11 +156,11 @@ function isDecoratorMemberExpression(node) {
 }
 
 function shouldParenthesizeDecoratorExpression(node) {
-  if (node.type === "CallExpression") {
+  if (node.type === 'CallExpression') {
     node = node.callee;
   }
 
-  if (node.type === "ParenthesizedExpression") {
+  if (node.type === 'ParenthesizedExpression') {
     return false;
   }
 
@@ -154,15 +168,13 @@ function shouldParenthesizeDecoratorExpression(node) {
 }
 
 function Decorator(node) {
-  this.token("@");
+  this.token('@');
-  const {
+  const { expression } = node;
-    expression
-  } = node;
 
   if (shouldParenthesizeDecoratorExpression(expression)) {
-    this.token("(");
+    this.token('(');
     this.print(expression, node);
-    this.token(")");
+    this.token(')');
   } else {
     this.print(expression, node);
   }
@@ -174,26 +186,26 @@ function OptionalMemberExpression(node) {
   this.print(node.object, node);
 
   if (!node.computed && isMemberExpression(node.property)) {
-    throw new TypeError("Got a MemberExpression for MemberExpression property");
+    throw new TypeError('Got a MemberExpression for MemberExpression property');
   }
 
   let computed = node.computed;
 
-  if (isLiteral(node.property) && typeof node.property.value === "number") {
+  if (isLiteral(node.property) && typeof node.property.value === 'number') {
     computed = true;
   }
 
   if (node.optional) {
-    this.token("?.");
+    this.token('?.');
   }
 
   if (computed) {
-    this.token("[");
+    this.token('[');
     this.print(node.property, node);
-    this.token("]");
+    this.token(']');
   } else {
     if (!node.optional) {
-      this.token(".");
+      this.token('.');
     }
 
     this.print(node.property, node);
@@ -206,25 +218,25 @@ function OptionalCallExpression(node) {
   this.print(node.typeParameters, node);
 
   if (node.optional) {
-    this.token("?.");
+    this.token('?.');
   }
 
-  this.token("(");
+  this.token('(');
   this.printList(node.arguments, node);
-  this.token(")");
+  this.token(')');
 }
 
 function CallExpression(node) {
   this.print(node.callee, node);
   this.print(node.typeArguments, node);
   this.print(node.typeParameters, node);
-  this.token("(");
+  this.token('(');
   this.printList(node.arguments, node);
-  this.token(")");
+  this.token(')');
 }
 
 function Import() {
-  this.word("import");
+  this.word('import');
 }
 
 function buildYieldAwait(keyword) {
@@ -232,7 +244,7 @@ function buildYieldAwait(keyword) {
     this.word(keyword);
 
     if (node.delegate) {
-      this.token("*");
+      this.token('*');
     }
 
     if (node.argument) {
@@ -244,9 +256,9 @@ function buildYieldAwait(keyword) {
   };
 }
 
-const YieldExpression = buildYieldAwait("yield");
+const YieldExpression = buildYieldAwait('yield');
 exports.YieldExpression = YieldExpression;
-const AwaitExpression = buildYieldAwait("await");
+const AwaitExpression = buildYieldAwait('await');
 exports.AwaitExpression = AwaitExpression;
 
 function EmptyStatement() {
@@ -260,25 +272,28 @@ function ExpressionStatement(node) {
 
 function AssignmentPattern(node) {
   this.print(node.left, node);
-  if (node.left.optional) this.token("?");
+  if (node.left.optional) this.token('?');
   this.print(node.left.typeAnnotation, node);
   this.space();
-  this.token("=");
+  this.token('=');
   this.space();
   this.print(node.right, node);
 }
 
 function AssignmentExpression(node, parent) {
-  const parens = this.inForStatementInitCounter && node.operator === "in" && !n.needsParens(node, parent);
+  const parens =
+    this.inForStatementInitCounter &&
+    node.operator === 'in' &&
+    !n.needsParens(node, parent);
 
   if (parens) {
-    this.token("(");
+    this.token('(');
   }
 
   this.print(node.left, node);
   this.space();
 
-  if (node.operator === "in" || node.operator === "instanceof") {
+  if (node.operator === 'in' || node.operator === 'instanceof') {
     this.word(node.operator);
   } else {
     this.token(node.operator);
@@ -288,13 +303,13 @@ function AssignmentExpression(node, parent) {
   this.print(node.right, node);
 
   if (parens) {
-    this.token(")");
+    this.token(')');
   }
 }
 
 function BindExpression(node) {
   this.print(node.object, node);
-  this.token("::");
+  this.token('::');
   this.print(node.callee, node);
 }
 
@@ -302,52 +317,52 @@ function MemberExpression(node) {
   this.print(node.object, node);
 
   if (!node.computed && isMemberExpression(node.property)) {
-    throw new TypeError("Got a MemberExpression for MemberExpression property");
+    throw new TypeError('Got a MemberExpression for MemberExpression property');
   }
 
   let computed = node.computed;
 
-  if (isLiteral(node.property) && typeof node.property.value === "number") {
+  if (isLiteral(node.property) && typeof node.property.value === 'number') {
     computed = true;
   }
 
   if (computed) {
-    this.token("[");
+    this.token('[');
     this.print(node.property, node);
-    this.token("]");
+    this.token(']');
   } else {
-    this.token(".");
+    this.token('.');
     this.print(node.property, node);
   }
 }
 
 function MetaProperty(node) {
   this.print(node.meta, node);
-  this.token(".");
+  this.token('.');
   this.print(node.property, node);
 }
 
 function PrivateName(node) {
-  this.token("#");
+  this.token('#');
   this.print(node.id, node);
 }
 
 function V8IntrinsicIdentifier(node) {
-  this.token("%");
+  this.token('%');
   this.word(node.name);
 }
 
 function ModuleExpression(node) {
-  this.word("module");
+  this.word('module');
   this.space();
-  this.token("{");
+  this.token('{');
 
   if (node.body.body.length === 0) {
-    this.token("}");
+    this.token('}');
   } else {
     this.newline();
     this.printSequence(node.body.body, node, {
-      indent: true
+      indent: true,
     });
     this.rightBrace();
   }

node_modules/@babel/generator/lib/generators/flow.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.AnyTypeAnnotation = AnyTypeAnnotation;
 exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
@@ -34,17 +34,20 @@ exports.FunctionTypeParam = FunctionTypeParam;
 exports.IndexedAccessType = IndexedAccessType;
 exports.InferredPredicate = InferredPredicate;
 exports.InterfaceDeclaration = InterfaceDeclaration;
-exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends;
+exports.GenericTypeAnnotation =
+  exports.ClassImplements =
+  exports.InterfaceExtends =
+    InterfaceExtends;
 exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation;
 exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
 exports.MixedTypeAnnotation = MixedTypeAnnotation;
 exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
 exports.NullableTypeAnnotation = NullableTypeAnnotation;
-Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
+Object.defineProperty(exports, 'NumberLiteralTypeAnnotation', {
   enumerable: true,
   get: function () {
     return _types2.NumericLiteral;
-  }
+  },
 });
 exports.NumberTypeAnnotation = NumberTypeAnnotation;
 exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
@@ -56,11 +59,11 @@ exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
 exports.OpaqueType = OpaqueType;
 exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
 exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
-Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
+Object.defineProperty(exports, 'StringLiteralTypeAnnotation', {
   enumerable: true,
   get: function () {
     return _types2.StringLiteral;
-  }
+  },
 });
 exports.StringTypeAnnotation = StringTypeAnnotation;
 exports.SymbolTypeAnnotation = SymbolTypeAnnotation;
@@ -70,7 +73,8 @@ exports.TypeAlias = TypeAlias;
 exports.TypeAnnotation = TypeAnnotation;
 exports.TypeCastExpression = TypeCastExpression;
 exports.TypeParameter = TypeParameter;
-exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation;
+exports.TypeParameterDeclaration = exports.TypeParameterInstantiation =
+  TypeParameterInstantiation;
 exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
 exports.UnionTypeAnnotation = UnionTypeAnnotation;
 exports.Variance = Variance;
@@ -78,46 +82,43 @@ exports.VoidTypeAnnotation = VoidTypeAnnotation;
 exports._interfaceish = _interfaceish;
 exports._variance = _variance;
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
-var _modules = require("./modules");
+var _modules = require('./modules');
 
-var _types2 = require("./types");
+var _types2 = require('./types');
 
-const {
+const { isDeclareExportDeclaration, isStatement } = _t;
-  isDeclareExportDeclaration,
-  isStatement
-} = _t;
 
 function AnyTypeAnnotation() {
-  this.word("any");
+  this.word('any');
 }
 
 function ArrayTypeAnnotation(node) {
   this.print(node.elementType, node);
-  this.token("[");
+  this.token('[');
-  this.token("]");
+  this.token(']');
 }
 
 function BooleanTypeAnnotation() {
-  this.word("boolean");
+  this.word('boolean');
 }
 
 function BooleanLiteralTypeAnnotation(node) {
-  this.word(node.value ? "true" : "false");
+  this.word(node.value ? 'true' : 'false');
 }
 
 function NullLiteralTypeAnnotation() {
-  this.word("null");
+  this.word('null');
 }
 
 function DeclareClass(node, parent) {
   if (!isDeclareExportDeclaration(parent)) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
-  this.word("class");
+  this.word('class');
   this.space();
 
   this._interfaceish(node);
@@ -125,11 +126,11 @@ function DeclareClass(node, parent) {
 
 function DeclareFunction(node, parent) {
   if (!isDeclareExportDeclaration(parent)) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
-  this.word("function");
+  this.word('function');
   this.space();
   this.print(node.id, node);
   this.print(node.id.typeAnnotation.typeAnnotation, node);
@@ -143,28 +144,28 @@ function DeclareFunction(node, parent) {
 }
 
 function InferredPredicate() {
-  this.token("%");
+  this.token('%');
-  this.word("checks");
+  this.word('checks');
 }
 
 function DeclaredPredicate(node) {
-  this.token("%");
+  this.token('%');
-  this.word("checks");
+  this.word('checks');
-  this.token("(");
+  this.token('(');
   this.print(node.value, node);
-  this.token(")");
+  this.token(')');
 }
 
 function DeclareInterface(node) {
-  this.word("declare");
+  this.word('declare');
   this.space();
   this.InterfaceDeclaration(node);
 }
 
 function DeclareModule(node) {
-  this.word("declare");
+  this.word('declare');
   this.space();
-  this.word("module");
+  this.word('module');
   this.space();
   this.print(node.id, node);
   this.space();
@@ -172,23 +173,23 @@ function DeclareModule(node) {
 }
 
 function DeclareModuleExports(node) {
-  this.word("declare");
+  this.word('declare');
   this.space();
-  this.word("module");
+  this.word('module');
-  this.token(".");
+  this.token('.');
-  this.word("exports");
+  this.word('exports');
   this.print(node.typeAnnotation, node);
 }
 
 function DeclareTypeAlias(node) {
-  this.word("declare");
+  this.word('declare');
   this.space();
   this.TypeAlias(node);
 }
 
 function DeclareOpaqueType(node, parent) {
   if (!isDeclareExportDeclaration(parent)) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
@@ -197,11 +198,11 @@ function DeclareOpaqueType(node, parent) {
 
 function DeclareVariable(node, parent) {
   if (!isDeclareExportDeclaration(parent)) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
-  this.word("var");
+  this.word('var');
   this.space();
   this.print(node.id, node);
   this.print(node.id.typeAnnotation, node);
@@ -209,13 +210,13 @@ function DeclareVariable(node, parent) {
 }
 
 function DeclareExportDeclaration(node) {
-  this.word("declare");
+  this.word('declare');
   this.space();
-  this.word("export");
+  this.word('export');
   this.space();
 
   if (node.default) {
-    this.word("default");
+    this.word('default');
     this.space();
   }
 
@@ -223,18 +224,15 @@ function DeclareExportDeclaration(node) {
 }
 
 function DeclareExportAllDeclaration() {
-  this.word("declare");
+  this.word('declare');
   this.space();
 
   _modules.ExportAllDeclaration.apply(this, arguments);
 }
 
 function EnumDeclaration(node) {
-  const {
+  const { id, body } = node;
-    id,
+  this.word('enum');
-    body
-  } = node;
-  this.word("enum");
   this.space();
   this.print(id, node);
   this.print(body, node);
@@ -243,7 +241,7 @@ function EnumDeclaration(node) {
 function enumExplicitType(context, name, hasExplicitType) {
   if (hasExplicitType) {
     context.space();
-    context.word("of");
+    context.word('of');
     context.space();
     context.word(name);
   }
@@ -252,10 +250,8 @@ function enumExplicitType(context, name, hasExplicitType) {
 }
 
 function enumBody(context, node) {
-  const {
+  const { members } = node;
-    members
+  context.token('{');
-  } = node;
-  context.token("{");
   context.indent();
   context.newline();
 
@@ -265,62 +261,51 @@ function enumBody(context, node) {
   }
 
   if (node.hasUnknownMembers) {
-    context.token("...");
+    context.token('...');
     context.newline();
   }
 
   context.dedent();
-  context.token("}");
+  context.token('}');
 }
 
 function EnumBooleanBody(node) {
-  const {
+  const { explicitType } = node;
-    explicitType
+  enumExplicitType(this, 'boolean', explicitType);
-  } = node;
-  enumExplicitType(this, "boolean", explicitType);
   enumBody(this, node);
 }
 
 function EnumNumberBody(node) {
-  const {
+  const { explicitType } = node;
-    explicitType
+  enumExplicitType(this, 'number', explicitType);
-  } = node;
-  enumExplicitType(this, "number", explicitType);
   enumBody(this, node);
 }
 
 function EnumStringBody(node) {
-  const {
+  const { explicitType } = node;
-    explicitType
+  enumExplicitType(this, 'string', explicitType);
-  } = node;
-  enumExplicitType(this, "string", explicitType);
   enumBody(this, node);
 }
 
 function EnumSymbolBody(node) {
-  enumExplicitType(this, "symbol", true);
+  enumExplicitType(this, 'symbol', true);
   enumBody(this, node);
 }
 
 function EnumDefaultedMember(node) {
-  const {
+  const { id } = node;
-    id
-  } = node;
   this.print(id, node);
-  this.token(",");
+  this.token(',');
 }
 
 function enumInitializedMember(context, node) {
-  const {
+  const { id, init } = node;
-    id,
-    init
-  } = node;
   context.print(id, node);
   context.space();
-  context.token("=");
+  context.token('=');
   context.space();
   context.print(init, node);
-  context.token(",");
+  context.token(',');
 }
 
 function EnumBooleanMember(node) {
@@ -341,7 +326,7 @@ function FlowExportDeclaration(node) {
     this.print(declar, node);
     if (!isStatement(declar)) this.semicolon();
   } else {
-    this.token("{");
+    this.token('{');
 
     if (node.specifiers.length) {
       this.space();
@@ -349,11 +334,11 @@ function FlowExportDeclaration(node) {
       this.space();
     }
 
-    this.token("}");
+    this.token('}');
 
     if (node.source) {
       this.space();
-      this.word("from");
+      this.word('from');
       this.space();
       this.print(node.source, node);
     }
@@ -363,21 +348,21 @@ function FlowExportDeclaration(node) {
 }
 
 function ExistsTypeAnnotation() {
-  this.token("*");
+  this.token('*');
 }
 
 function FunctionTypeAnnotation(node, parent) {
   this.print(node.typeParameters, node);
-  this.token("(");
+  this.token('(');
 
   if (node.this) {
-    this.word("this");
+    this.word('this');
-    this.token(":");
+    this.token(':');
     this.space();
     this.print(node.this.typeAnnotation, node);
 
     if (node.params.length || node.rest) {
-      this.token(",");
+      this.token(',');
       this.space();
     }
   }
@@ -386,21 +371,26 @@ function FunctionTypeAnnotation(node, parent) {
 
   if (node.rest) {
     if (node.params.length) {
-      this.token(",");
+      this.token(',');
       this.space();
     }
 
-    this.token("...");
+    this.token('...');
     this.print(node.rest, node);
   }
 
-  this.token(")");
+  this.token(')');
 
-  if (parent && (parent.type === "ObjectTypeCallProperty" || parent.type === "DeclareFunction" || parent.type === "ObjectTypeProperty" && parent.method)) {
+  if (
-    this.token(":");
+    parent &&
+    (parent.type === 'ObjectTypeCallProperty' ||
+      parent.type === 'DeclareFunction' ||
+      (parent.type === 'ObjectTypeProperty' && parent.method))
+  ) {
+    this.token(':');
   } else {
     this.space();
-    this.token("=>");
+    this.token('=>');
   }
 
   this.space();
@@ -409,10 +399,10 @@ function FunctionTypeAnnotation(node, parent) {
 
 function FunctionTypeParam(node) {
   this.print(node.name, node);
-  if (node.optional) this.token("?");
+  if (node.optional) this.token('?');
 
   if (node.name) {
-    this.token(":");
+    this.token(':');
     this.space();
   }
 
@@ -432,21 +422,21 @@ function _interfaceish(node) {
 
   if ((_node$extends = node.extends) != null && _node$extends.length) {
     this.space();
-    this.word("extends");
+    this.word('extends');
     this.space();
     this.printList(node.extends, node);
   }
 
   if (node.mixins && node.mixins.length) {
     this.space();
-    this.word("mixins");
+    this.word('mixins');
     this.space();
     this.printList(node.mixins, node);
   }
 
   if (node.implements && node.implements.length) {
     this.space();
-    this.word("implements");
+    this.word('implements');
     this.space();
     this.printList(node.implements, node);
   }
@@ -457,16 +447,16 @@ function _interfaceish(node) {
 
 function _variance(node) {
   if (node.variance) {
-    if (node.variance.kind === "plus") {
+    if (node.variance.kind === 'plus') {
-      this.token("+");
+      this.token('+');
-    } else if (node.variance.kind === "minus") {
+    } else if (node.variance.kind === 'minus') {
-      this.token("-");
+      this.token('-');
     }
   }
 }
 
 function InterfaceDeclaration(node) {
-  this.word("interface");
+  this.word('interface');
   this.space();
 
   this._interfaceish(node);
@@ -474,16 +464,16 @@ function InterfaceDeclaration(node) {
 
 function andSeparator() {
   this.space();
-  this.token("&");
+  this.token('&');
   this.space();
 }
 
 function InterfaceTypeAnnotation(node) {
-  this.word("interface");
+  this.word('interface');
 
   if (node.extends && node.extends.length) {
     this.space();
-    this.word("extends");
+    this.word('extends');
     this.space();
     this.printList(node.extends, node);
   }
@@ -494,70 +484,70 @@ function InterfaceTypeAnnotation(node) {
 
 function IntersectionTypeAnnotation(node) {
   this.printJoin(node.types, node, {
-    separator: andSeparator
+    separator: andSeparator,
   });
 }
 
 function MixedTypeAnnotation() {
-  this.word("mixed");
+  this.word('mixed');
 }
 
 function EmptyTypeAnnotation() {
-  this.word("empty");
+  this.word('empty');
 }
 
 function NullableTypeAnnotation(node) {
-  this.token("?");
+  this.token('?');
   this.print(node.typeAnnotation, node);
 }
 
 function NumberTypeAnnotation() {
-  this.word("number");
+  this.word('number');
 }
 
 function StringTypeAnnotation() {
-  this.word("string");
+  this.word('string');
 }
 
 function ThisTypeAnnotation() {
-  this.word("this");
+  this.word('this');
 }
 
 function TupleTypeAnnotation(node) {
-  this.token("[");
+  this.token('[');
   this.printList(node.types, node);
-  this.token("]");
+  this.token(']');
 }
 
 function TypeofTypeAnnotation(node) {
-  this.word("typeof");
+  this.word('typeof');
   this.space();
   this.print(node.argument, node);
 }
 
 function TypeAlias(node) {
-  this.word("type");
+  this.word('type');
   this.space();
   this.print(node.id, node);
   this.print(node.typeParameters, node);
   this.space();
-  this.token("=");
+  this.token('=');
   this.space();
   this.print(node.right, node);
   this.semicolon();
 }
 
 function TypeAnnotation(node) {
-  this.token(":");
+  this.token(':');
   this.space();
-  if (node.optional) this.token("?");
+  if (node.optional) this.token('?');
   this.print(node.typeAnnotation, node);
 }
 
 function TypeParameterInstantiation(node) {
-  this.token("<");
+  this.token('<');
   this.printList(node.params, node, {});
-  this.token(">");
+  this.token('>');
 }
 
 function TypeParameter(node) {
@@ -571,29 +561,29 @@ function TypeParameter(node) {
 
   if (node.default) {
     this.space();
-    this.token("=");
+    this.token('=');
     this.space();
     this.print(node.default, node);
   }
 }
 
 function OpaqueType(node) {
-  this.word("opaque");
+  this.word('opaque');
   this.space();
-  this.word("type");
+  this.word('type');
   this.space();
   this.print(node.id, node);
   this.print(node.typeParameters, node);
 
   if (node.supertype) {
-    this.token(":");
+    this.token(':');
     this.space();
     this.print(node.supertype, node);
   }
 
   if (node.impltype) {
     this.space();
-    this.token("=");
+    this.token('=');
     this.space();
     this.print(node.impltype, node);
   }
@@ -603,12 +593,17 @@ function OpaqueType(node) {
 
 function ObjectTypeAnnotation(node) {
   if (node.exact) {
-    this.token("{|");
+    this.token('{|');
   } else {
-    this.token("{");
+    this.token('{');
   }
 
-  const props = [...node.properties, ...(node.callProperties || []), ...(node.indexers || []), ...(node.internalSlots || [])];
+  const props = [
+    ...node.properties,
+    ...(node.callProperties || []),
+    ...(node.indexers || []),
+    ...(node.internalSlots || []),
+  ];
 
   if (props.length) {
     this.space();
@@ -621,17 +616,17 @@ function ObjectTypeAnnotation(node) {
       statement: true,
       iterator: () => {
         if (props.length !== 1 || node.inexact) {
-          this.token(",");
+          this.token(',');
           this.space();
         }
-      }
+      },
     });
     this.space();
   }
 
   if (node.inexact) {
     this.indent();
-    this.token("...");
+    this.token('...');
 
     if (props.length) {
       this.newline();
@@ -641,27 +636,27 @@ function ObjectTypeAnnotation(node) {
   }
 
   if (node.exact) {
-    this.token("|}");
+    this.token('|}');
   } else {
-    this.token("}");
+    this.token('}');
   }
 }
 
 function ObjectTypeInternalSlot(node) {
   if (node.static) {
-    this.word("static");
+    this.word('static');
     this.space();
   }
 
-  this.token("[");
+  this.token('[');
-  this.token("[");
+  this.token('[');
   this.print(node.id, node);
-  this.token("]");
+  this.token(']');
-  this.token("]");
+  this.token(']');
-  if (node.optional) this.token("?");
+  if (node.optional) this.token('?');
 
   if (!node.method) {
-    this.token(":");
+    this.token(':');
     this.space();
   }
 
@@ -670,7 +665,7 @@ function ObjectTypeInternalSlot(node) {
 
 function ObjectTypeCallProperty(node) {
   if (node.static) {
-    this.word("static");
+    this.word('static');
     this.space();
   }
 
@@ -679,39 +674,39 @@ function ObjectTypeCallProperty(node) {
 
 function ObjectTypeIndexer(node) {
   if (node.static) {
-    this.word("static");
+    this.word('static');
     this.space();
   }
 
   this._variance(node);
 
-  this.token("[");
+  this.token('[');
 
   if (node.id) {
     this.print(node.id, node);
-    this.token(":");
+    this.token(':');
     this.space();
   }
 
   this.print(node.key, node);
-  this.token("]");
+  this.token(']');
-  this.token(":");
+  this.token(':');
   this.space();
   this.print(node.value, node);
 }
 
 function ObjectTypeProperty(node) {
   if (node.proto) {
-    this.word("proto");
+    this.word('proto');
     this.space();
   }
 
   if (node.static) {
-    this.word("static");
+    this.word('static');
     this.space();
   }
 
-  if (node.kind === "get" || node.kind === "set") {
+  if (node.kind === 'get' || node.kind === 'set') {
     this.word(node.kind);
     this.space();
   }
@@ -719,10 +714,10 @@ function ObjectTypeProperty(node) {
   this._variance(node);
 
   this.print(node.key, node);
-  if (node.optional) this.token("?");
+  if (node.optional) this.token('?');
 
   if (!node.method) {
-    this.token(":");
+    this.token(':');
     this.space();
   }
 
@@ -730,66 +725,66 @@ function ObjectTypeProperty(node) {
 }
 
 function ObjectTypeSpreadProperty(node) {
-  this.token("...");
+  this.token('...');
   this.print(node.argument, node);
 }
 
 function QualifiedTypeIdentifier(node) {
   this.print(node.qualification, node);
-  this.token(".");
+  this.token('.');
   this.print(node.id, node);
 }
 
 function SymbolTypeAnnotation() {
-  this.word("symbol");
+  this.word('symbol');
 }
 
 function orSeparator() {
   this.space();
-  this.token("|");
+  this.token('|');
   this.space();
 }
 
 function UnionTypeAnnotation(node) {
   this.printJoin(node.types, node, {
-    separator: orSeparator
+    separator: orSeparator,
   });
 }
 
 function TypeCastExpression(node) {
-  this.token("(");
+  this.token('(');
   this.print(node.expression, node);
   this.print(node.typeAnnotation, node);
-  this.token(")");
+  this.token(')');
 }
 
 function Variance(node) {
-  if (node.kind === "plus") {
+  if (node.kind === 'plus') {
-    this.token("+");
+    this.token('+');
   } else {
-    this.token("-");
+    this.token('-');
   }
 }
 
 function VoidTypeAnnotation() {
-  this.word("void");
+  this.word('void');
 }
 
 function IndexedAccessType(node) {
   this.print(node.objectType, node);
-  this.token("[");
+  this.token('[');
   this.print(node.indexType, node);
-  this.token("]");
+  this.token(']');
 }
 
 function OptionalIndexedAccessType(node) {
   this.print(node.objectType, node);
 
   if (node.optional) {
-    this.token("?.");
+    this.token('?.');
   }
 
-  this.token("[");
+  this.token('[');
   this.print(node.indexType, node);
-  this.token("]");
+  this.token(']');
 }

node_modules/@babel/generator/lib/generators/index.js

@@ -1,148 +1,148 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 
-var _templateLiterals = require("./template-literals");
+var _templateLiterals = require('./template-literals');
 
 Object.keys(_templateLiterals).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _templateLiterals[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _templateLiterals[key];
-    }
+    },
   });
 });
 
-var _expressions = require("./expressions");
+var _expressions = require('./expressions');
 
 Object.keys(_expressions).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _expressions[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _expressions[key];
-    }
+    },
   });
 });
 
-var _statements = require("./statements");
+var _statements = require('./statements');
 
 Object.keys(_statements).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _statements[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _statements[key];
-    }
+    },
   });
 });
 
-var _classes = require("./classes");
+var _classes = require('./classes');
 
 Object.keys(_classes).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _classes[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _classes[key];
-    }
+    },
   });
 });
 
-var _methods = require("./methods");
+var _methods = require('./methods');
 
 Object.keys(_methods).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _methods[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _methods[key];
-    }
+    },
   });
 });
 
-var _modules = require("./modules");
+var _modules = require('./modules');
 
 Object.keys(_modules).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _modules[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _modules[key];
-    }
+    },
   });
 });
 
-var _types = require("./types");
+var _types = require('./types');
 
 Object.keys(_types).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _types[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _types[key];
-    }
+    },
   });
 });
 
-var _flow = require("./flow");
+var _flow = require('./flow');
 
 Object.keys(_flow).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _flow[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _flow[key];
-    }
+    },
   });
 });
 
-var _base = require("./base");
+var _base = require('./base');
 
 Object.keys(_base).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _base[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _base[key];
-    }
+    },
   });
 });
 
-var _jsx = require("./jsx");
+var _jsx = require('./jsx');
 
 Object.keys(_jsx).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _jsx[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _jsx[key];
-    }
+    },
   });
 });
 
-var _typescript = require("./typescript");
+var _typescript = require('./typescript');
 
 Object.keys(_typescript).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  if (key === 'default' || key === '__esModule') return;
   if (key in exports && exports[key] === _typescript[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
       return _typescript[key];
-    }
+    },
   });
 });

node_modules/@babel/generator/lib/generators/jsx.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.JSXAttribute = JSXAttribute;
 exports.JSXClosingElement = JSXClosingElement;
@@ -23,7 +23,7 @@ function JSXAttribute(node) {
   this.print(node.name, node);
 
   if (node.value) {
-    this.token("=");
+    this.token('=');
     this.print(node.value, node);
   }
 }
@@ -34,34 +34,34 @@ function JSXIdentifier(node) {
 
 function JSXNamespacedName(node) {
   this.print(node.namespace, node);
-  this.token(":");
+  this.token(':');
   this.print(node.name, node);
 }
 
 function JSXMemberExpression(node) {
   this.print(node.object, node);
-  this.token(".");
+  this.token('.');
   this.print(node.property, node);
 }
 
 function JSXSpreadAttribute(node) {
-  this.token("{");
+  this.token('{');
-  this.token("...");
+  this.token('...');
   this.print(node.argument, node);
-  this.token("}");
+  this.token('}');
 }
 
 function JSXExpressionContainer(node) {
-  this.token("{");
+  this.token('{');
   this.print(node.expression, node);
-  this.token("}");
+  this.token('}');
 }
 
 function JSXSpreadChild(node) {
-  this.token("{");
+  this.token('{');
-  this.token("...");
+  this.token('...');
   this.print(node.expression, node);
-  this.token("}");
+  this.token('}');
 }
 
 function JSXText(node) {
@@ -93,29 +93,29 @@ function spaceSeparator() {
 }
 
 function JSXOpeningElement(node) {
-  this.token("<");
+  this.token('<');
   this.print(node.name, node);
   this.print(node.typeParameters, node);
 
   if (node.attributes.length > 0) {
     this.space();
     this.printJoin(node.attributes, node, {
-      separator: spaceSeparator
+      separator: spaceSeparator,
     });
   }
 
   if (node.selfClosing) {
     this.space();
-    this.token("/>");
+    this.token('/>');
   } else {
-    this.token(">");
+    this.token('>');
   }
 }
 
 function JSXClosingElement(node) {
-  this.token("</");
+  this.token('</');
   this.print(node.name, node);
-  this.token(">");
+  this.token('>');
 }
 
 function JSXEmptyExpression(node) {
@@ -135,11 +135,11 @@ function JSXFragment(node) {
 }
 
 function JSXOpeningFragment() {
-  this.token("<");
+  this.token('<');
-  this.token(">");
+  this.token('>');
 }
 
 function JSXClosingFragment() {
-  this.token("</");
+  this.token('</');
-  this.token(">");
+  this.token('>');
 }

node_modules/@babel/generator/lib/generators/methods.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.ArrowFunctionExpression = ArrowFunctionExpression;
 exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression;
@@ -12,19 +12,17 @@ exports._parameters = _parameters;
 exports._params = _params;
 exports._predicate = _predicate;
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
-const {
+const { isIdentifier } = _t;
-  isIdentifier
-} = _t;
 
 function _params(node) {
   this.print(node.typeParameters, node);
-  this.token("(");
+  this.token('(');
 
   this._parameters(node.params, node);
 
-  this.token(")");
+  this.token(')');
   this.print(node.returnType, node);
 }
 
@@ -33,7 +31,7 @@ function _parameters(parameters, parent) {
     this._param(parameters[i], parent);
 
     if (i < parameters.length - 1) {
-      this.token(",");
+      this.token(',');
       this.space();
     }
   }
@@ -42,7 +40,7 @@ function _parameters(parameters, parent) {
 function _param(parameter, parent) {
   this.printJoin(parameter.decorators, parameter);
   this.print(parameter, parent);
-  if (parameter.optional) this.token("?");
+  if (parameter.optional) this.token('?');
   this.print(parameter.typeAnnotation, parameter);
 }
 
@@ -50,34 +48,34 @@ function _methodHead(node) {
   const kind = node.kind;
   const key = node.key;
 
-  if (kind === "get" || kind === "set") {
+  if (kind === 'get' || kind === 'set') {
     this.word(kind);
     this.space();
   }
 
   if (node.async) {
-    this._catchUp("start", key.loc);
+    this._catchUp('start', key.loc);
 
-    this.word("async");
+    this.word('async');
     this.space();
   }
 
-  if (kind === "method" || kind === "init") {
+  if (kind === 'method' || kind === 'init') {
     if (node.generator) {
-      this.token("*");
+      this.token('*');
     }
   }
 
   if (node.computed) {
-    this.token("[");
+    this.token('[');
     this.print(key, node);
-    this.token("]");
+    this.token(']');
   } else {
     this.print(key, node);
   }
 
   if (node.optional) {
-    this.token("?");
+    this.token('?');
   }
 
   this._params(node);
@@ -86,7 +84,7 @@ function _methodHead(node) {
 function _predicate(node) {
   if (node.predicate) {
     if (!node.returnType) {
-      this.token(":");
+      this.token(':');
     }
 
     this.space();
@@ -96,12 +94,12 @@ function _predicate(node) {
 
 function _functionHead(node) {
   if (node.async) {
-    this.word("async");
+    this.word('async');
     this.space();
   }
 
-  this.word("function");
+  this.word('function');
-  if (node.generator) this.token("*");
+  if (node.generator) this.token('*');
   this.printInnerComments(node);
   this.space();
 
@@ -123,13 +121,20 @@ function FunctionExpression(node) {
 
 function ArrowFunctionExpression(node) {
   if (node.async) {
-    this.word("async");
+    this.word('async');
     this.space();
   }
 
   const firstParam = node.params[0];
 
-  if (!this.format.retainLines && !this.format.auxiliaryCommentBefore && !this.format.auxiliaryCommentAfter && node.params.length === 1 && isIdentifier(firstParam) && !hasTypesOrComments(node, firstParam)) {
+  if (
+    !this.format.retainLines &&
+    !this.format.auxiliaryCommentBefore &&
+    !this.format.auxiliaryCommentAfter &&
+    node.params.length === 1 &&
+    isIdentifier(firstParam) &&
+    !hasTypesOrComments(node, firstParam)
+  ) {
     this.print(firstParam, node);
   } else {
     this._params(node);
@@ -138,7 +143,7 @@ function ArrowFunctionExpression(node) {
   this._predicate(node);
 
   this.space();
-  this.token("=>");
+  this.token('=>');
   this.space();
   this.print(node.body, node);
 }
@@ -146,5 +151,15 @@ function ArrowFunctionExpression(node) {
 function hasTypesOrComments(node, param) {
   var _param$leadingComment, _param$trailingCommen;
 
-  return !!(node.typeParameters || node.returnType || node.predicate || param.typeAnnotation || param.optional || (_param$leadingComment = param.leadingComments) != null && _param$leadingComment.length || (_param$trailingCommen = param.trailingComments) != null && _param$trailingCommen.length);
+  return !!(
+    node.typeParameters ||
+    node.returnType ||
+    node.predicate ||
+    param.typeAnnotation ||
+    param.optional ||
+    ((_param$leadingComment = param.leadingComments) != null &&
+      _param$leadingComment.length) ||
+    ((_param$trailingCommen = param.trailingComments) != null &&
+      _param$trailingCommen.length)
+  );
 }

node_modules/@babel/generator/lib/generators/modules.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.ExportAllDeclaration = ExportAllDeclaration;
 exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
@@ -15,7 +15,7 @@ exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
 exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
 exports.ImportSpecifier = ImportSpecifier;
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
 const {
   isClassDeclaration,
@@ -23,11 +23,11 @@ const {
   isExportNamespaceSpecifier,
   isImportDefaultSpecifier,
   isImportNamespaceSpecifier,
-  isStatement
+  isStatement,
 } = _t;
 
 function ImportSpecifier(node) {
-  if (node.importKind === "type" || node.importKind === "typeof") {
+  if (node.importKind === 'type' || node.importKind === 'typeof') {
     this.word(node.importKind);
     this.space();
   }
@@ -36,7 +36,7 @@ function ImportSpecifier(node) {
 
   if (node.local && node.local.name !== node.imported.name) {
     this.space();
-    this.word("as");
+    this.word('as');
     this.space();
     this.print(node.local, node);
   }
@@ -51,8 +51,8 @@ function ExportDefaultSpecifier(node) {
 }
 
 function ExportSpecifier(node) {
-  if (node.exportKind === "type") {
+  if (node.exportKind === 'type') {
-    this.word("type");
+    this.word('type');
     this.space();
   }
 
@@ -60,32 +60,32 @@ function ExportSpecifier(node) {
 
   if (node.exported && node.local.name !== node.exported.name) {
     this.space();
-    this.word("as");
+    this.word('as');
     this.space();
     this.print(node.exported, node);
   }
 }
 
 function ExportNamespaceSpecifier(node) {
-  this.token("*");
+  this.token('*');
   this.space();
-  this.word("as");
+  this.word('as');
   this.space();
   this.print(node.exported, node);
 }
 
 function ExportAllDeclaration(node) {
-  this.word("export");
+  this.word('export');
   this.space();
 
-  if (node.exportKind === "type") {
+  if (node.exportKind === 'type') {
-    this.word("type");
+    this.word('type');
     this.space();
   }
 
-  this.token("*");
+  this.token('*');
   this.space();
-  this.word("from");
+  this.word('from');
   this.space();
   this.print(node.source, node);
   this.printAssertions(node);
@@ -93,23 +93,29 @@ function ExportAllDeclaration(node) {
 }
 
 function ExportNamedDeclaration(node) {
-  if (this.format.decoratorsBeforeExport && isClassDeclaration(node.declaration)) {
+  if (
+    this.format.decoratorsBeforeExport &&
+    isClassDeclaration(node.declaration)
+  ) {
     this.printJoin(node.declaration.decorators, node);
   }
 
-  this.word("export");
+  this.word('export');
   this.space();
   ExportDeclaration.apply(this, arguments);
 }
 
 function ExportDefaultDeclaration(node) {
-  if (this.format.decoratorsBeforeExport && isClassDeclaration(node.declaration)) {
+  if (
+    this.format.decoratorsBeforeExport &&
+    isClassDeclaration(node.declaration)
+  ) {
     this.printJoin(node.declaration.decorators, node);
   }
 
-  this.word("export");
+  this.word('export');
   this.space();
-  this.word("default");
+  this.word('default');
   this.space();
   ExportDeclaration.apply(this, arguments);
 }
@@ -120,8 +126,8 @@ function ExportDeclaration(node) {
     this.print(declar, node);
     if (!isStatement(declar)) this.semicolon();
   } else {
-    if (node.exportKind === "type") {
+    if (node.exportKind === 'type') {
-      this.word("type");
+      this.word('type');
       this.space();
     }
 
@@ -131,12 +137,15 @@ function ExportDeclaration(node) {
     for (;;) {
       const first = specifiers[0];
 
-      if (isExportDefaultSpecifier(first) || isExportNamespaceSpecifier(first)) {
+      if (
+        isExportDefaultSpecifier(first) ||
+        isExportNamespaceSpecifier(first)
+      ) {
         hasSpecial = true;
         this.print(specifiers.shift(), node);
 
         if (specifiers.length) {
-          this.token(",");
+          this.token(',');
           this.space();
         }
       } else {
@@ -144,8 +153,8 @@ function ExportDeclaration(node) {
       }
     }
 
-    if (specifiers.length || !specifiers.length && !hasSpecial) {
+    if (specifiers.length || (!specifiers.length && !hasSpecial)) {
-      this.token("{");
+      this.token('{');
 
       if (specifiers.length) {
         this.space();
@@ -153,12 +162,12 @@ function ExportDeclaration(node) {
         this.space();
       }
 
-      this.token("}");
+      this.token('}');
     }
 
     if (node.source) {
       this.space();
-      this.word("from");
+      this.word('from');
       this.space();
       this.print(node.source, node);
       this.printAssertions(node);
@@ -169,9 +178,9 @@ function ExportDeclaration(node) {
 }
 
 function ImportDeclaration(node) {
-  this.word("import");
+  this.word('import');
   this.space();
-  const isTypeKind = node.importKind === "type" || node.importKind === "typeof";
+  const isTypeKind = node.importKind === 'type' || node.importKind === 'typeof';
 
   if (isTypeKind) {
     this.word(node.importKind);
@@ -188,7 +197,7 @@ function ImportDeclaration(node) {
       this.print(specifiers.shift(), node);
 
       if (specifiers.length) {
-        this.token(",");
+        this.token(',');
         this.space();
       }
     } else {
@@ -197,19 +206,19 @@ function ImportDeclaration(node) {
   }
 
   if (specifiers.length) {
-    this.token("{");
+    this.token('{');
     this.space();
     this.printList(specifiers, node);
     this.space();
-    this.token("}");
+    this.token('}');
   } else if (isTypeKind && !hasSpecifiers) {
-    this.token("{");
+    this.token('{');
-    this.token("}");
+    this.token('}');
   }
 
   if (hasSpecifiers || isTypeKind) {
     this.space();
-    this.word("from");
+    this.word('from');
     this.space();
   }
 
@@ -218,9 +227,12 @@ function ImportDeclaration(node) {
   {
     var _node$attributes;
 
-    if ((_node$attributes = node.attributes) != null && _node$attributes.length) {
+    if (
+      (_node$attributes = node.attributes) != null &&
+      _node$attributes.length
+    ) {
       this.space();
-      this.word("with");
+      this.word('with');
       this.space();
       this.printList(node.attributes, node);
     }
@@ -230,15 +242,15 @@ function ImportDeclaration(node) {
 
 function ImportAttribute(node) {
   this.print(node.key);
-  this.token(":");
+  this.token(':');
   this.space();
   this.print(node.value);
 }
 
 function ImportNamespaceSpecifier(node) {
-  this.token("*");
+  this.token('*');
   this.space();
-  this.word("as");
+  this.word('as');
   this.space();
   this.print(node.local, node);
 }

node_modules/@babel/generator/lib/generators/statements.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.BreakStatement = void 0;
 exports.CatchClause = CatchClause;
@@ -22,35 +22,31 @@ exports.VariableDeclarator = VariableDeclarator;
 exports.WhileStatement = WhileStatement;
 exports.WithStatement = WithStatement;
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
-const {
+const { isFor, isForStatement, isIfStatement, isStatement } = _t;
-  isFor,
-  isForStatement,
-  isIfStatement,
-  isStatement
-} = _t;
 
 function WithStatement(node) {
-  this.word("with");
+  this.word('with');
   this.space();
-  this.token("(");
+  this.token('(');
   this.print(node.object, node);
-  this.token(")");
+  this.token(')');
   this.printBlock(node);
 }
 
 function IfStatement(node) {
-  this.word("if");
+  this.word('if');
   this.space();
-  this.token("(");
+  this.token('(');
   this.print(node.test, node);
-  this.token(")");
+  this.token(')');
   this.space();
-  const needsBlock = node.alternate && isIfStatement(getLastStatement(node.consequent));
+  const needsBlock =
+    node.alternate && isIfStatement(getLastStatement(node.consequent));
 
   if (needsBlock) {
-    this.token("{");
+    this.token('{');
     this.newline();
     this.indent();
   }
@@ -60,12 +56,12 @@ function IfStatement(node) {
   if (needsBlock) {
     this.dedent();
     this.newline();
-    this.token("}");
+    this.token('}');
   }
 
   if (node.alternate) {
     if (this.endsWith(125)) this.space();
-    this.word("else");
+    this.word('else');
     this.space();
     this.printAndIndentOnComments(node.alternate, node);
   }
@@ -77,86 +73,86 @@ function getLastStatement(statement) {
 }
 
 function ForStatement(node) {
-  this.word("for");
+  this.word('for');
   this.space();
-  this.token("(");
+  this.token('(');
   this.inForStatementInitCounter++;
   this.print(node.init, node);
   this.inForStatementInitCounter--;
-  this.token(";");
+  this.token(';');
 
   if (node.test) {
     this.space();
     this.print(node.test, node);
   }
 
-  this.token(";");
+  this.token(';');
 
   if (node.update) {
     this.space();
     this.print(node.update, node);
   }
 
-  this.token(")");
+  this.token(')');
   this.printBlock(node);
 }
 
 function WhileStatement(node) {
-  this.word("while");
+  this.word('while');
   this.space();
-  this.token("(");
+  this.token('(');
   this.print(node.test, node);
-  this.token(")");
+  this.token(')');
   this.printBlock(node);
 }
 
 const buildForXStatement = function (op) {
   return function (node) {
-    this.word("for");
+    this.word('for');
     this.space();
 
-    if (op === "of" && node.await) {
+    if (op === 'of' && node.await) {
-      this.word("await");
+      this.word('await');
       this.space();
     }
 
-    this.token("(");
+    this.token('(');
     this.print(node.left, node);
     this.space();
     this.word(op);
     this.space();
     this.print(node.right, node);
-    this.token(")");
+    this.token(')');
     this.printBlock(node);
   };
 };
 
-const ForInStatement = buildForXStatement("in");
+const ForInStatement = buildForXStatement('in');
 exports.ForInStatement = ForInStatement;
-const ForOfStatement = buildForXStatement("of");
+const ForOfStatement = buildForXStatement('of');
 exports.ForOfStatement = ForOfStatement;
 
 function DoWhileStatement(node) {
-  this.word("do");
+  this.word('do');
   this.space();
   this.print(node.body, node);
   this.space();
-  this.word("while");
+  this.word('while');
   this.space();
-  this.token("(");
+  this.token('(');
   this.print(node.test, node);
-  this.token(")");
+  this.token(')');
   this.semicolon();
 }
 
-function buildLabelStatement(prefix, key = "label") {
+function buildLabelStatement(prefix, key = 'label') {
   return function (node) {
     this.word(prefix);
     const label = node[key];
 
     if (label) {
       this.space();
-      const isLabel = key == "label";
+      const isLabel = key == 'label';
       const terminatorState = this.startTerminatorless(isLabel);
       this.print(label, node);
       this.endTerminatorless(terminatorState);
@@ -166,24 +162,24 @@ function buildLabelStatement(prefix, key = "label") {
   };
 }
 
-const ContinueStatement = buildLabelStatement("continue");
+const ContinueStatement = buildLabelStatement('continue');
 exports.ContinueStatement = ContinueStatement;
-const ReturnStatement = buildLabelStatement("return", "argument");
+const ReturnStatement = buildLabelStatement('return', 'argument');
 exports.ReturnStatement = ReturnStatement;
-const BreakStatement = buildLabelStatement("break");
+const BreakStatement = buildLabelStatement('break');
 exports.BreakStatement = BreakStatement;
-const ThrowStatement = buildLabelStatement("throw", "argument");
+const ThrowStatement = buildLabelStatement('throw', 'argument');
 exports.ThrowStatement = ThrowStatement;
 
 function LabeledStatement(node) {
   this.print(node.label, node);
-  this.token(":");
+  this.token(':');
   this.space();
   this.print(node.body, node);
 }
 
 function TryStatement(node) {
-  this.word("try");
+  this.word('try');
   this.space();
   this.print(node.block, node);
   this.space();
@@ -196,21 +192,21 @@ function TryStatement(node) {
 
   if (node.finalizer) {
     this.space();
-    this.word("finally");
+    this.word('finally');
     this.space();
     this.print(node.finalizer, node);
   }
 }
 
 function CatchClause(node) {
-  this.word("catch");
+  this.word('catch');
   this.space();
 
   if (node.param) {
-    this.token("(");
+    this.token('(');
     this.print(node.param, node);
     this.print(node.param.typeAnnotation, node);
-    this.token(")");
+    this.token(')');
     this.space();
   }
 
@@ -218,50 +214,49 @@ function CatchClause(node) {
 }
 
 function SwitchStatement(node) {
-  this.word("switch");
+  this.word('switch');
   this.space();
-  this.token("(");
+  this.token('(');
   this.print(node.discriminant, node);
-  this.token(")");
+  this.token(')');
   this.space();
-  this.token("{");
+  this.token('{');
   this.printSequence(node.cases, node, {
     indent: true,
 
     addNewlines(leading, cas) {
       if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
-    }
+    },
-
   });
-  this.token("}");
+  this.token('}');
 }
 
 function SwitchCase(node) {
   if (node.test) {
-    this.word("case");
+    this.word('case');
     this.space();
     this.print(node.test, node);
-    this.token(":");
+    this.token(':');
   } else {
-    this.word("default");
+    this.word('default');
-    this.token(":");
+    this.token(':');
   }
 
   if (node.consequent.length) {
     this.newline();
     this.printSequence(node.consequent, node, {
-      indent: true
+      indent: true,
     });
   }
 }
 
 function DebuggerStatement() {
-  this.word("debugger");
+  this.word('debugger');
   this.semicolon();
 }
 
 function variableDeclarationIndent() {
-  this.token(",");
+  this.token(',');
   this.newline();
 
   if (this.endsWith(10)) {
@@ -270,7 +265,7 @@ function variableDeclarationIndent() {
 }
 
 function constDeclarationIndent() {
-  this.token(",");
+  this.token(',');
   this.newline();
 
   if (this.endsWith(10)) {
@@ -280,7 +275,7 @@ function constDeclarationIndent() {
 
 function VariableDeclaration(node, parent) {
   if (node.declare) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
@@ -299,11 +294,14 @@ function VariableDeclaration(node, parent) {
   let separator;
 
   if (hasInits) {
-    separator = node.kind === "const" ? constDeclarationIndent : variableDeclarationIndent;
+    separator =
+      node.kind === 'const' ?
+        constDeclarationIndent
+      : variableDeclarationIndent;
   }
 
   this.printList(node.declarations, node, {
-    separator
+    separator,
   });
 
   if (isFor(parent)) {
@@ -319,12 +317,12 @@ function VariableDeclaration(node, parent) {
 
 function VariableDeclarator(node) {
   this.print(node.id, node);
-  if (node.definite) this.token("!");
+  if (node.definite) this.token('!');
   this.print(node.id.typeAnnotation, node);
 
   if (node.init) {
     this.space();
-    this.token("=");
+    this.token('=');
     this.space();
     this.print(node.init, node);
   }

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

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.TaggedTemplateExpression = TaggedTemplateExpression;
 exports.TemplateElement = TemplateElement;
@@ -16,7 +16,7 @@ function TaggedTemplateExpression(node) {
 function TemplateElement(node, parent) {
   const isFirst = parent.quasis[0] === node;
   const isLast = parent.quasis[parent.quasis.length - 1] === node;
-  const value = (isFirst ? "`" : "}") + node.value.raw + (isLast ? "`" : "${");
+  const value = (isFirst ? '`' : '}') + node.value.raw + (isLast ? '`' : '${');
   this.token(value);
 }
 

node_modules/@babel/generator/lib/generators/types.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.ArgumentPlaceholder = ArgumentPlaceholder;
 exports.ArrayPattern = exports.ArrayExpression = ArrayExpression;
@@ -24,14 +24,11 @@ exports.StringLiteral = StringLiteral;
 exports.TopicReference = TopicReference;
 exports.TupleExpression = TupleExpression;
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
-var _jsesc = require("jsesc");
+var _jsesc = require('jsesc');
 
-const {
+const { isAssignmentPattern, isIdentifier } = _t;
-  isAssignmentPattern,
-  isIdentifier
-} = _t;
 
 function Identifier(node) {
   this.exactSource(node.loc, () => {
@@ -40,29 +37,29 @@ function Identifier(node) {
 }
 
 function ArgumentPlaceholder() {
-  this.token("?");
+  this.token('?');
 }
 
 function RestElement(node) {
-  this.token("...");
+  this.token('...');
   this.print(node.argument, node);
 }
 
 function ObjectExpression(node) {
   const props = node.properties;
-  this.token("{");
+  this.token('{');
   this.printInnerComments(node);
 
   if (props.length) {
     this.space();
     this.printList(props, node, {
       indent: true,
-      statement: true
+      statement: true,
     });
     this.space();
   }
 
-  this.token("}");
+  this.token('}');
 }
 
 function ObjectMethod(node) {
@@ -78,23 +75,32 @@ function ObjectProperty(node) {
   this.printJoin(node.decorators, node);
 
   if (node.computed) {
-    this.token("[");
+    this.token('[');
     this.print(node.key, node);
-    this.token("]");
+    this.token(']');
   } else {
-    if (isAssignmentPattern(node.value) && isIdentifier(node.key) && node.key.name === node.value.left.name) {
+    if (
+      isAssignmentPattern(node.value) &&
+      isIdentifier(node.key) &&
+      node.key.name === node.value.left.name
+    ) {
       this.print(node.value, node);
       return;
     }
 
     this.print(node.key, node);
 
-    if (node.shorthand && isIdentifier(node.key) && isIdentifier(node.value) && node.key.name === node.value.name) {
+    if (
+      node.shorthand &&
+      isIdentifier(node.key) &&
+      isIdentifier(node.value) &&
+      node.key.name === node.value.name
+    ) {
       return;
     }
   }
 
-  this.token(":");
+  this.token(':');
   this.space();
   this.print(node.value, node);
 }
@@ -102,7 +108,7 @@ function ObjectProperty(node) {
 function ArrayExpression(node) {
   const elems = node.elements;
   const len = elems.length;
-  this.token("[");
+  this.token('[');
   this.printInnerComments(node);
 
   for (let i = 0; i < elems.length; i++) {
@@ -111,13 +117,13 @@ function ArrayExpression(node) {
     if (elem) {
       if (i > 0) this.space();
       this.print(elem, node);
-      if (i < len - 1) this.token(",");
+      if (i < len - 1) this.token(',');
     } else {
-      this.token(",");
+      this.token(',');
     }
   }
 
-  this.token("]");
+  this.token(']');
 }
 
 function RecordExpression(node) {
@@ -125,14 +131,16 @@ function RecordExpression(node) {
   let startToken;
   let endToken;
 
-  if (this.format.recordAndTupleSyntaxType === "bar") {
+  if (this.format.recordAndTupleSyntaxType === 'bar') {
-    startToken = "{|";
+    startToken = '{|';
-    endToken = "|}";
+    endToken = '|}';
-  } else if (this.format.recordAndTupleSyntaxType === "hash") {
+  } else if (this.format.recordAndTupleSyntaxType === 'hash') {
-    startToken = "#{";
+    startToken = '#{';
-    endToken = "}";
+    endToken = '}';
   } else {
-    throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`);
+    throw new Error(
+      `The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`
+    );
   }
 
   this.token(startToken);
@@ -142,7 +150,7 @@ function RecordExpression(node) {
     this.space();
     this.printList(props, node, {
       indent: true,
-      statement: true
+      statement: true,
     });
     this.space();
   }
@@ -156,14 +164,16 @@ function TupleExpression(node) {
   let startToken;
   let endToken;
 
-  if (this.format.recordAndTupleSyntaxType === "bar") {
+  if (this.format.recordAndTupleSyntaxType === 'bar') {
-    startToken = "[|";
+    startToken = '[|';
-    endToken = "|]";
+    endToken = '|]';
-  } else if (this.format.recordAndTupleSyntaxType === "hash") {
+  } else if (this.format.recordAndTupleSyntaxType === 'hash') {
-    startToken = "#[";
+    startToken = '#[';
-    endToken = "]";
+    endToken = ']';
   } else {
-    throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`);
+    throw new Error(
+      `${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`
+    );
   }
 
   this.token(startToken);
@@ -175,7 +185,7 @@ function TupleExpression(node) {
     if (elem) {
       if (i > 0) this.space();
       this.print(elem, node);
-      if (i < len - 1) this.token(",");
+      if (i < len - 1) this.token(',');
     }
   }
 
@@ -187,17 +197,17 @@ function RegExpLiteral(node) {
 }
 
 function BooleanLiteral(node) {
-  this.word(node.value ? "true" : "false");
+  this.word(node.value ? 'true' : 'false');
 }
 
 function NullLiteral() {
-  this.word("null");
+  this.word('null');
 }
 
 function NumericLiteral(node) {
   const raw = this.getPossibleRaw(node);
   const opts = this.format.jsescOption;
-  const value = node.value + "";
+  const value = node.value + '';
 
   if (opts.numbers) {
     this.number(_jsesc(node.value, opts));
@@ -218,9 +228,15 @@ function StringLiteral(node) {
     return;
   }
 
-  const val = _jsesc(node.value, Object.assign(this.format.jsescOption, this.format.jsonCompatibleStrings && {
+  const val = _jsesc(
-    json: true
+    node.value,
-  }));
+    Object.assign(
+      this.format.jsescOption,
+      this.format.jsonCompatibleStrings && {
+        json: true,
+      }
+    )
+  );
 
   return this.token(val);
 }
@@ -233,7 +249,7 @@ function BigIntLiteral(node) {
     return;
   }
 
-  this.word(node.value + "n");
+  this.word(node.value + 'n');
 }
 
 function DecimalLiteral(node) {
@@ -244,22 +260,25 @@ function DecimalLiteral(node) {
     return;
   }
 
-  this.word(node.value + "m");
+  this.word(node.value + 'm');
 }
 
-const validTopicTokenSet = new Set(["^^", "@@", "^", "%", "#"]);
+const validTopicTokenSet = new Set(['^^', '@@', '^', '%', '#']);
 
 function TopicReference() {
-  const {
+  const { topicToken } = this.format;
-    topicToken
-  } = this.format;
 
   if (validTopicTokenSet.has(topicToken)) {
     this.token(topicToken);
   } else {
     const givenTopicTokenJSON = JSON.stringify(topicToken);
-    const validTopics = Array.from(validTopicTokenSet, v => JSON.stringify(v));
+    const validTopics = Array.from(validTopicTokenSet, (v) =>
-    throw new Error(`The "topicToken" generator option must be one of ` + `${validTopics.join(", ")} (${givenTopicTokenJSON} received instead).`);
+      JSON.stringify(v)
+    );
+    throw new Error(
+      `The "topicToken" generator option must be one of ` +
+        `${validTopics.join(', ')} (${givenTopicTokenJSON} received instead).`
+    );
   }
 }
 
@@ -272,5 +291,5 @@ function PipelineBareFunction(node) {
 }
 
 function PipelinePrimaryTopicReference() {
-  this.token("#");
+  this.token('#');
 }

node_modules/@babel/generator/lib/generators/typescript.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.TSAnyKeyword = TSAnyKeyword;
 exports.TSArrayType = TSArrayType;
@@ -58,7 +58,8 @@ exports.TSTypeAssertion = TSTypeAssertion;
 exports.TSTypeLiteral = TSTypeLiteral;
 exports.TSTypeOperator = TSTypeOperator;
 exports.TSTypeParameter = TSTypeParameter;
-exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation;
+exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation =
+  TSTypeParameterInstantiation;
 exports.TSTypePredicate = TSTypePredicate;
 exports.TSTypeQuery = TSTypeQuery;
 exports.TSTypeReference = TSTypeReference;
@@ -75,31 +76,31 @@ exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody;
 exports.tsPrintUnionOrIntersectionType = tsPrintUnionOrIntersectionType;
 
 function TSTypeAnnotation(node) {
-  this.token(":");
+  this.token(':');
   this.space();
-  if (node.optional) this.token("?");
+  if (node.optional) this.token('?');
   this.print(node.typeAnnotation, node);
 }
 
 function TSTypeParameterInstantiation(node, parent) {
-  this.token("<");
+  this.token('<');
   this.printList(node.params, node, {});
 
-  if (parent.type === "ArrowFunctionExpression" && node.params.length === 1) {
+  if (parent.type === 'ArrowFunctionExpression' && node.params.length === 1) {
-    this.token(",");
+    this.token(',');
   }
 
-  this.token(">");
+  this.token('>');
 }
 
 function TSTypeParameter(node) {
   if (node.in) {
-    this.word("in");
+    this.word('in');
     this.space();
   }
 
   if (node.out) {
-    this.word("out");
+    this.word('out');
     this.space();
   }
 
@@ -107,14 +108,14 @@ function TSTypeParameter(node) {
 
   if (node.constraint) {
     this.space();
-    this.word("extends");
+    this.word('extends');
     this.space();
     this.print(node.constraint, node);
   }
 
   if (node.default) {
     this.space();
-    this.token("=");
+    this.token('=');
     this.space();
     this.print(node.default, node);
   }
@@ -127,7 +128,7 @@ function TSParameterProperty(node) {
   }
 
   if (node.readonly) {
-    this.word("readonly");
+    this.word('readonly');
     this.space();
   }
 
@@ -136,47 +137,44 @@ function TSParameterProperty(node) {
 
 function TSDeclareFunction(node) {
   if (node.declare) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
   this._functionHead(node);
 
-  this.token(";");
+  this.token(';');
 }
 
 function TSDeclareMethod(node) {
   this._classMethodHead(node);
 
-  this.token(";");
+  this.token(';');
 }
 
 function TSQualifiedName(node) {
   this.print(node.left, node);
-  this.token(".");
+  this.token('.');
   this.print(node.right, node);
 }
 
 function TSCallSignatureDeclaration(node) {
   this.tsPrintSignatureDeclarationBase(node);
-  this.token(";");
+  this.token(';');
 }
 
 function TSConstructSignatureDeclaration(node) {
-  this.word("new");
+  this.word('new');
   this.space();
   this.tsPrintSignatureDeclarationBase(node);
-  this.token(";");
+  this.token(';');
 }
 
 function TSPropertySignature(node) {
-  const {
+  const { readonly, initializer } = node;
-    readonly,
-    initializer
-  } = node;
 
   if (readonly) {
-    this.word("readonly");
+    this.word('readonly');
     this.space();
   }
 
@@ -185,124 +183,119 @@ function TSPropertySignature(node) {
 
   if (initializer) {
     this.space();
-    this.token("=");
+    this.token('=');
     this.space();
     this.print(initializer, node);
   }
 
-  this.token(";");
+  this.token(';');
 }
 
 function tsPrintPropertyOrMethodName(node) {
   if (node.computed) {
-    this.token("[");
+    this.token('[');
   }
 
   this.print(node.key, node);
 
   if (node.computed) {
-    this.token("]");
+    this.token(']');
   }
 
   if (node.optional) {
-    this.token("?");
+    this.token('?');
   }
 }
 
 function TSMethodSignature(node) {
-  const {
+  const { kind } = node;
-    kind
-  } = node;
 
-  if (kind === "set" || kind === "get") {
+  if (kind === 'set' || kind === 'get') {
     this.word(kind);
     this.space();
   }
 
   this.tsPrintPropertyOrMethodName(node);
   this.tsPrintSignatureDeclarationBase(node);
-  this.token(";");
+  this.token(';');
 }
 
 function TSIndexSignature(node) {
-  const {
+  const { readonly, static: isStatic } = node;
-    readonly,
-    static: isStatic
-  } = node;
 
   if (isStatic) {
-    this.word("static");
+    this.word('static');
     this.space();
   }
 
   if (readonly) {
-    this.word("readonly");
+    this.word('readonly');
     this.space();
   }
 
-  this.token("[");
+  this.token('[');
 
   this._parameters(node.parameters, node);
 
-  this.token("]");
+  this.token(']');
   this.print(node.typeAnnotation, node);
-  this.token(";");
+  this.token(';');
 }
 
 function TSAnyKeyword() {
-  this.word("any");
+  this.word('any');
 }
 
 function TSBigIntKeyword() {
-  this.word("bigint");
+  this.word('bigint');
 }
 
 function TSUnknownKeyword() {
-  this.word("unknown");
+  this.word('unknown');
 }
 
 function TSNumberKeyword() {
-  this.word("number");
+  this.word('number');
 }
 
 function TSObjectKeyword() {
-  this.word("object");
+  this.word('object');
 }
 
 function TSBooleanKeyword() {
-  this.word("boolean");
+  this.word('boolean');
 }
 
 function TSStringKeyword() {
-  this.word("string");
+  this.word('string');
 }
 
 function TSSymbolKeyword() {
-  this.word("symbol");
+  this.word('symbol');
 }
 
 function TSVoidKeyword() {
-  this.word("void");
+  this.word('void');
 }
 
 function TSUndefinedKeyword() {
-  this.word("undefined");
+  this.word('undefined');
 }
 
 function TSNullKeyword() {
-  this.word("null");
+  this.word('null');
 }
 
 function TSNeverKeyword() {
-  this.word("never");
+  this.word('never');
 }
 
 function TSIntrinsicKeyword() {
-  this.word("intrinsic");
+  this.word('intrinsic');
 }
 
 function TSThisType() {
-  this.word("this");
+  this.word('this');
 }
 
 function TSFunctionType(node) {
@@ -311,28 +304,26 @@ function TSFunctionType(node) {
 
 function TSConstructorType(node) {
   if (node.abstract) {
-    this.word("abstract");
+    this.word('abstract');
     this.space();
   }
 
-  this.word("new");
+  this.word('new');
   this.space();
   this.tsPrintFunctionOrConstructorType(node);
 }
 
 function tsPrintFunctionOrConstructorType(node) {
-  const {
+  const { typeParameters } = node;
-    typeParameters
-  } = node;
   const parameters = node.parameters;
   this.print(typeParameters, node);
-  this.token("(");
+  this.token('(');
 
   this._parameters(parameters, node);
 
-  this.token(")");
+  this.token(')');
   this.space();
-  this.token("=>");
+  this.token('=>');
   this.space();
   const returnType = node.typeAnnotation;
   this.print(returnType.typeAnnotation, node);
@@ -345,7 +336,7 @@ function TSTypeReference(node) {
 
 function TSTypePredicate(node) {
   if (node.asserts) {
-    this.word("asserts");
+    this.word('asserts');
     this.space();
   }
 
@@ -353,14 +344,14 @@ function TSTypePredicate(node) {
 
   if (node.typeAnnotation) {
     this.space();
-    this.word("is");
+    this.word('is');
     this.space();
     this.print(node.typeAnnotation.typeAnnotation);
   }
 }
 
 function TSTypeQuery(node) {
-  this.word("typeof");
+  this.word('typeof');
   this.space();
   this.print(node.exprName);
 
@@ -378,7 +369,7 @@ function tsPrintTypeLiteralOrInterfaceBody(members, node) {
 }
 
 function tsPrintBraced(members, node) {
-  this.token("{");
+  this.token('{');
 
   if (members.length) {
     this.indent();
@@ -392,45 +383,45 @@ function tsPrintBraced(members, node) {
     this.dedent();
     this.rightBrace();
   } else {
-    this.token("}");
+    this.token('}');
   }
 }
 
 function TSArrayType(node) {
   this.print(node.elementType, node);
-  this.token("[]");
+  this.token('[]');
 }
 
 function TSTupleType(node) {
-  this.token("[");
+  this.token('[');
   this.printList(node.elementTypes, node);
-  this.token("]");
+  this.token(']');
 }
 
 function TSOptionalType(node) {
   this.print(node.typeAnnotation, node);
-  this.token("?");
+  this.token('?');
 }
 
 function TSRestType(node) {
-  this.token("...");
+  this.token('...');
   this.print(node.typeAnnotation, node);
 }
 
 function TSNamedTupleMember(node) {
   this.print(node.label, node);
-  if (node.optional) this.token("?");
+  if (node.optional) this.token('?');
-  this.token(":");
+  this.token(':');
   this.space();
   this.print(node.elementType, node);
 }
 
 function TSUnionType(node) {
-  this.tsPrintUnionOrIntersectionType(node, "|");
+  this.tsPrintUnionOrIntersectionType(node, '|');
 }
 
 function TSIntersectionType(node) {
-  this.tsPrintUnionOrIntersectionType(node, "&");
+  this.tsPrintUnionOrIntersectionType(node, '&');
 }
 
 function tsPrintUnionOrIntersectionType(node, sep) {
@@ -439,37 +430,36 @@ function tsPrintUnionOrIntersectionType(node, sep) {
       this.space();
       this.token(sep);
       this.space();
-    }
+    },
-
   });
 }
 
 function TSConditionalType(node) {
   this.print(node.checkType);
   this.space();
-  this.word("extends");
+  this.word('extends');
   this.space();
   this.print(node.extendsType);
   this.space();
-  this.token("?");
+  this.token('?');
   this.space();
   this.print(node.trueType);
   this.space();
-  this.token(":");
+  this.token(':');
   this.space();
   this.print(node.falseType);
 }
 
 function TSInferType(node) {
-  this.token("infer");
+  this.token('infer');
   this.space();
   this.print(node.typeParameter);
 }
 
 function TSParenthesizedType(node) {
-  this.token("(");
+  this.token('(');
   this.print(node.typeAnnotation, node);
-  this.token(")");
+  this.token(')');
 }
 
 function TSTypeOperator(node) {
@@ -480,53 +470,48 @@ function TSTypeOperator(node) {
 
 function TSIndexedAccessType(node) {
   this.print(node.objectType, node);
-  this.token("[");
+  this.token('[');
   this.print(node.indexType, node);
-  this.token("]");
+  this.token(']');
 }
 
 function TSMappedType(node) {
-  const {
+  const { nameType, optional, readonly, typeParameter } = node;
-    nameType,
+  this.token('{');
-    optional,
-    readonly,
-    typeParameter
-  } = node;
-  this.token("{");
   this.space();
 
   if (readonly) {
     tokenIfPlusMinus(this, readonly);
-    this.word("readonly");
+    this.word('readonly');
     this.space();
   }
 
-  this.token("[");
+  this.token('[');
   this.word(typeParameter.name);
   this.space();
-  this.word("in");
+  this.word('in');
   this.space();
   this.print(typeParameter.constraint, typeParameter);
 
   if (nameType) {
     this.space();
-    this.word("as");
+    this.word('as');
     this.space();
     this.print(nameType, node);
   }
 
-  this.token("]");
+  this.token(']');
 
   if (optional) {
     tokenIfPlusMinus(this, optional);
-    this.token("?");
+    this.token('?');
   }
 
-  this.token(":");
+  this.token(':');
   this.space();
   this.print(node.typeAnnotation, node);
   this.space();
-  this.token("}");
+  this.token('}');
 }
 
 function tokenIfPlusMinus(self, tok) {
@@ -545,27 +530,21 @@ function TSExpressionWithTypeArguments(node) {
 }
 
 function TSInterfaceDeclaration(node) {
-  const {
+  const { declare, id, typeParameters, extends: extendz, body } = node;
-    declare,
-    id,
-    typeParameters,
-    extends: extendz,
-    body
-  } = node;
 
   if (declare) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
-  this.word("interface");
+  this.word('interface');
   this.space();
   this.print(id, node);
   this.print(typeParameters, node);
 
   if (extendz != null && extendz.length) {
     this.space();
-    this.word("extends");
+    this.word('extends');
     this.space();
     this.printList(extendz, node);
   }
@@ -579,49 +558,38 @@ function TSInterfaceBody(node) {
 }
 
 function TSTypeAliasDeclaration(node) {
-  const {
+  const { declare, id, typeParameters, typeAnnotation } = node;
-    declare,
-    id,
-    typeParameters,
-    typeAnnotation
-  } = node;
 
   if (declare) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
-  this.word("type");
+  this.word('type');
   this.space();
   this.print(id, node);
   this.print(typeParameters, node);
   this.space();
-  this.token("=");
+  this.token('=');
   this.space();
   this.print(typeAnnotation, node);
-  this.token(";");
+  this.token(';');
 }
 
 function TSAsExpression(node) {
-  const {
+  const { expression, typeAnnotation } = node;
-    expression,
-    typeAnnotation
-  } = node;
   this.print(expression, node);
   this.space();
-  this.word("as");
+  this.word('as');
   this.space();
   this.print(typeAnnotation, node);
 }
 
 function TSTypeAssertion(node) {
-  const {
+  const { typeAnnotation, expression } = node;
-    typeAnnotation,
+  this.token('<');
-    expression
-  } = node;
-  this.token("<");
   this.print(typeAnnotation, node);
-  this.token(">");
+  this.token('>');
   this.space();
   this.print(expression, node);
 }
@@ -632,24 +600,19 @@ function TSInstantiationExpression(node) {
 }
 
 function TSEnumDeclaration(node) {
-  const {
+  const { declare, const: isConst, id, members } = node;
-    declare,
-    const: isConst,
-    id,
-    members
-  } = node;
 
   if (declare) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
   if (isConst) {
-    this.word("const");
+    this.word('const');
     this.space();
   }
 
-  this.word("enum");
+  this.word('enum');
   this.space();
   this.print(id, node);
   this.space();
@@ -657,49 +620,43 @@ function TSEnumDeclaration(node) {
 }
 
 function TSEnumMember(node) {
-  const {
+  const { id, initializer } = node;
-    id,
-    initializer
-  } = node;
   this.print(id, node);
 
   if (initializer) {
     this.space();
-    this.token("=");
+    this.token('=');
     this.space();
     this.print(initializer, node);
   }
 
-  this.token(",");
+  this.token(',');
 }
 
 function TSModuleDeclaration(node) {
-  const {
+  const { declare, id } = node;
-    declare,
-    id
-  } = node;
 
   if (declare) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
   if (!node.global) {
-    this.word(id.type === "Identifier" ? "namespace" : "module");
+    this.word(id.type === 'Identifier' ? 'namespace' : 'module');
     this.space();
   }
 
   this.print(id, node);
 
   if (!node.body) {
-    this.token(";");
+    this.token(';');
     return;
   }
 
   let body = node.body;
 
-  while (body.type === "TSModuleDeclaration") {
+  while (body.type === 'TSModuleDeclaration') {
-    this.token(".");
+    this.token('.');
     this.print(body.id, body);
     body = body.body;
   }
@@ -713,18 +670,14 @@ function TSModuleBlock(node) {
 }
 
 function TSImportType(node) {
-  const {
+  const { argument, qualifier, typeParameters } = node;
-    argument,
+  this.word('import');
-    qualifier,
+  this.token('(');
-    typeParameters
-  } = node;
-  this.word("import");
-  this.token("(");
   this.print(argument, node);
-  this.token(")");
+  this.token(')');
 
   if (qualifier) {
-    this.token(".");
+    this.token('.');
     this.print(qualifier, node);
   }
 
@@ -734,75 +687,69 @@ function TSImportType(node) {
 }
 
 function TSImportEqualsDeclaration(node) {
-  const {
+  const { isExport, id, moduleReference } = node;
-    isExport,
-    id,
-    moduleReference
-  } = node;
 
   if (isExport) {
-    this.word("export");
+    this.word('export');
     this.space();
   }
 
-  this.word("import");
+  this.word('import');
   this.space();
   this.print(id, node);
   this.space();
-  this.token("=");
+  this.token('=');
   this.space();
   this.print(moduleReference, node);
-  this.token(";");
+  this.token(';');
 }
 
 function TSExternalModuleReference(node) {
-  this.token("require(");
+  this.token('require(');
   this.print(node.expression, node);
-  this.token(")");
+  this.token(')');
 }
 
 function TSNonNullExpression(node) {
   this.print(node.expression, node);
-  this.token("!");
+  this.token('!');
 }
 
 function TSExportAssignment(node) {
-  this.word("export");
+  this.word('export');
   this.space();
-  this.token("=");
+  this.token('=');
   this.space();
   this.print(node.expression, node);
-  this.token(";");
+  this.token(';');
 }
 
 function TSNamespaceExportDeclaration(node) {
-  this.word("export");
+  this.word('export');
   this.space();
-  this.word("as");
+  this.word('as');
   this.space();
-  this.word("namespace");
+  this.word('namespace');
   this.space();
   this.print(node.id, node);
 }
 
 function tsPrintSignatureDeclarationBase(node) {
-  const {
+  const { typeParameters } = node;
-    typeParameters
-  } = node;
   const parameters = node.parameters;
   this.print(typeParameters, node);
-  this.token("(");
+  this.token('(');
 
   this._parameters(parameters, node);
 
-  this.token(")");
+  this.token(')');
   const returnType = node.typeAnnotation;
   this.print(returnType, node);
 }
 
 function tsPrintClassMemberModifiers(node, isField) {
   if (isField && node.declare) {
-    this.word("declare");
+    this.word('declare');
     this.space();
   }
 
@@ -812,22 +759,22 @@ function tsPrintClassMemberModifiers(node, isField) {
   }
 
   if (node.static) {
-    this.word("static");
+    this.word('static');
     this.space();
   }
 
   if (node.override) {
-    this.word("override");
+    this.word('override');
     this.space();
   }
 
   if (node.abstract) {
-    this.word("abstract");
+    this.word('abstract');
     this.space();
   }
 
   if (isField && node.readonly) {
-    this.word("readonly");
+    this.word('readonly');
     this.space();
   }
 }

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

@@ -1,14 +1,14 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.CodeGenerator = void 0;
 exports.default = generate;
 
-var _sourceMap = require("./source-map");
+var _sourceMap = require('./source-map');
 
-var _printer = require("./printer");
+var _printer = require('./printer');
 
 class Generator extends _printer.default {
   constructor(ast, opts = {}, code) {
@@ -22,7 +22,6 @@ class Generator extends _printer.default {
   generate() {
     return super.generate(this.ast);
   }
-
 }
 
 function normalizeOptions(code, opts) {
@@ -38,17 +37,20 @@ function normalizeOptions(code, opts) {
     concise: opts.concise,
     indent: {
       adjustMultilineComment: true,
-      style: "  ",
+      style: '  ',
-      base: 0
+      base: 0,
     },
     decoratorsBeforeExport: !!opts.decoratorsBeforeExport,
-    jsescOption: Object.assign({
+    jsescOption: Object.assign(
-      quotes: "double",
+      {
+        quotes: 'double',
         wrap: true,
-      minimal: false
+        minimal: false,
-    }, opts.jsescOption),
+      },
+      opts.jsescOption
+    ),
     recordAndTupleSyntaxType: opts.recordAndTupleSyntaxType,
-    topicToken: opts.topicToken
+    topicToken: opts.topicToken,
   };
   {
     format.jsonCompatibleStrings = opts.jsonCompatibleStrings;
@@ -57,16 +59,25 @@ function normalizeOptions(code, opts) {
   if (format.minified) {
     format.compact = true;
 
-    format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
+    format.shouldPrintComment =
+      format.shouldPrintComment || (() => format.comments);
   } else {
-    format.shouldPrintComment = format.shouldPrintComment || (value => format.comments || value.indexOf("@license") >= 0 || value.indexOf("@preserve") >= 0);
+    format.shouldPrintComment =
+      format.shouldPrintComment ||
+      ((value) =>
+        format.comments ||
+        value.indexOf('@license') >= 0 ||
+        value.indexOf('@preserve') >= 0);
   }
 
-  if (format.compact === "auto") {
+  if (format.compact === 'auto') {
     format.compact = code.length > 500000;
 
     if (format.compact) {
-      console.error("[BABEL] Note: The code generator has deoptimised the styling of " + `${opts.filename} as it exceeds the max of ${"500KB"}.`);
+      console.error(
+        '[BABEL] Note: The code generator has deoptimised the styling of ' +
+          `${opts.filename} as it exceeds the max of ${'500KB'}.`
+      );
     }
   }
 
@@ -86,7 +97,6 @@ class CodeGenerator {
   generate() {
     return this._generator.generate();
   }
-
 }
 
 exports.CodeGenerator = CodeGenerator;

node_modules/@babel/generator/lib/node/index.js

@@ -1,25 +1,25 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.needsParens = needsParens;
 exports.needsWhitespace = needsWhitespace;
 exports.needsWhitespaceAfter = needsWhitespaceAfter;
 exports.needsWhitespaceBefore = needsWhitespaceBefore;
 
-var whitespace = require("./whitespace");
+var whitespace = require('./whitespace');
 
-var parens = require("./parentheses");
+var parens = require('./parentheses');
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
 const {
   FLIPPED_ALIAS_KEYS,
   isCallExpression,
   isExpressionStatement,
   isMemberExpression,
-  isNewExpression
+  isNewExpression,
 } = _t;
 
 function expandAliases(obj) {
@@ -27,10 +27,13 @@ function expandAliases(obj) {
 
   function add(type, func) {
     const fn = newObj[type];
-    newObj[type] = fn ? function (node, parent, stack) {
+    newObj[type] =
+      fn ?
+        function (node, parent, stack) {
           const result = fn(node, parent, stack);
           return result == null ? func(node, parent, stack) : result;
-    } : func;
+        }
+      : func;
   }
 
   for (const type of Object.keys(obj)) {
@@ -85,7 +88,7 @@ function needsWhitespace(node, parent, type) {
     }
   }
 
-  if (typeof linesInfo === "object" && linesInfo !== null) {
+  if (typeof linesInfo === 'object' && linesInfo !== null) {
     return linesInfo[type] || 0;
   }
 
@@ -93,11 +96,11 @@ function needsWhitespace(node, parent, type) {
 }
 
 function needsWhitespaceBefore(node, parent) {
-  return needsWhitespace(node, parent, "before");
+  return needsWhitespace(node, parent, 'before');
 }
 
 function needsWhitespaceAfter(node, parent) {
-  return needsWhitespace(node, parent, "after");
+  return needsWhitespace(node, parent, 'after');
 }
 
 function needsParens(node, parent, printStack) {

node_modules/@babel/generator/lib/node/parentheses.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.ArrowFunctionExpression = ArrowFunctionExpression;
 exports.AssignmentExpression = AssignmentExpression;
@@ -17,7 +17,8 @@ exports.LogicalExpression = LogicalExpression;
 exports.NullableTypeAnnotation = NullableTypeAnnotation;
 exports.ObjectExpression = ObjectExpression;
 exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
-exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression;
+exports.OptionalCallExpression = exports.OptionalMemberExpression =
+  OptionalMemberExpression;
 exports.SequenceExpression = SequenceExpression;
 exports.TSAsExpression = TSAsExpression;
 exports.TSInferType = TSInferType;
@@ -25,11 +26,12 @@ exports.TSInstantiationExpression = TSInstantiationExpression;
 exports.TSTypeAssertion = TSTypeAssertion;
 exports.TSIntersectionType = exports.TSUnionType = TSUnionType;
 exports.UnaryLike = UnaryLike;
-exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation =
+  UnionTypeAnnotation;
 exports.UpdateExpression = UpdateExpression;
 exports.AwaitExpression = exports.YieldExpression = YieldExpression;
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
 const {
   isArrayTypeAnnotation,
@@ -81,46 +83,62 @@ const {
   isUnionTypeAnnotation,
   isVariableDeclarator,
   isWhileStatement,
-  isYieldExpression
+  isYieldExpression,
 } = _t;
 const PRECEDENCE = {
-  "||": 0,
+  '||': 0,
-  "??": 0,
+  '??': 0,
-  "&&": 1,
+  '&&': 1,
-  "|": 2,
+  '|': 2,
-  "^": 3,
+  '^': 3,
-  "&": 4,
+  '&': 4,
-  "==": 5,
+  '==': 5,
-  "===": 5,
+  '===': 5,
-  "!=": 5,
+  '!=': 5,
-  "!==": 5,
+  '!==': 5,
-  "<": 6,
+  '<': 6,
-  ">": 6,
+  '>': 6,
-  "<=": 6,
+  '<=': 6,
-  ">=": 6,
+  '>=': 6,
   in: 6,
   instanceof: 6,
-  ">>": 7,
+  '>>': 7,
-  "<<": 7,
+  '<<': 7,
-  ">>>": 7,
+  '>>>': 7,
-  "+": 8,
+  '+': 8,
-  "-": 8,
+  '-': 8,
-  "*": 9,
+  '*': 9,
-  "/": 9,
+  '/': 9,
-  "%": 9,
+  '%': 9,
-  "**": 10
+  '**': 10,
 };
 
-const isClassExtendsClause = (node, parent) => (isClassDeclaration(parent) || isClassExpression(parent)) && parent.superClass === node;
+const isClassExtendsClause = (node, parent) =>
+  (isClassDeclaration(parent) || isClassExpression(parent)) &&
+  parent.superClass === node;
 
-const hasPostfixPart = (node, parent) => (isMemberExpression(parent) || isOptionalMemberExpression(parent)) && parent.object === node || (isCallExpression(parent) || isOptionalCallExpression(parent) || isNewExpression(parent)) && parent.callee === node || isTaggedTemplateExpression(parent) && parent.tag === node || isTSNonNullExpression(parent);
+const hasPostfixPart = (node, parent) =>
+  ((isMemberExpression(parent) || isOptionalMemberExpression(parent)) &&
+    parent.object === node) ||
+  ((isCallExpression(parent) ||
+    isOptionalCallExpression(parent) ||
+    isNewExpression(parent)) &&
+    parent.callee === node) ||
+  (isTaggedTemplateExpression(parent) && parent.tag === node) ||
+  isTSNonNullExpression(parent);
 
 function NullableTypeAnnotation(node, parent) {
   return isArrayTypeAnnotation(parent);
 }
 
 function FunctionTypeAnnotation(node, parent, printStack) {
-  return isUnionTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isArrayTypeAnnotation(parent) || isTypeAnnotation(parent) && isArrowFunctionExpression(printStack[printStack.length - 3]);
+  return (
+    isUnionTypeAnnotation(parent) ||
+    isIntersectionTypeAnnotation(parent) ||
+    isArrayTypeAnnotation(parent) ||
+    (isTypeAnnotation(parent) &&
+      isArrowFunctionExpression(printStack[printStack.length - 3]))
+  );
 }
 
 function UpdateExpression(node, parent) {
@@ -130,20 +148,26 @@ function UpdateExpression(node, parent) {
 function ObjectExpression(node, parent, printStack) {
   return isFirstInContext(printStack, {
     expressionStatement: true,
-    arrowBody: true
+    arrowBody: true,
   });
 }
 
 function DoExpression(node, parent, printStack) {
-  return !node.async && isFirstInContext(printStack, {
+  return (
-    expressionStatement: true
+    !node.async &&
-  });
+    isFirstInContext(printStack, {
+      expressionStatement: true,
+    })
+  );
 }
 
 function Binary(node, parent) {
-  if (node.operator === "**" && isBinaryExpression(parent, {
+  if (
-    operator: "**"
+    node.operator === '**' &&
-  })) {
+    isBinaryExpression(parent, {
+      operator: '**',
+    })
+  ) {
     return parent.left === node;
   }
 
@@ -151,7 +175,11 @@ function Binary(node, parent) {
     return true;
   }
 
-  if (hasPostfixPart(node, parent) || isUnaryLike(parent) || isAwaitExpression(parent)) {
+  if (
+    hasPostfixPart(node, parent) ||
+    isUnaryLike(parent) ||
+    isAwaitExpression(parent)
+  ) {
     return true;
   }
 
@@ -161,19 +189,29 @@ function Binary(node, parent) {
     const nodeOp = node.operator;
     const nodePos = PRECEDENCE[nodeOp];
 
-    if (parentPos === nodePos && parent.right === node && !isLogicalExpression(parent) || parentPos > nodePos) {
+    if (
+      (parentPos === nodePos &&
+        parent.right === node &&
+        !isLogicalExpression(parent)) ||
+      parentPos > nodePos
+    ) {
       return true;
     }
   }
 }
 
 function UnionTypeAnnotation(node, parent) {
-  return isArrayTypeAnnotation(parent) || isNullableTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isUnionTypeAnnotation(parent);
+  return (
+    isArrayTypeAnnotation(parent) ||
+    isNullableTypeAnnotation(parent) ||
+    isIntersectionTypeAnnotation(parent) ||
+    isUnionTypeAnnotation(parent)
+  );
 }
 
 function OptionalIndexedAccessType(node, parent) {
   return isIndexedAccessType(parent, {
-    objectType: node
+    objectType: node,
   });
 }
 
@@ -186,7 +224,13 @@ function TSTypeAssertion() {
 }
 
 function TSUnionType(node, parent) {
-  return isTSArrayType(parent) || isTSOptionalType(parent) || isTSIntersectionType(parent) || isTSUnionType(parent) || isTSRestType(parent);
+  return (
+    isTSArrayType(parent) ||
+    isTSOptionalType(parent) ||
+    isTSIntersectionType(parent) ||
+    isTSUnionType(parent) ||
+    isTSRestType(parent)
+  );
 }
 
 function TSInferType(node, parent) {
@@ -194,15 +238,32 @@ function TSInferType(node, parent) {
 }
 
 function TSInstantiationExpression(node, parent) {
-  return (isCallExpression(parent) || isOptionalCallExpression(parent) || isNewExpression(parent) || isTSInstantiationExpression(parent)) && !!parent.typeParameters;
+  return (
+    (isCallExpression(parent) ||
+      isOptionalCallExpression(parent) ||
+      isNewExpression(parent) ||
+      isTSInstantiationExpression(parent)) &&
+    !!parent.typeParameters
+  );
 }
 
 function BinaryExpression(node, parent) {
-  return node.operator === "in" && (isVariableDeclarator(parent) || isFor(parent));
+  return (
+    node.operator === 'in' && (isVariableDeclarator(parent) || isFor(parent))
+  );
 }
 
 function SequenceExpression(node, parent) {
-  if (isForStatement(parent) || isThrowStatement(parent) || isReturnStatement(parent) || isIfStatement(parent) && parent.test === node || isWhileStatement(parent) && parent.test === node || isForInStatement(parent) && parent.right === node || isSwitchStatement(parent) && parent.discriminant === node || isExpressionStatement(parent) && parent.expression === node) {
+  if (
+    isForStatement(parent) ||
+    isThrowStatement(parent) ||
+    isReturnStatement(parent) ||
+    (isIfStatement(parent) && parent.test === node) ||
+    (isWhileStatement(parent) && parent.test === node) ||
+    (isForInStatement(parent) && parent.right === node) ||
+    (isSwitchStatement(parent) && parent.discriminant === node) ||
+    (isExpressionStatement(parent) && parent.expression === node)
+  ) {
     return false;
   }
 
@@ -210,27 +271,38 @@ function SequenceExpression(node, parent) {
 }
 
 function YieldExpression(node, parent) {
-  return isBinary(parent) || isUnaryLike(parent) || hasPostfixPart(node, parent) || isAwaitExpression(parent) && isYieldExpression(node) || isConditionalExpression(parent) && node === parent.test || isClassExtendsClause(node, parent);
+  return (
+    isBinary(parent) ||
+    isUnaryLike(parent) ||
+    hasPostfixPart(node, parent) ||
+    (isAwaitExpression(parent) && isYieldExpression(node)) ||
+    (isConditionalExpression(parent) && node === parent.test) ||
+    isClassExtendsClause(node, parent)
+  );
 }
 
 function ClassExpression(node, parent, printStack) {
   return isFirstInContext(printStack, {
     expressionStatement: true,
-    exportDefault: true
+    exportDefault: true,
   });
 }
 
 function UnaryLike(node, parent) {
-  return hasPostfixPart(node, parent) || isBinaryExpression(parent, {
+  return (
-    operator: "**",
+    hasPostfixPart(node, parent) ||
-    left: node
+    isBinaryExpression(parent, {
-  }) || isClassExtendsClause(node, parent);
+      operator: '**',
+      left: node,
+    }) ||
+    isClassExtendsClause(node, parent)
+  );
 }
 
 function FunctionExpression(node, parent, printStack) {
   return isFirstInContext(printStack, {
     expressionStatement: true,
-    exportDefault: true
+    exportDefault: true,
   });
 }
 
@@ -239,9 +311,16 @@ function ArrowFunctionExpression(node, parent) {
 }
 
 function ConditionalExpression(node, parent) {
-  if (isUnaryLike(parent) || isBinary(parent) || isConditionalExpression(parent, {
+  if (
-    test: node
+    isUnaryLike(parent) ||
-  }) || isAwaitExpression(parent) || isTSTypeAssertion(parent) || isTSAsExpression(parent)) {
+    isBinary(parent) ||
+    isConditionalExpression(parent, {
+      test: node,
+    }) ||
+    isAwaitExpression(parent) ||
+    isTSTypeAssertion(parent) ||
+    isTSAsExpression(parent)
+  ) {
     return true;
   }
 
@@ -249,11 +328,14 @@ function ConditionalExpression(node, parent) {
 }
 
 function OptionalMemberExpression(node, parent) {
-  return isCallExpression(parent, {
+  return (
-    callee: node
+    isCallExpression(parent, {
-  }) || isMemberExpression(parent, {
+      callee: node,
-    object: node
+    }) ||
-  });
+    isMemberExpression(parent, {
+      object: node,
+    })
+  );
 }
 
 function AssignmentExpression(node, parent) {
@@ -266,86 +348,119 @@ function AssignmentExpression(node, parent) {
 
 function LogicalExpression(node, parent) {
   switch (node.operator) {
-    case "||":
+    case '||':
       if (!isLogicalExpression(parent)) return false;
-      return parent.operator === "??" || parent.operator === "&&";
+      return parent.operator === '??' || parent.operator === '&&';
 
-    case "&&":
+    case '&&':
       return isLogicalExpression(parent, {
-        operator: "??"
+        operator: '??',
       });
 
-    case "??":
+    case '??':
-      return isLogicalExpression(parent) && parent.operator !== "??";
+      return isLogicalExpression(parent) && parent.operator !== '??';
   }
 }
 
 function Identifier(node, parent, printStack) {
   var _node$extra;
 
-  if ((_node$extra = node.extra) != null && _node$extra.parenthesized && isAssignmentExpression(parent, {
+  if (
-    left: node
+    (_node$extra = node.extra) != null &&
-  }) && (isFunctionExpression(parent.right) || isClassExpression(parent.right)) && parent.right.id == null) {
+    _node$extra.parenthesized &&
+    isAssignmentExpression(parent, {
+      left: node,
+    }) &&
+    (isFunctionExpression(parent.right) || isClassExpression(parent.right)) &&
+    parent.right.id == null
+  ) {
     return true;
   }
 
-  if (node.name === "let") {
+  if (node.name === 'let') {
-    const isFollowedByBracket = isMemberExpression(parent, {
+    const isFollowedByBracket =
-      object: node,
+      isMemberExpression(parent, {
-      computed: true
-    }) || isOptionalMemberExpression(parent, {
         object: node,
         computed: true,
-      optional: false
+      }) ||
+      isOptionalMemberExpression(parent, {
+        object: node,
+        computed: true,
+        optional: false,
       });
     return isFirstInContext(printStack, {
       expressionStatement: isFollowedByBracket,
       forHead: isFollowedByBracket,
       forInHead: isFollowedByBracket,
-      forOfHead: true
+      forOfHead: true,
     });
   }
 
-  return node.name === "async" && isForOfStatement(parent) && node === parent.left;
+  return (
+    node.name === 'async' && isForOfStatement(parent) && node === parent.left
+  );
 }
 
-function isFirstInContext(printStack, {
+function isFirstInContext(
+  printStack,
+  {
     expressionStatement = false,
     arrowBody = false,
     exportDefault = false,
     forHead = false,
     forInHead = false,
-  forOfHead = false
+    forOfHead = false,
-}) {
+  }
+) {
   let i = printStack.length - 1;
   let node = printStack[i];
   i--;
   let parent = printStack[i];
 
   while (i >= 0) {
-    if (expressionStatement && isExpressionStatement(parent, {
+    if (
-      expression: node
+      (expressionStatement &&
-    }) || exportDefault && isExportDefaultDeclaration(parent, {
+        isExpressionStatement(parent, {
-      declaration: node
+          expression: node,
-    }) || arrowBody && isArrowFunctionExpression(parent, {
+        })) ||
-      body: node
+      (exportDefault &&
-    }) || forHead && isForStatement(parent, {
+        isExportDefaultDeclaration(parent, {
-      init: node
+          declaration: node,
-    }) || forInHead && isForInStatement(parent, {
+        })) ||
-      left: node
+      (arrowBody &&
-    }) || forOfHead && isForOfStatement(parent, {
+        isArrowFunctionExpression(parent, {
-      left: node
+          body: node,
-    })) {
+        })) ||
+      (forHead &&
+        isForStatement(parent, {
+          init: node,
+        })) ||
+      (forInHead &&
+        isForInStatement(parent, {
+          left: node,
+        })) ||
+      (forOfHead &&
+        isForOfStatement(parent, {
+          left: node,
+        }))
+    ) {
       return true;
     }
 
-    if (hasPostfixPart(node, parent) && !isNewExpression(parent) || isSequenceExpression(parent) && parent.expressions[0] === node || isUpdateExpression(parent) && !parent.prefix || isConditional(parent, {
+    if (
-      test: node
+      (hasPostfixPart(node, parent) && !isNewExpression(parent)) ||
-    }) || isBinary(parent, {
+      (isSequenceExpression(parent) && parent.expressions[0] === node) ||
-      left: node
+      (isUpdateExpression(parent) && !parent.prefix) ||
-    }) || isAssignmentExpression(parent, {
+      isConditional(parent, {
-      left: node
+        test: node,
-    })) {
+      }) ||
+      isBinary(parent, {
+        left: node,
+      }) ||
+      isAssignmentExpression(parent, {
+        left: node,
+      })
+    ) {
       node = parent;
       i--;
       parent = printStack[i];

node_modules/@babel/generator/lib/node/whitespace.js

@@ -1,11 +1,11 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.nodes = exports.list = void 0;
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
 const {
   FLIPPED_ALIAS_KEYS,
@@ -21,7 +21,7 @@ const {
   isObjectExpression,
   isOptionalCallExpression,
   isOptionalMemberExpression,
-  isStringLiteral
+  isStringLiteral,
 } = _t;
 
 function crawl(node, state = {}) {
@@ -47,28 +47,36 @@ function isHelper(node) {
   if (isMemberExpression(node)) {
     return isHelper(node.object) || isHelper(node.property);
   } else if (isIdentifier(node)) {
-    return node.name === "require" || node.name[0] === "_";
+    return node.name === 'require' || node.name[0] === '_';
   } else if (isCallExpression(node)) {
     return isHelper(node.callee);
   } else if (isBinary(node) || isAssignmentExpression(node)) {
-    return isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right);
+    return (
+      (isIdentifier(node.left) && isHelper(node.left)) || isHelper(node.right)
+    );
   } else {
     return false;
   }
 }
 
 function isType(node) {
-  return isLiteral(node) || isObjectExpression(node) || isArrayExpression(node) || isIdentifier(node) || isMemberExpression(node);
+  return (
+    isLiteral(node) ||
+    isObjectExpression(node) ||
+    isArrayExpression(node) ||
+    isIdentifier(node) ||
+    isMemberExpression(node)
+  );
 }
 
 const nodes = {
   AssignmentExpression(node) {
     const state = crawl(node.right);
 
-    if (state.hasCall && state.hasHelper || state.hasFunction) {
+    if ((state.hasCall && state.hasHelper) || state.hasFunction) {
       return {
         before: state.hasFunction,
-        after: true
+        after: true,
       };
     }
   },
@@ -76,22 +84,24 @@ const nodes = {
   SwitchCase(node, parent) {
     return {
       before: !!node.consequent.length || parent.cases[0] === node,
-      after: !node.consequent.length && parent.cases[parent.cases.length - 1] === node
+      after:
+        !node.consequent.length &&
+        parent.cases[parent.cases.length - 1] === node,
     };
   },
 
   LogicalExpression(node) {
     if (isFunction(node.left) || isFunction(node.right)) {
       return {
-        after: true
+        after: true,
       };
     }
   },
 
   Literal(node) {
-    if (isStringLiteral(node) && node.value === "use strict") {
+    if (isStringLiteral(node) && node.value === 'use strict') {
       return {
-        after: true
+        after: true,
       };
     }
   },
@@ -100,7 +110,7 @@ const nodes = {
     if (isFunction(node.callee) || isHelper(node)) {
       return {
         before: true,
-        after: true
+        after: true,
       };
     }
   },
@@ -109,7 +119,7 @@ const nodes = {
     if (isFunction(node.callee)) {
       return {
         before: true,
-        after: true
+        after: true,
       };
     }
   },
@@ -121,13 +131,13 @@ const nodes = {
 
       if (!enabled) {
         const state = crawl(declar.init);
-        enabled = isHelper(declar.init) && state.hasCall || state.hasFunction;
+        enabled = (isHelper(declar.init) && state.hasCall) || state.hasFunction;
       }
 
       if (enabled) {
         return {
           before: true,
-          after: true
+          after: true,
         };
       }
     }
@@ -137,28 +147,36 @@ const nodes = {
     if (isBlockStatement(node.consequent)) {
       return {
         before: true,
-        after: true
+        after: true,
       };
     }
-  }
+  },
-
 };
 exports.nodes = nodes;
 
-nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) {
+nodes.ObjectProperty =
+  nodes.ObjectTypeProperty =
+  nodes.ObjectMethod =
+    function (node, parent) {
       if (parent.properties[0] === node) {
         return {
-      before: true
+          before: true,
         };
       }
-};
+    };
 
 nodes.ObjectTypeCallProperty = function (node, parent) {
   var _parent$properties;
 
-  if (parent.callProperties[0] === node && !((_parent$properties = parent.properties) != null && _parent$properties.length)) {
+  if (
+    parent.callProperties[0] === node &&
+    !(
+      (_parent$properties = parent.properties) != null &&
+      _parent$properties.length
+    )
+  ) {
     return {
-      before: true
+      before: true,
     };
   }
 };
@@ -166,9 +184,19 @@ nodes.ObjectTypeCallProperty = function (node, parent) {
 nodes.ObjectTypeIndexer = function (node, parent) {
   var _parent$properties2, _parent$callPropertie;
 
-  if (parent.indexers[0] === node && !((_parent$properties2 = parent.properties) != null && _parent$properties2.length) && !((_parent$callPropertie = parent.callProperties) != null && _parent$callPropertie.length)) {
+  if (
+    parent.indexers[0] === node &&
+    !(
+      (_parent$properties2 = parent.properties) != null &&
+      _parent$properties2.length
+    ) &&
+    !(
+      (_parent$callPropertie = parent.callProperties) != null &&
+      _parent$callPropertie.length
+    )
+  ) {
     return {
-      before: true
+      before: true,
     };
   }
 };
@@ -176,16 +204,27 @@ nodes.ObjectTypeIndexer = function (node, parent) {
 nodes.ObjectTypeInternalSlot = function (node, parent) {
   var _parent$properties3, _parent$callPropertie2, _parent$indexers;
 
-  if (parent.internalSlots[0] === node && !((_parent$properties3 = parent.properties) != null && _parent$properties3.length) && !((_parent$callPropertie2 = parent.callProperties) != null && _parent$callPropertie2.length) && !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)) {
+  if (
+    parent.internalSlots[0] === node &&
+    !(
+      (_parent$properties3 = parent.properties) != null &&
+      _parent$properties3.length
+    ) &&
+    !(
+      (_parent$callPropertie2 = parent.callProperties) != null &&
+      _parent$callPropertie2.length
+    ) &&
+    !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)
+  ) {
     return {
-      before: true
+      before: true,
     };
   }
 };
 
 const list = {
   VariableDeclaration(node) {
-    return node.declarations.map(decl => decl.init);
+    return node.declarations.map((decl) => decl.init);
   },
 
   ArrayExpression(node) {
@@ -194,15 +233,21 @@ const list = {
 
   ObjectExpression(node) {
     return node.properties;
-  }
+  },
-
 };
 exports.list = list;
-[["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) {
+[
-  if (typeof amounts === "boolean") {
+  ['Function', true],
+  ['Class', true],
+  ['Loop', true],
+  ['LabeledStatement', true],
+  ['SwitchStatement', true],
+  ['TryStatement', true],
+].forEach(function ([type, amounts]) {
+  if (typeof amounts === 'boolean') {
     amounts = {
       after: amounts,
-      before: amounts
+      before: amounts,
     };
   }
 

node_modules/@babel/generator/lib/printer.js

@@ -1,32 +1,24 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = void 0;
 
-var _buffer = require("./buffer");
+var _buffer = require('./buffer');
 
-var n = require("./node");
+var n = require('./node');
 
-var _t = require("@babel/types");
+var _t = require('@babel/types');
 
-var generatorFunctions = require("./generators");
+var generatorFunctions = require('./generators');
 
-const {
+const { isProgram, isFile, isEmptyStatement } = _t;
-  isProgram,
-  isFile,
-  isEmptyStatement
-} = _t;
 const SCIENTIFIC_NOTATION = /e/i;
 const ZERO_DECIMAL_INTEGER = /\.0+$/;
 const NON_DECIMAL_LITERAL = /^0[box]/;
 const PURE_ANNOTATION_RE = /^\s*[@#]__PURE__\s*$/;
-const {
+const { needsParens, needsWhitespaceAfter, needsWhitespaceBefore } = n;
-  needsParens,
-  needsWhitespaceAfter,
-  needsWhitespaceBefore
-} = n;
 
 class Printer {
   constructor(format, map) {
@@ -65,7 +57,7 @@ class Printer {
   semicolon(force = false) {
     this._maybeAddAuxComment();
 
-    this._append(";", !force);
+    this._append(';', !force);
   }
 
   rightBrace() {
@@ -73,7 +65,7 @@ class Printer {
       this._buf.removeLastSemicolon();
     }
 
-    this.token("}");
+    this.token('}');
   }
 
   space(force = false) {
@@ -91,7 +83,7 @@ class Printer {
   }
 
   word(str) {
-    if (this._endsWithWord || this.endsWith(47) && str.charCodeAt(0) === 47) {
+    if (this._endsWithWord || (this.endsWith(47) && str.charCodeAt(0) === 47)) {
       this._space();
     }
 
@@ -104,14 +96,24 @@ class Printer {
 
   number(str) {
     this.word(str);
-    this._endsWithInteger = Number.isInteger(+str) && !NON_DECIMAL_LITERAL.test(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46;
+    this._endsWithInteger =
+      Number.isInteger(+str) &&
+      !NON_DECIMAL_LITERAL.test(str) &&
+      !SCIENTIFIC_NOTATION.test(str) &&
+      !ZERO_DECIMAL_INTEGER.test(str) &&
+      str.charCodeAt(str.length - 1) !== 46;
   }
 
   token(str) {
     const lastChar = this.getLastChar();
     const strFirst = str.charCodeAt(0);
 
-    if (str === "--" && lastChar === 33 || strFirst === 43 && lastChar === 43 || strFirst === 45 && lastChar === 45 || strFirst === 46 && this._endsWithInteger) {
+    if (
+      (str === '--' && lastChar === 33) ||
+      (strFirst === 43 && lastChar === 43) ||
+      (strFirst === 45 && lastChar === 45) ||
+      (strFirst === 46 && this._endsWithInteger)
+    ) {
       this._space();
     }
 
@@ -159,7 +161,7 @@ class Printer {
   }
 
   exactSource(loc, cb) {
-    this._catchUp("start", loc);
+    this._catchUp('start', loc);
 
     this._buf.exactSource(loc, cb);
   }
@@ -177,11 +179,11 @@ class Printer {
   }
 
   _space() {
-    this._append(" ", true);
+    this._append(' ', true);
   }
 
   _newline() {
-    this._append("\n", true);
+    this._append('\n', true);
   }
 
   _append(str, queue = false) {
@@ -189,7 +191,8 @@ class Printer {
 
     this._maybeIndent(str);
 
-    if (queue) this._buf.queue(str);else this._buf.append(str);
+    if (queue) this._buf.queue(str);
+    else this._buf.append(str);
     this._endsWithWord = false;
     this._endsWithInteger = false;
   }
@@ -205,7 +208,7 @@ class Printer {
     if (!parenPushNewlineState) return;
     let i;
 
-    for (i = 0; i < str.length && str[i] === " "; i++) continue;
+    for (i = 0; i < str.length && str[i] === ' '; i++) continue;
 
     if (i === str.length) {
       return;
@@ -213,25 +216,25 @@ class Printer {
 
     const cha = str[i];
 
-    if (cha !== "\n") {
+    if (cha !== '\n') {
-      if (cha !== "/" || i + 1 === str.length) {
+      if (cha !== '/' || i + 1 === str.length) {
         this._parenPushNewlineState = null;
         return;
       }
 
       const chaPost = str[i + 1];
 
-      if (chaPost === "*") {
+      if (chaPost === '*') {
         if (PURE_ANNOTATION_RE.test(str.slice(i + 2, str.length - 2))) {
           return;
         }
-      } else if (chaPost !== "/") {
+      } else if (chaPost !== '/') {
         this._parenPushNewlineState = null;
         return;
       }
     }
 
-    this.token("(");
+    this.token('(');
     this.indent();
     parenPushNewlineState.printed = true;
   }
@@ -258,9 +261,9 @@ class Printer {
       this._noLineTerminator = true;
       return null;
     } else {
-      return this._parenPushNewlineState = {
+      return (this._parenPushNewlineState = {
-        printed: false
+        printed: false,
-      };
+      });
     }
   }
 
@@ -270,7 +273,7 @@ class Printer {
     if (state != null && state.printed) {
       this.dedent();
       this.newline();
-      this.token(")");
+      this.token(')');
     }
   }
 
@@ -285,7 +288,9 @@ class Printer {
     const printMethod = this[node.type];
 
     if (!printMethod) {
-      throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node == null ? void 0 : node.constructor.name)}`);
+      throw new ReferenceError(
+        `unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node == null ? void 0 : node.constructor.name)}`
+      );
     }
 
     this._printStack.push(node);
@@ -297,22 +302,27 @@ class Printer {
 
     let shouldPrintParens = needsParens(node, parent, this._printStack);
 
-    if (this.format.retainFunctionParens && node.type === "FunctionExpression" && node.extra && node.extra.parenthesized) {
+    if (
+      this.format.retainFunctionParens &&
+      node.type === 'FunctionExpression' &&
+      node.extra &&
+      node.extra.parenthesized
+    ) {
       shouldPrintParens = true;
     }
 
-    if (shouldPrintParens) this.token("(");
+    if (shouldPrintParens) this.token('(');
 
     this._printLeadingComments(node);
 
     const loc = isProgram(node) || isFile(node) ? null : node.loc;
-    this.withSource("start", loc, () => {
+    this.withSource('start', loc, () => {
       printMethod.call(this, node, parent);
     });
 
     this._printTrailingComments(node);
 
-    if (shouldPrintParens) this.token(")");
+    if (shouldPrintParens) this.token(')');
 
     this._printStack.pop();
 
@@ -332,8 +342,8 @@ class Printer {
 
     if (comment) {
       this._printComment({
-        type: "CommentBlock",
+        type: 'CommentBlock',
-        value: comment
+        value: comment,
       });
     }
   }
@@ -345,8 +355,8 @@ class Printer {
 
     if (comment) {
       this._printComment({
-        type: "CommentBlock",
+        type: 'CommentBlock',
-        value: comment
+        value: comment,
       });
     }
   }
@@ -354,7 +364,12 @@ class Printer {
   getPossibleRaw(node) {
     const extra = node.extra;
 
-    if (extra && extra.raw != null && extra.rawValue != null && node.value === extra.rawValue) {
+    if (
+      extra &&
+      extra.raw != null &&
+      extra.rawValue != null &&
+      node.value === extra.rawValue
+    ) {
       return extra.raw;
     }
   }
@@ -363,7 +378,7 @@ class Printer {
     if (!(nodes != null && nodes.length)) return;
     if (opts.indent) this.indent();
     const newlineOpts = {
-      addNewlines: opts.addNewlines
+      addNewlines: opts.addNewlines,
     };
 
     for (let i = 0; i < nodes.length; i++) {
@@ -414,7 +429,13 @@ class Printer {
   printInnerComments(node, indent = true) {
     var _node$innerComments;
 
-    if (!((_node$innerComments = node.innerComments) != null && _node$innerComments.length)) return;
+    if (
+      !(
+        (_node$innerComments = node.innerComments) != null &&
+        _node$innerComments.length
+      )
+    )
+      return;
     if (indent) this.indent();
 
     this._printComments(node.innerComments);
@@ -456,7 +477,9 @@ class Printer {
   }
 
   _getComments(leading, node) {
-    return node && (leading ? node.leadingComments : node.trailingComments) || [];
+    return (
+      (node && (leading ? node.leadingComments : node.trailingComments)) || []
+    );
   }
 
   _printComment(comment, skipNewLines) {
@@ -466,8 +489,9 @@ class Printer {
 
     this._printedComments.add(comment);
 
-    const isBlockComment = comment.type === "CommentBlock";
+    const isBlockComment = comment.type === 'CommentBlock';
-    const printNewLines = isBlockComment && !skipNewLines && !this._noLineTerminator;
+    const printNewLines =
+      isBlockComment && !skipNewLines && !this._noLineTerminator;
     if (printNewLines && this._buf.hasContent()) this.newline(1);
     const lastCharCode = this.getLastChar();
 
@@ -475,24 +499,33 @@ class Printer {
       this.space();
     }
 
-    let val = !isBlockComment && !this._noLineTerminator ? `//${comment.value}\n` : `/*${comment.value}*/`;
+    let val =
+      !isBlockComment && !this._noLineTerminator ?
+        `//${comment.value}\n`
+      : `/*${comment.value}*/`;
 
     if (isBlockComment && this.format.indent.adjustMultilineComment) {
       var _comment$loc;
 
-      const offset = (_comment$loc = comment.loc) == null ? void 0 : _comment$loc.start.column;
+      const offset =
+        (_comment$loc = comment.loc) == null ?
+          void 0
+        : _comment$loc.start.column;
 
       if (offset) {
-        const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
+        const newlineRegex = new RegExp('\\n\\s{1,' + offset + '}', 'g');
-        val = val.replace(newlineRegex, "\n");
+        val = val.replace(newlineRegex, '\n');
       }
 
-      const indentSize = Math.max(this._getIndent().length, this.format.retainLines ? 0 : this._buf.getCurrentColumn());
+      const indentSize = Math.max(
-      val = val.replace(/\n(?!$)/g, `\n${" ".repeat(indentSize)}`);
+        this._getIndent().length,
+        this.format.retainLines ? 0 : this._buf.getCurrentColumn()
+      );
+      val = val.replace(/\n(?!$)/g, `\n${' '.repeat(indentSize)}`);
     }
 
     if (this.endsWith(47)) this._space();
-    this.withSource("start", comment.loc, () => {
+    this.withSource('start', comment.loc, () => {
       this._append(val);
     });
     if (printNewLines) this.newline(1);
@@ -501,8 +534,15 @@ class Printer {
   _printComments(comments, inlinePureAnnotation) {
     if (!(comments != null && comments.length)) return;
 
-    if (inlinePureAnnotation && comments.length === 1 && PURE_ANNOTATION_RE.test(comments[0].value)) {
+    if (
-      this._printComment(comments[0], this._buf.hasContent() && !this.endsWith(10));
+      inlinePureAnnotation &&
+      comments.length === 1 &&
+      PURE_ANNOTATION_RE.test(comments[0].value)
+    ) {
+      this._printComment(
+        comments[0],
+        this._buf.hasContent() && !this.endsWith(10)
+      );
     } else {
       for (const comment of comments) {
         this._printComment(comment);
@@ -513,18 +553,20 @@ class Printer {
   printAssertions(node) {
     var _node$assertions;
 
-    if ((_node$assertions = node.assertions) != null && _node$assertions.length) {
+    if (
+      (_node$assertions = node.assertions) != null &&
+      _node$assertions.length
+    ) {
       this.space();
-      this.word("assert");
+      this.word('assert');
       this.space();
-      this.token("{");
+      this.token('{');
       this.space();
       this.printList(node.assertions, node);
       this.space();
-      this.token("}");
+      this.token('}');
     }
   }
-
 }
 
 Object.assign(Printer.prototype, generatorFunctions);
@@ -535,6 +577,6 @@ var _default = Printer;
 exports.default = _default;
 
 function commaSeparator() {
-  this.token(",");
+  this.token(',');
   this.space();
 }

node_modules/@babel/generator/lib/source-map.js

@@ -1,11 +1,11 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = void 0;
 
-var _genMapping = require("@jridgewell/gen-mapping");
+var _genMapping = require('@jridgewell/gen-mapping');
 
 class SourceMap {
   constructor(opts, code) {
@@ -17,17 +17,24 @@ class SourceMap {
     this._lastGenLine = 0;
     this._lastSourceLine = 0;
     this._lastSourceColumn = 0;
-    const map = this._map = new _genMapping.GenMapping({
+    const map = (this._map = new _genMapping.GenMapping({
-      sourceRoot: opts.sourceRoot
+      sourceRoot: opts.sourceRoot,
-    });
+    }));
-    this._sourceFileName = (_opts$sourceFileName = opts.sourceFileName) == null ? void 0 : _opts$sourceFileName.replace(/\\/g, "/");
+    this._sourceFileName =
+      (_opts$sourceFileName = opts.sourceFileName) == null ?
+        void 0
+      : _opts$sourceFileName.replace(/\\/g, '/');
     this._rawMappings = undefined;
 
-    if (typeof code === "string") {
+    if (typeof code === 'string') {
       (0, _genMapping.setSourceContent)(map, this._sourceFileName, code);
-    } else if (typeof code === "object") {
+    } else if (typeof code === 'object') {
-      Object.keys(code).forEach(sourceFileName => {
+      Object.keys(code).forEach((sourceFileName) => {
-        (0, _genMapping.setSourceContent)(map, sourceFileName.replace(/\\/g, "/"), code[sourceFileName]);
+        (0, _genMapping.setSourceContent)(
+          map,
+          sourceFileName.replace(/\\/g, '/'),
+          code[sourceFileName]
+        );
       });
     }
   }
@@ -41,7 +48,10 @@ class SourceMap {
   }
 
   getRawMappings() {
-    return this._rawMappings || (this._rawMappings = (0, _genMapping.allMappings)(this._map));
+    return (
+      this._rawMappings ||
+      (this._rawMappings = (0, _genMapping.allMappings)(this._map))
+    );
   }
 
   mark(generated, line, column, identifierName, filename) {
@@ -49,14 +59,20 @@ class SourceMap {
     (0, _genMapping.maybeAddMapping)(this._map, {
       name: identifierName,
       generated,
-      source: line == null ? undefined : (filename == null ? void 0 : filename.replace(/\\/g, "/")) || this._sourceFileName,
+      source:
-      original: line == null ? undefined : {
+        line == null ? undefined : (
+          (filename == null ? void 0 : filename.replace(/\\/g, '/')) ||
+          this._sourceFileName
+        ),
+      original:
+        line == null ? undefined : (
+          {
             line: line,
-        column: column
+            column: column,
           }
+        ),
     });
   }
-
 }
 
 exports.default = SourceMap;

node_modules/@babel/helper-string-parser/lib/index.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.readCodePoint = readCodePoint;
 exports.readInt = readInt;
@@ -11,24 +11,23 @@ var _isDigit = function isDigit(code) {
 };
 const forbiddenNumericSeparatorSiblings = {
   decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
-  hex: new Set([46, 88, 95, 120])
+  hex: new Set([46, 88, 95, 120]),
 };
 const isAllowedNumericSeparatorSibling = {
-  bin: ch => ch === 48 || ch === 49,
+  bin: (ch) => ch === 48 || ch === 49,
-  oct: ch => ch >= 48 && ch <= 55,
+  oct: (ch) => ch >= 48 && ch <= 55,
-  dec: ch => ch >= 48 && ch <= 57,
+  dec: (ch) => ch >= 48 && ch <= 57,
-  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+  hex: (ch) =>
+    (ch >= 48 && ch <= 57) || (ch >= 65 && ch <= 70) || (ch >= 97 && ch <= 102),
 };
 function readStringContents(type, input, pos, lineStart, curLine, errors) {
   const initialPos = pos;
   const initialLineStart = lineStart;
   const initialCurLine = curLine;
-  let out = "";
+  let out = '';
   let firstInvalidLoc = null;
   let chunkStart = pos;
-  const {
+  const { length } = input;
-    length
-  } = input;
   for (;;) {
     if (pos >= length) {
       errors.unterminated(initialPos, initialLineStart, initialCurLine);
@@ -42,29 +41,32 @@ function readStringContents(type, input, pos, lineStart, curLine, errors) {
     }
     if (ch === 92) {
       out += input.slice(chunkStart, pos);
-      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
+      const res = readEscapedChar(
+        input,
+        pos,
+        lineStart,
+        curLine,
+        type === 'template',
+        errors
+      );
       if (res.ch === null && !firstInvalidLoc) {
         firstInvalidLoc = {
           pos,
           lineStart,
-          curLine
+          curLine,
         };
       } else {
         out += res.ch;
       }
-      ({
+      ({ pos, lineStart, curLine } = res);
-        pos,
-        lineStart,
-        curLine
-      } = res);
       chunkStart = pos;
     } else if (ch === 8232 || ch === 8233) {
       ++pos;
       ++curLine;
       lineStart = pos;
     } else if (ch === 10 || ch === 13) {
-      if (type === "template") {
+      if (type === 'template') {
-        out += input.slice(chunkStart, pos) + "\n";
+        out += input.slice(chunkStart, pos) + '\n';
         ++pos;
         if (ch === 13 && input.charCodeAt(pos) === 10) {
           ++pos;
@@ -84,56 +86,64 @@ function readStringContents(type, input, pos, lineStart, curLine, errors) {
     firstInvalidLoc,
     lineStart,
     curLine,
-    containsInvalid: !!firstInvalidLoc
+    containsInvalid: !!firstInvalidLoc,
   };
 }
 function isStringEnd(type, ch, input, pos) {
-  if (type === "template") {
+  if (type === 'template') {
-    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
+    return ch === 96 || (ch === 36 && input.charCodeAt(pos + 1) === 123);
   }
-  return ch === (type === "double" ? 34 : 39);
+  return ch === (type === 'double' ? 34 : 39);
 }
 function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
   const throwOnInvalid = !inTemplate;
   pos++;
-  const res = ch => ({
+  const res = (ch) => ({
     pos,
     ch,
     lineStart,
-    curLine
+    curLine,
   });
   const ch = input.charCodeAt(pos++);
   switch (ch) {
     case 110:
-      return res("\n");
+      return res('\n');
     case 114:
-      return res("\r");
+      return res('\r');
-    case 120:
+    case 120: {
-      {
       let code;
-        ({
+      ({ code, pos } = readHexChar(
-          code,
+        input,
-          pos
+        pos,
-        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+        lineStart,
+        curLine,
+        2,
+        false,
+        throwOnInvalid,
+        errors
+      ));
       return res(code === null ? null : String.fromCharCode(code));
     }
-    case 117:
+    case 117: {
-      {
       let code;
-        ({
+      ({ code, pos } = readCodePoint(
-          code,
+        input,
-          pos
+        pos,
-        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
+        lineStart,
+        curLine,
+        throwOnInvalid,
+        errors
+      ));
       return res(code === null ? null : String.fromCodePoint(code));
     }
     case 116:
-      return res("\t");
+      return res('\t');
     case 98:
-      return res("\b");
+      return res('\b');
     case 118:
-      return res("\u000b");
+      return res('\u000b');
     case 102:
-      return res("\f");
+      return res('\f');
     case 13:
       if (input.charCodeAt(pos) === 10) {
         ++pos;
@@ -143,7 +153,7 @@ function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
       ++curLine;
     case 8232:
     case 8233:
-      return res("");
+      return res('');
     case 56:
     case 57:
       if (inTemplate) {
@@ -163,7 +173,7 @@ function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
         }
         pos += octalStr.length - 1;
         const next = input.charCodeAt(pos);
-        if (octalStr !== "0" || next === 56 || next === 57) {
+        if (octalStr !== '0' || next === 56 || next === 57) {
           if (inTemplate) {
             return res(null);
           } else {
@@ -175,13 +185,30 @@ function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
       return res(String.fromCharCode(ch));
   }
 }
-function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+function readHexChar(
+  input,
+  pos,
+  lineStart,
+  curLine,
+  len,
+  forceLen,
+  throwOnInvalid,
+  errors
+) {
   const initialPos = pos;
   let n;
-  ({
+  ({ n, pos } = readInt(
-    n,
+    input,
-    pos
+    pos,
-  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+    lineStart,
+    curLine,
+    16,
+    len,
+    forceLen,
+    false,
+    errors,
+    !throwOnInvalid
+  ));
   if (n === null) {
     if (throwOnInvalid) {
       errors.invalidEscapeSequence(initialPos, lineStart, curLine);
@@ -191,31 +218,56 @@ function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInval
   }
   return {
     code: n,
-    pos
+    pos,
   };
 }
-function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+function readInt(
+  input,
+  pos,
+  lineStart,
+  curLine,
+  radix,
+  len,
+  forceLen,
+  allowNumSeparator,
+  errors,
+  bailOnError
+) {
   const start = pos;
-  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
+  const forbiddenSiblings =
-  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
+    radix === 16 ?
+      forbiddenNumericSeparatorSiblings.hex
+    : forbiddenNumericSeparatorSiblings.decBinOct;
+  const isAllowedSibling =
+    radix === 16 ? isAllowedNumericSeparatorSibling.hex
+    : radix === 10 ? isAllowedNumericSeparatorSibling.dec
+    : radix === 8 ? isAllowedNumericSeparatorSibling.oct
+    : isAllowedNumericSeparatorSibling.bin;
   let invalid = false;
   let total = 0;
   for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
     const code = input.charCodeAt(pos);
     let val;
-    if (code === 95 && allowNumSeparator !== "bail") {
+    if (code === 95 && allowNumSeparator !== 'bail') {
       const prev = input.charCodeAt(pos - 1);
       const next = input.charCodeAt(pos + 1);
       if (!allowNumSeparator) {
-        if (bailOnError) return {
+        if (bailOnError)
+          return {
             n: null,
-          pos
+            pos,
           };
         errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
-      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
+      } else if (
-        if (bailOnError) return {
+        Number.isNaN(next) ||
+        !isAllowedSibling(next) ||
+        forbiddenSiblings.has(prev) ||
+        forbiddenSiblings.has(next)
+      ) {
+        if (bailOnError)
+          return {
             n: null,
-          pos
+            pos,
           };
         errors.unexpectedNumericSeparator(pos, lineStart, curLine);
       }
@@ -235,9 +287,12 @@ function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumS
       if (val <= 9 && bailOnError) {
         return {
           n: null,
-          pos
+          pos,
         };
-      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
+      } else if (
+        val <= 9 &&
+        errors.invalidDigit(pos, lineStart, curLine, radix)
+      ) {
         val = 0;
       } else if (forceLen) {
         val = 0;
@@ -249,15 +304,15 @@ function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumS
     ++pos;
     total = total * radix + val;
   }
-  if (pos === start || len != null && pos - start !== len || invalid) {
+  if (pos === start || (len != null && pos - start !== len) || invalid) {
     return {
       n: null,
-      pos
+      pos,
     };
   }
   return {
     n: total,
-    pos
+    pos,
   };
 }
 function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
@@ -265,10 +320,16 @@ function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
   let code;
   if (ch === 123) {
     ++pos;
-    ({
+    ({ code, pos } = readHexChar(
-      code,
+      input,
-      pos
+      pos,
-    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+      lineStart,
+      curLine,
+      input.indexOf('}', pos) - pos,
+      true,
+      throwOnInvalid,
+      errors
+    ));
     ++pos;
     if (code !== null && code > 0x10ffff) {
       if (throwOnInvalid) {
@@ -276,19 +337,25 @@ function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
       } else {
         return {
           code: null,
-          pos
+          pos,
         };
       }
     }
   } else {
-    ({
+    ({ code, pos } = readHexChar(
-      code,
+      input,
-      pos
+      pos,
-    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+      lineStart,
+      curLine,
+      4,
+      false,
+      throwOnInvalid,
+      errors
+    ));
   }
   return {
     code,
-    pos
+    pos,
   };
 }
 

node_modules/@babel/helper-validator-identifier/lib/identifier.js

@@ -1,18 +1,69 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.isIdentifierChar = isIdentifierChar;
 exports.isIdentifierName = isIdentifierName;
 exports.isIdentifierStart = isIdentifierStart;
-let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7cd\ua7d0\ua7d1\ua7d3\ua7d5-\ua7dc\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierStartChars =
-let nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
+  '\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7cd\ua7d0\ua7d1\ua7d3\ua7d5-\ua7dc\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc';
-const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+let nonASCIIidentifierChars =
-const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+  '\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65';
+const nonASCIIidentifierStart = new RegExp(
+  '[' + nonASCIIidentifierStartChars + ']'
+);
+const nonASCIIidentifier = new RegExp(
+  '[' + nonASCIIidentifierStartChars + nonASCIIidentifierChars + ']'
+);
 nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
-const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 2, 60, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 42, 9, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 496, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191];
+const astralIdentifierStartCodes = [
-const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 80, 3, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 343, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 726, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+  0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48,
+  31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39,
+  9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310,
+  10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11,
+  22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2,
+  28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56,
+  50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 2, 60, 28, 11, 0, 9,
+  21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30,
+  0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6,
+  2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0,
+  19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21,
+  2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26,
+  38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7,
+  3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200,
+  32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2,
+  31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195,
+  2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18,
+  78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 129, 74, 6, 0, 67,
+  12, 65, 1, 2, 0, 29, 6135, 9, 1237, 42, 9, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0,
+  30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2,
+  1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3,
+  2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2,
+  24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322,
+  29, 19, 43, 485, 27, 229, 29, 3, 0, 496, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67,
+  8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2,
+  0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2,
+  6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7,
+  221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191,
+];
+const astralIdentifierCodes = [
+  509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574,
+  3, 9, 9, 7, 9, 32, 4, 318, 1, 80, 3, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3,
+  1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13,
+  9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2,
+  10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17,
+  10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9,
+  7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9,
+  120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 343, 9, 54, 7,
+  2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1,
+  2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465,
+  27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0,
+  12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3,
+  149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16,
+  3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2,
+  9, 726, 6, 110, 6, 6, 9, 4759, 9, 787719, 239,
+];
 function isInAstralSet(code, set) {
   let pos = 0x10000;
   for (let i = 0, length = set.length; i < length; i += 2) {
@@ -29,7 +80,9 @@ function isIdentifierStart(code) {
   if (code < 97) return code === 95;
   if (code <= 122) return true;
   if (code <= 0xffff) {
-    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+    return (
+      code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code))
+    );
   }
   return isInAstralSet(code, astralIdentifierStartCodes);
 }
@@ -43,7 +96,10 @@ function isIdentifierChar(code) {
   if (code <= 0xffff) {
     return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
   }
-  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+  return (
+    isInAstralSet(code, astralIdentifierStartCodes) ||
+    isInAstralSet(code, astralIdentifierCodes)
+  );
 }
 function isIdentifierName(name) {
   let isFirst = true;

node_modules/@babel/helper-validator-identifier/lib/index.js

@@ -1,57 +1,57 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
-Object.defineProperty(exports, "isIdentifierChar", {
+Object.defineProperty(exports, 'isIdentifierChar', {
   enumerable: true,
   get: function () {
     return _identifier.isIdentifierChar;
-  }
+  },
 });
-Object.defineProperty(exports, "isIdentifierName", {
+Object.defineProperty(exports, 'isIdentifierName', {
   enumerable: true,
   get: function () {
     return _identifier.isIdentifierName;
-  }
+  },
 });
-Object.defineProperty(exports, "isIdentifierStart", {
+Object.defineProperty(exports, 'isIdentifierStart', {
   enumerable: true,
   get: function () {
     return _identifier.isIdentifierStart;
-  }
+  },
 });
-Object.defineProperty(exports, "isKeyword", {
+Object.defineProperty(exports, 'isKeyword', {
   enumerable: true,
   get: function () {
     return _keyword.isKeyword;
-  }
+  },
 });
-Object.defineProperty(exports, "isReservedWord", {
+Object.defineProperty(exports, 'isReservedWord', {
   enumerable: true,
   get: function () {
     return _keyword.isReservedWord;
-  }
+  },
 });
-Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+Object.defineProperty(exports, 'isStrictBindOnlyReservedWord', {
   enumerable: true,
   get: function () {
     return _keyword.isStrictBindOnlyReservedWord;
-  }
+  },
 });
-Object.defineProperty(exports, "isStrictBindReservedWord", {
+Object.defineProperty(exports, 'isStrictBindReservedWord', {
   enumerable: true,
   get: function () {
     return _keyword.isStrictBindReservedWord;
-  }
+  },
 });
-Object.defineProperty(exports, "isStrictReservedWord", {
+Object.defineProperty(exports, 'isStrictReservedWord', {
   enumerable: true,
   get: function () {
     return _keyword.isStrictReservedWord;
-  }
+  },
 });
-var _identifier = require("./identifier.js");
+var _identifier = require('./identifier.js');
-var _keyword = require("./keyword.js");
+var _keyword = require('./keyword.js');
 
 //# sourceMappingURL=index.js.map

node_modules/@babel/helper-validator-identifier/lib/keyword.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.isKeyword = isKeyword;
 exports.isReservedWord = isReservedWord;
@@ -9,15 +9,61 @@ exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
 exports.isStrictBindReservedWord = isStrictBindReservedWord;
 exports.isStrictReservedWord = isStrictReservedWord;
 const reservedWords = {
-  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+  keyword: [
-  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+    'break',
-  strictBind: ["eval", "arguments"]
+    'case',
+    'catch',
+    'continue',
+    'debugger',
+    'default',
+    'do',
+    'else',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'return',
+    'switch',
+    'throw',
+    'try',
+    'var',
+    'const',
+    'while',
+    'with',
+    'new',
+    'this',
+    'super',
+    'class',
+    'extends',
+    'export',
+    'import',
+    'null',
+    'true',
+    'false',
+    'in',
+    'instanceof',
+    'typeof',
+    'void',
+    'delete',
+  ],
+  strict: [
+    'implements',
+    'interface',
+    'let',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'static',
+    'yield',
+  ],
+  strictBind: ['eval', 'arguments'],
 };
 const keywords = new Set(reservedWords.keyword);
 const reservedWordsStrictSet = new Set(reservedWords.strict);
 const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
 function isReservedWord(word, inModule) {
-  return inModule && word === "await" || word === "enum";
+  return (inModule && word === 'await') || word === 'enum';
 }
 function isStrictReservedWord(word, inModule) {
   return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
@@ -26,7 +72,9 @@ function isStrictBindOnlyReservedWord(word) {
   return reservedWordsStrictBindSet.has(word);
 }
 function isStrictBindReservedWord(word, inModule) {
-  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+  return (
+    isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word)
+  );
 }
 function isKeyword(word) {
   return keywords.has(word);

node_modules/@babel/parser/bin/babel-parser.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 /* eslint no-var: 0 */
 
-var parser = require("..");
+var parser = require('..');
-var fs = require("fs");
+var fs = require('fs');
 
 var filename = process.argv[2];
 if (!filename) {
-  console.error("no filename specified");
+  console.error('no filename specified');
 } else {
-  var file = fs.readFileSync(filename, "utf8");
+  var file = fs.readFileSync(filename, 'utf8');
   var ast = parser.parse(file);
 
-  console.log(JSON.stringify(ast, null, "  "));
+  console.log(JSON.stringify(ast, null, '  '));
 }

node_modules/@babel/parser/typings/babel-parser.d.ts

@@ -11,7 +11,7 @@
 export function parse(
   input: string,
   options?: ParserOptions
-): ParseResult<import("@babel/types").File>;
+): ParseResult<import('@babel/types').File>;
 
 /**
  * Parse the provided code as a single expression.
@@ -19,7 +19,7 @@ export function parse(
 export function parseExpression(
   input: string,
   options?: ParserOptions
-): ParseResult<import("@babel/types").Expression>;
+): ParseResult<import('@babel/types').Expression>;
 
 export interface ParserOptions {
   /**
@@ -73,7 +73,7 @@ export interface ParserOptions {
    * of ES6 import or export statements.
    * Files with ES6 imports and exports are considered "module" and are otherwise "script".
    */
-  sourceType?: "script" | "module" | "unambiguous";
+  sourceType?: 'script' | 'module' | 'unambiguous';
 
   /**
    * Correlate output AST nodes with their source filename.
@@ -126,67 +126,67 @@ export interface ParserOptions {
 }
 
 export type ParserPlugin =
-  | "asyncDoExpressions"
+  | 'asyncDoExpressions'
-  | "asyncGenerators"
+  | 'asyncGenerators'
-  | "bigInt"
+  | 'bigInt'
-  | "classPrivateMethods"
+  | 'classPrivateMethods'
-  | "classPrivateProperties"
+  | 'classPrivateProperties'
-  | "classProperties"
+  | 'classProperties'
-  | "classStaticBlock" // Enabled by default
+  | 'classStaticBlock' // Enabled by default
-  | "decimal"
+  | 'decimal'
-  | "decorators"
+  | 'decorators'
-  | "decorators-legacy"
+  | 'decorators-legacy'
-  | "decoratorAutoAccessors"
+  | 'decoratorAutoAccessors'
-  | "destructuringPrivate"
+  | 'destructuringPrivate'
-  | "doExpressions"
+  | 'doExpressions'
-  | "dynamicImport"
+  | 'dynamicImport'
-  | "estree"
+  | 'estree'
-  | "exportDefaultFrom"
+  | 'exportDefaultFrom'
-  | "exportNamespaceFrom" // deprecated
+  | 'exportNamespaceFrom' // deprecated
-  | "flow"
+  | 'flow'
-  | "flowComments"
+  | 'flowComments'
-  | "functionBind"
+  | 'functionBind'
-  | "functionSent"
+  | 'functionSent'
-  | "importMeta"
+  | 'importMeta'
-  | "jsx"
+  | 'jsx'
-  | "logicalAssignment"
+  | 'logicalAssignment'
-  | "importAssertions"
+  | 'importAssertions'
-  | "moduleBlocks"
+  | 'moduleBlocks'
-  | "moduleStringNames"
+  | 'moduleStringNames'
-  | "nullishCoalescingOperator"
+  | 'nullishCoalescingOperator'
-  | "numericSeparator"
+  | 'numericSeparator'
-  | "objectRestSpread"
+  | 'objectRestSpread'
-  | "optionalCatchBinding"
+  | 'optionalCatchBinding'
-  | "optionalChaining"
+  | 'optionalChaining'
-  | "partialApplication"
+  | 'partialApplication'
-  | "pipelineOperator"
+  | 'pipelineOperator'
-  | "placeholders"
+  | 'placeholders'
-  | "privateIn" // Enabled by default
+  | 'privateIn' // Enabled by default
-  | "regexpUnicodeSets"
+  | 'regexpUnicodeSets'
-  | "throwExpressions"
+  | 'throwExpressions'
-  | "topLevelAwait"
+  | 'topLevelAwait'
-  | "typescript"
+  | 'typescript'
-  | "v8intrinsic"
+  | 'v8intrinsic'
   | ParserPluginWithOptions;
 
 export type ParserPluginWithOptions =
-  | ["decorators", DecoratorsPluginOptions]
+  | ['decorators', DecoratorsPluginOptions]
-  | ["pipelineOperator", PipelineOperatorPluginOptions]
+  | ['pipelineOperator', PipelineOperatorPluginOptions]
-  | ["recordAndTuple", RecordAndTuplePluginOptions]
+  | ['recordAndTuple', RecordAndTuplePluginOptions]
-  | ["flow", FlowPluginOptions]
+  | ['flow', FlowPluginOptions]
-  | ["typescript", TypeScriptPluginOptions];
+  | ['typescript', TypeScriptPluginOptions];
 
 export interface DecoratorsPluginOptions {
   decoratorsBeforeExport?: boolean;
 }
 
 export interface PipelineOperatorPluginOptions {
-  proposal: "minimal" | "fsharp" | "hack" | "smart";
+  proposal: 'minimal' | 'fsharp' | 'hack' | 'smart';
-  topicToken?: "%" | "#" | "@@" | "^^" | "^";
+  topicToken?: '%' | '#' | '@@' | '^^' | '^';
 }
 
 export interface RecordAndTuplePluginOptions {
-  syntaxType: "bar" | "hash";
+  syntaxType: 'bar' | 'hash';
 }
 
 export interface FlowPluginOptions {

node_modules/@babel/types/lib/asserts/assertNode.js

@@ -1,17 +1,20 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = assertNode;
 
-var _isNode = require("../validators/isNode");
+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);
+    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}"`);
   }
 }

node_modules/@babel/types/lib/ast-types/generated/index.js

@@ -1,3 +1 @@
-
-
 //# sourceMappingURL=index.js.map

node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js

@@ -1,13 +1,13 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = createFlowUnionType;
 
-var _generated = require("../generated");
+var _generated = require('../generated');
 
-var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates");
+var _removeTypeDuplicates = require('../../modifications/flow/removeTypeDuplicates');
 
 function createFlowUnionType(types) {
   const flattened = (0, _removeTypeDuplicates.default)(types);

node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js

@@ -1,43 +1,49 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = void 0;
 
-var _generated = require("../generated");
+var _generated = require('../generated');
 
 var _default = createTypeAnnotationBasedOnTypeof;
 exports.default = _default;
 
 function createTypeAnnotationBasedOnTypeof(type) {
   switch (type) {
-    case "string":
+    case 'string':
       return (0, _generated.stringTypeAnnotation)();
 
-    case "number":
+    case 'number':
       return (0, _generated.numberTypeAnnotation)();
 
-    case "undefined":
+    case 'undefined':
       return (0, _generated.voidTypeAnnotation)();
 
-    case "boolean":
+    case 'boolean':
       return (0, _generated.booleanTypeAnnotation)();
 
-    case "function":
+    case 'function':
-      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function"));
+      return (0, _generated.genericTypeAnnotation)(
+        (0, _generated.identifier)('Function')
+      );
 
-    case "object":
+    case 'object':
-      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
+      return (0, _generated.genericTypeAnnotation)(
+        (0, _generated.identifier)('Object')
+      );
 
-    case "symbol":
+    case 'symbol':
-      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
+      return (0, _generated.genericTypeAnnotation)(
+        (0, _generated.identifier)('Symbol')
+      );
 
-    case "bigint":
+    case 'bigint':
       return (0, _generated.anyTypeAnnotation)();
   }
 
-  throw new Error("Invalid typeof value: " + type);
+  throw new Error('Invalid typeof value: ' + type);
 }
 
 //# sourceMappingURL=createTypeAnnotationBasedOnTypeof.js.map

node_modules/@babel/types/lib/builders/react/buildChildren.js

@@ -1,13 +1,13 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = buildChildren;
 
-var _generated = require("../../validators/generated");
+var _generated = require('../../validators/generated');
 
-var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild");
+var _cleanJSXElementLiteralChild = require('../../utils/react/cleanJSXElementLiteralChild');
 
 function buildChildren(node) {
   const elements = [];
@@ -20,7 +20,8 @@ function buildChildren(node) {
       continue;
     }
 
-    if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
+    if ((0, _generated.isJSXExpressionContainer)(child))
+      child = child.expression;
     if ((0, _generated.isJSXEmptyExpression)(child)) continue;
     elements.push(child);
   }

node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js

@@ -1,18 +1,18 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = createTSUnionType;
 
-var _generated = require("../generated");
+var _generated = require('../generated');
 
-var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates");
+var _removeTypeDuplicates = require('../../modifications/typescript/removeTypeDuplicates');
 
-var _index = require("../../validators/generated/index");
+var _index = require('../../validators/generated/index');
 
 function createTSUnionType(typeAnnotations) {
-  const types = typeAnnotations.map(type => {
+  const types = typeAnnotations.map((type) => {
     return (0, _index.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;
   });
   const flattened = (0, _removeTypeDuplicates.default)(types);

node_modules/@babel/types/lib/builders/validateNode.js

@@ -1,13 +1,13 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = validateNode;
 
-var _validate = require("../validators/validate");
+var _validate = require('../validators/validate');
 
-var _ = require("..");
+var _ = require('..');
 
 function validateNode(node) {
   const keys = _.BUILDER_KEYS[node.type];

node_modules/@babel/types/lib/clone/clone.js

@@ -1,11 +1,11 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = clone;
 
-var _cloneNode = require("./cloneNode");
+var _cloneNode = require('./cloneNode');
 
 function clone(node) {
   return (0, _cloneNode.default)(node, false);

node_modules/@babel/types/lib/clone/cloneDeep.js

@@ -1,11 +1,11 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = cloneDeep;
 
-var _cloneNode = require("./cloneNode");
+var _cloneNode = require('./cloneNode');
 
 function cloneDeep(node) {
   return (0, _cloneNode.default)(node);

node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js

@@ -1,11 +1,11 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = cloneDeepWithoutLoc;
 
-var _cloneNode = require("./cloneNode");
+var _cloneNode = require('./cloneNode');
 
 function cloneDeepWithoutLoc(node) {
   return (0, _cloneNode.default)(node, true, true);

node_modules/@babel/types/lib/clone/cloneNode.js

@@ -1,18 +1,18 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = cloneNode;
 
-var _definitions = require("../definitions");
+var _definitions = require('../definitions');
 
-var _generated = require("../validators/generated");
+var _generated = require('../validators/generated');
 
 const has = Function.call.bind(Object.prototype.hasOwnProperty);
 
 function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
-  if (obj && typeof obj.type === "string") {
+  if (obj && typeof obj.type === 'string') {
     return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);
   }
 
@@ -21,7 +21,9 @@ function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
 
 function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {
   if (Array.isArray(obj)) {
-    return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache));
+    return obj.map((node) =>
+      cloneIfNode(node, deep, withoutLoc, commentsCache)
+    );
   }
 
   return cloneIfNode(obj, deep, withoutLoc, commentsCache);
@@ -31,24 +33,35 @@ function cloneNode(node, deep = true, withoutLoc = false) {
   return cloneNodeInternal(node, deep, withoutLoc, new Map());
 }
 
-function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) {
+function cloneNodeInternal(
+  node,
+  deep = true,
+  withoutLoc = false,
+  commentsCache
+) {
   if (!node) return node;
-  const {
+  const { type } = node;
-    type
-  } = node;
   const newNode = {
-    type: node.type
+    type: node.type,
   };
 
   if ((0, _generated.isIdentifier)(node)) {
     newNode.name = node.name;
 
-    if (has(node, "optional") && typeof node.optional === "boolean") {
+    if (has(node, 'optional') && typeof node.optional === 'boolean') {
       newNode.optional = node.optional;
     }
 
-    if (has(node, "typeAnnotation")) {
+    if (has(node, 'typeAnnotation')) {
-      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation;
+      newNode.typeAnnotation =
+        deep ?
+          cloneIfNodeOrArray(
+            node.typeAnnotation,
+            true,
+            withoutLoc,
+            commentsCache
+          )
+        : node.typeAnnotation;
     }
   } else if (!has(_definitions.NODE_FIELDS, type)) {
     throw new Error(`Unknown node type: "${type}"`);
@@ -56,7 +69,10 @@ function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache)
     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, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);
+          newNode[field] =
+            (0, _generated.isFile)(node) && field === 'comments' ?
+              maybeCloneComments(node.comments, deep, withoutLoc, commentsCache)
+            : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);
         } else {
           newNode[field] = node[field];
         }
@@ -64,7 +80,7 @@ function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache)
     }
   }
 
-  if (has(node, "loc")) {
+  if (has(node, 'loc')) {
     if (withoutLoc) {
       newNode.loc = null;
     } else {
@@ -72,19 +88,34 @@ function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache)
     }
   }
 
-  if (has(node, "leadingComments")) {
+  if (has(node, 'leadingComments')) {
-    newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache);
+    newNode.leadingComments = maybeCloneComments(
+      node.leadingComments,
+      deep,
+      withoutLoc,
+      commentsCache
+    );
   }
 
-  if (has(node, "innerComments")) {
+  if (has(node, 'innerComments')) {
-    newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache);
+    newNode.innerComments = maybeCloneComments(
+      node.innerComments,
+      deep,
+      withoutLoc,
+      commentsCache
+    );
   }
 
-  if (has(node, "trailingComments")) {
+  if (has(node, 'trailingComments')) {
-    newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache);
+    newNode.trailingComments = maybeCloneComments(
+      node.trailingComments,
+      deep,
+      withoutLoc,
+      commentsCache
+    );
   }
 
-  if (has(node, "extra")) {
+  if (has(node, 'extra')) {
     newNode.extra = Object.assign({}, node.extra);
   }
 
@@ -96,18 +127,14 @@ function maybeCloneComments(comments, deep, withoutLoc, commentsCache) {
     return comments;
   }
 
-  return comments.map(comment => {
+  return comments.map((comment) => {
     const cache = commentsCache.get(comment);
     if (cache) return cache;
-    const {
+    const { type, value, loc } = comment;
-      type,
-      value,
-      loc
-    } = comment;
     const ret = {
       type,
       value,
-      loc
+      loc,
     };
 
     if (withoutLoc) {

node_modules/@babel/types/lib/clone/cloneWithoutLoc.js

@@ -1,11 +1,11 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = cloneWithoutLoc;
 
-var _cloneNode = require("./cloneNode");
+var _cloneNode = require('./cloneNode');
 
 function cloneWithoutLoc(node) {
   return (0, _cloneNode.default)(node, false, true);

node_modules/@babel/types/lib/comments/addComment.js

@@ -1,17 +1,19 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = addComment;
 
-var _addComments = require("./addComments");
+var _addComments = require('./addComments');
 
 function addComment(node, type, content, line) {
-  return (0, _addComments.default)(node, type, [{
+  return (0, _addComments.default)(node, type, [
-    type: line ? "CommentLine" : "CommentBlock",
+    {
-    value: content
+      type: line ? 'CommentLine' : 'CommentBlock',
-  }]);
+      value: content,
+    },
+  ]);
 }
 
 //# sourceMappingURL=addComment.js.map

node_modules/@babel/types/lib/comments/addComments.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = addComments;
 
@@ -10,7 +10,7 @@ function addComments(node, type, comments) {
   const key = `${type}Comments`;
 
   if (node[key]) {
-    if (type === "leading") {
+    if (type === 'leading') {
       node[key] = comments.concat(node[key]);
     } else {
       node[key].push(...comments);

node_modules/@babel/types/lib/comments/inheritInnerComments.js

@@ -1,14 +1,14 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = inheritInnerComments;
 
-var _inherit = require("../utils/inherit");
+var _inherit = require('../utils/inherit');
 
 function inheritInnerComments(child, parent) {
-  (0, _inherit.default)("innerComments", child, parent);
+  (0, _inherit.default)('innerComments', child, parent);
 }
 
 //# sourceMappingURL=inheritInnerComments.js.map

node_modules/@babel/types/lib/comments/inheritLeadingComments.js

@@ -1,14 +1,14 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = inheritLeadingComments;
 
-var _inherit = require("../utils/inherit");
+var _inherit = require('../utils/inherit');
 
 function inheritLeadingComments(child, parent) {
-  (0, _inherit.default)("leadingComments", child, parent);
+  (0, _inherit.default)('leadingComments', child, parent);
 }
 
 //# sourceMappingURL=inheritLeadingComments.js.map

node_modules/@babel/types/lib/comments/inheritTrailingComments.js

@@ -1,14 +1,14 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = inheritTrailingComments;
 
-var _inherit = require("../utils/inherit");
+var _inherit = require('../utils/inherit');
 
 function inheritTrailingComments(child, parent) {
-  (0, _inherit.default)("trailingComments", child, parent);
+  (0, _inherit.default)('trailingComments', child, parent);
 }
 
 //# sourceMappingURL=inheritTrailingComments.js.map

node_modules/@babel/types/lib/comments/inheritsComments.js

@@ -1,15 +1,15 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = inheritsComments;
 
-var _inheritTrailingComments = require("./inheritTrailingComments");
+var _inheritTrailingComments = require('./inheritTrailingComments');
 
-var _inheritLeadingComments = require("./inheritLeadingComments");
+var _inheritLeadingComments = require('./inheritLeadingComments');
 
-var _inheritInnerComments = require("./inheritInnerComments");
+var _inheritInnerComments = require('./inheritInnerComments');
 
 function inheritsComments(child, parent) {
   (0, _inheritTrailingComments.default)(child, parent);

node_modules/@babel/types/lib/comments/removeComments.js

@@ -1,14 +1,14 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = removeComments;
 
-var _constants = require("../constants");
+var _constants = require('../constants');
 
 function removeComments(node) {
-  _constants.COMMENT_KEYS.forEach(key => {
+  _constants.COMMENT_KEYS.forEach((key) => {
     node[key] = null;
   });
 

node_modules/@babel/types/lib/constants/generated/index.js

@@ -1,109 +1,166 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  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;
+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");
+var _definitions = require('../../definitions');
 
-const STANDARDIZED_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Standardized"];
+const STANDARDIZED_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Standardized'];
 exports.STANDARDIZED_TYPES = STANDARDIZED_TYPES;
-const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"];
+const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Expression'];
 exports.EXPRESSION_TYPES = EXPRESSION_TYPES;
-const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"];
+const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Binary'];
 exports.BINARY_TYPES = BINARY_TYPES;
-const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"];
+const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Scopable'];
 exports.SCOPABLE_TYPES = SCOPABLE_TYPES;
-const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"];
+const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS['BlockParent'];
 exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES;
-const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"];
+const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Block'];
 exports.BLOCK_TYPES = BLOCK_TYPES;
-const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"];
+const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Statement'];
 exports.STATEMENT_TYPES = STATEMENT_TYPES;
-const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"];
+const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Terminatorless'];
 exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES;
-const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"];
+const COMPLETIONSTATEMENT_TYPES =
+  _definitions.FLIPPED_ALIAS_KEYS['CompletionStatement'];
 exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES;
-const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"];
+const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Conditional'];
 exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES;
-const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"];
+const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Loop'];
 exports.LOOP_TYPES = LOOP_TYPES;
-const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"];
+const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['While'];
 exports.WHILE_TYPES = WHILE_TYPES;
-const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
+const EXPRESSIONWRAPPER_TYPES =
+  _definitions.FLIPPED_ALIAS_KEYS['ExpressionWrapper'];
 exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES;
-const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"];
+const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS['For'];
 exports.FOR_TYPES = FOR_TYPES;
-const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"];
+const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS['ForXStatement'];
 exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES;
-const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"];
+const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Function'];
 exports.FUNCTION_TYPES = FUNCTION_TYPES;
-const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"];
+const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS['FunctionParent'];
 exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES;
-const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"];
+const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Pureish'];
 exports.PUREISH_TYPES = PUREISH_TYPES;
-const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"];
+const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Declaration'];
 exports.DECLARATION_TYPES = DECLARATION_TYPES;
-const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"];
+const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['PatternLike'];
 exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES;
-const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"];
+const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS['LVal'];
 exports.LVAL_TYPES = LVAL_TYPES;
-const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"];
+const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS['TSEntityName'];
 exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES;
-const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"];
+const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Literal'];
 exports.LITERAL_TYPES = LITERAL_TYPES;
-const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"];
+const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Immutable'];
 exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES;
-const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
+const USERWHITESPACABLE_TYPES =
+  _definitions.FLIPPED_ALIAS_KEYS['UserWhitespacable'];
 exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES;
-const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"];
+const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Method'];
 exports.METHOD_TYPES = METHOD_TYPES;
-const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"];
+const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS['ObjectMember'];
 exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES;
-const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"];
+const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Property'];
 exports.PROPERTY_TYPES = PROPERTY_TYPES;
-const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"];
+const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['UnaryLike'];
 exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES;
-const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"];
+const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Pattern'];
 exports.PATTERN_TYPES = PATTERN_TYPES;
-const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"];
+const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Class'];
 exports.CLASS_TYPES = CLASS_TYPES;
-const MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"];
+const MODULEDECLARATION_TYPES =
+  _definitions.FLIPPED_ALIAS_KEYS['ModuleDeclaration'];
 exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES;
-const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
+const EXPORTDECLARATION_TYPES =
+  _definitions.FLIPPED_ALIAS_KEYS['ExportDeclaration'];
 exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES;
-const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
+const MODULESPECIFIER_TYPES =
+  _definitions.FLIPPED_ALIAS_KEYS['ModuleSpecifier'];
 exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES;
-const ACCESSOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Accessor"];
+const ACCESSOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Accessor'];
 exports.ACCESSOR_TYPES = ACCESSOR_TYPES;
-const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"];
+const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Private'];
 exports.PRIVATE_TYPES = PRIVATE_TYPES;
-const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"];
+const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Flow'];
 exports.FLOW_TYPES = FLOW_TYPES;
-const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
+const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['FlowType'];
 exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
-const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
+const FLOWBASEANNOTATION_TYPES =
+  _definitions.FLIPPED_ALIAS_KEYS['FlowBaseAnnotation'];
 exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;
-const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
+const FLOWDECLARATION_TYPES =
+  _definitions.FLIPPED_ALIAS_KEYS['FlowDeclaration'];
 exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES;
-const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"];
+const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['FlowPredicate'];
 exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES;
-const ENUMBODY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumBody"];
+const ENUMBODY_TYPES = _definitions.FLIPPED_ALIAS_KEYS['EnumBody'];
 exports.ENUMBODY_TYPES = ENUMBODY_TYPES;
-const ENUMMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumMember"];
+const ENUMMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS['EnumMember'];
 exports.ENUMMEMBER_TYPES = ENUMMEMBER_TYPES;
-const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"];
+const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS['JSX'];
 exports.JSX_TYPES = JSX_TYPES;
-const MISCELLANEOUS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Miscellaneous"];
+const MISCELLANEOUS_TYPES = _definitions.FLIPPED_ALIAS_KEYS['Miscellaneous'];
 exports.MISCELLANEOUS_TYPES = MISCELLANEOUS_TYPES;
-const TYPESCRIPT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TypeScript"];
+const TYPESCRIPT_TYPES = _definitions.FLIPPED_ALIAS_KEYS['TypeScript'];
 exports.TYPESCRIPT_TYPES = TYPESCRIPT_TYPES;
-const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"];
+const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS['TSTypeElement'];
 exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES;
-const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"];
+const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['TSType'];
 exports.TSTYPE_TYPES = TSTYPE_TYPES;
-const TSBASETYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSBaseType"];
+const TSBASETYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS['TSBaseType'];
 exports.TSBASETYPE_TYPES = TSBASETYPE_TYPES;
 
 //# sourceMappingURL=index.js.map

node_modules/@babel/types/lib/constants/index.js

@@ -1,51 +1,108 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  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;
+exports.UPDATE_OPERATORS =
-const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
+  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"];
+const FLATTENABLE_KEYS = ['body', 'expressions'];
 exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS;
-const FOR_INIT_KEYS = ["left", "init"];
+const FOR_INIT_KEYS = ['left', 'init'];
 exports.FOR_INIT_KEYS = FOR_INIT_KEYS;
-const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
+const COMMENT_KEYS = ['leadingComments', 'trailingComments', 'innerComments'];
 exports.COMMENT_KEYS = COMMENT_KEYS;
-const LOGICAL_OPERATORS = ["||", "&&", "??"];
+const LOGICAL_OPERATORS = ['||', '&&', '??'];
 exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS;
-const UPDATE_OPERATORS = ["++", "--"];
+const UPDATE_OPERATORS = ['++', '--'];
 exports.UPDATE_OPERATORS = UPDATE_OPERATORS;
-const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
+const BOOLEAN_NUMBER_BINARY_OPERATORS = ['>', '<', '>=', '<='];
 exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS;
-const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
+const EQUALITY_BINARY_OPERATORS = ['==', '===', '!=', '!=='];
 exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS;
-const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
+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];
+const BOOLEAN_BINARY_OPERATORS = [
+  ...COMPARISON_BINARY_OPERATORS,
+  ...BOOLEAN_NUMBER_BINARY_OPERATORS,
+];
 exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS;
-const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+const NUMBER_BINARY_OPERATORS = [
+  '-',
+  '/',
+  '%',
+  '*',
+  '**',
+  '&',
+  '|',
+  '>>',
+  '>>>',
+  '<<',
+  '^',
+];
 exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
-const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_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 + "=")];
+const ASSIGNMENT_OPERATORS = [
+  '=',
+  '+=',
+  ...NUMBER_BINARY_OPERATORS.map((op) => op + '='),
+  ...LOGICAL_OPERATORS.map((op) => op + '='),
+];
 exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS;
-const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
+const BOOLEAN_UNARY_OPERATORS = ['delete', '!'];
 exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
-const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
+const NUMBER_UNARY_OPERATORS = ['+', '-', '~'];
 exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS;
-const STRING_UNARY_OPERATORS = ["typeof"];
+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];
+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"],
+  optional: ['typeAnnotation', 'typeParameters', 'returnType'],
-  force: ["start", "loc", "end"]
+  force: ['start', 'loc', 'end'],
 };
 exports.INHERIT_KEYS = INHERIT_KEYS;
-const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
+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");
+const NOT_LOCAL_BINDING = Symbol.for(
+  'should not be considered a local binding'
+);
 exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING;
 
 //# sourceMappingURL=index.js.map

node_modules/@babel/types/lib/converters/ensureBlock.js

@@ -1,13 +1,13 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = ensureBlock;
 
-var _toBlock = require("./toBlock");
+var _toBlock = require('./toBlock');
 
-function ensureBlock(node, key = "body") {
+function ensureBlock(node, key = 'body') {
   const result = (0, _toBlock.default)(node[key], node);
   node[key] = result;
   return result;

node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js

@@ -1,17 +1,17 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = gatherSequenceExpressions;
 
-var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers");
+var _getBindingIdentifiers = require('../retrievers/getBindingIdentifiers');
 
-var _generated = require("../validators/generated");
+var _generated = require('../validators/generated');
 
-var _generated2 = require("../builders/generated");
+var _generated2 = require('../builders/generated');
 
-var _cloneNode = require("../clone/cloneNode");
+var _cloneNode = require('../clone/cloneNode');
 
 function gatherSequenceExpressions(nodes, scope, declars) {
   const exprs = [];
@@ -27,7 +27,7 @@ function gatherSequenceExpressions(nodes, scope, declars) {
     } else if ((0, _generated.isExpressionStatement)(node)) {
       exprs.push(node.expression);
     } else if ((0, _generated.isVariableDeclaration)(node)) {
-      if (node.kind !== "var") return;
+      if (node.kind !== 'var') return;
 
       for (const declar of node.declarations) {
         const bindings = (0, _getBindingIdentifiers.default)(declar);
@@ -35,21 +35,31 @@ function gatherSequenceExpressions(nodes, scope, declars) {
         for (const key of Object.keys(bindings)) {
           declars.push({
             kind: node.kind,
-            id: (0, _cloneNode.default)(bindings[key])
+            id: (0, _cloneNode.default)(bindings[key]),
           });
         }
 
         if (declar.init) {
-          exprs.push((0, _generated2.assignmentExpression)("=", declar.id, 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 consequent =
-      const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
+        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));
+      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;

node_modules/@babel/types/lib/converters/toBindingIdentifierName.js

@@ -1,15 +1,15 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = toBindingIdentifierName;
 
-var _toIdentifier = require("./toIdentifier");
+var _toIdentifier = require('./toIdentifier');
 
 function toBindingIdentifierName(name) {
   name = (0, _toIdentifier.default)(name);
-  if (name === "eval" || name === "arguments") name = "_" + name;
+  if (name === 'eval' || name === 'arguments') name = '_' + name;
   return name;
 }
 

node_modules/@babel/types/lib/converters/toBlock.js

@@ -1,13 +1,13 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = toBlock;
 
-var _generated = require("../validators/generated");
+var _generated = require('../validators/generated');
 
-var _generated2 = require("../builders/generated");
+var _generated2 = require('../builders/generated');
 
 function toBlock(node, parent) {
   if ((0, _generated.isBlockStatement)(node)) {

node_modules/@babel/types/lib/converters/toComputedKey.js

@@ -1,16 +1,17 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = toComputedKey;
 
-var _generated = require("../validators/generated");
+var _generated = require('../validators/generated');
 
-var _generated2 = require("../builders/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);
+  if (!node.computed && (0, _generated.isIdentifier)(key))
+    key = (0, _generated2.stringLiteral)(key.name);
   return key;
 }
 

node_modules/@babel/types/lib/converters/toExpression.js

@@ -1,11 +1,11 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = void 0;
 
-var _generated = require("../validators/generated");
+var _generated = require('../validators/generated');
 
 var _default = toExpression;
 exports.default = _default;
@@ -20,9 +20,9 @@ function toExpression(node) {
   }
 
   if ((0, _generated.isClass)(node)) {
-    node.type = "ClassExpression";
+    node.type = 'ClassExpression';
   } else if ((0, _generated.isFunction)(node)) {
-    node.type = "FunctionExpression";
+    node.type = 'FunctionExpression';
   }
 
   if (!(0, _generated.isExpression)(node)) {

node_modules/@babel/types/lib/converters/toIdentifier.js

@@ -1,32 +1,35 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = toIdentifier;
 
-var _isValidIdentifier = require("../validators/isValidIdentifier");
+var _isValidIdentifier = require('../validators/isValidIdentifier');
 
-var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+var _helperValidatorIdentifier = require('@babel/helper-validator-identifier');
 
 function toIdentifier(input) {
-  input = input + "";
+  input = input + '';
-  let name = "";
+  let name = '';
 
   for (const c of input) {
-    name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-";
+    name +=
+      (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : (
+        '-'
+      );
   }
 
-  name = name.replace(/^[-0-9]+/, "");
+  name = name.replace(/^[-0-9]+/, '');
   name = name.replace(/[-\s]+(.)?/g, function (match, c) {
-    return c ? c.toUpperCase() : "";
+    return c ? c.toUpperCase() : '';
   });
 
   if (!(0, _isValidIdentifier.default)(name)) {
     name = `_${name}`;
   }
 
-  return name || "_";
+  return name || '_';
 }
 
 //# sourceMappingURL=toIdentifier.js.map

node_modules/@babel/types/lib/converters/toKeyAlias.js

@@ -1,27 +1,29 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = toKeyAlias;
 
-var _generated = require("../validators/generated");
+var _generated = require('../validators/generated');
 
-var _cloneNode = require("../clone/cloneNode");
+var _cloneNode = require('../clone/cloneNode');
 
-var _removePropertiesDeep = require("../modifications/removePropertiesDeep");
+var _removePropertiesDeep = require('../modifications/removePropertiesDeep');
 
 function toKeyAlias(node, key = node.key) {
   let alias;
 
-  if (node.kind === "method") {
+  if (node.kind === 'method') {
-    return toKeyAlias.increment() + "";
+    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)));
+    alias = JSON.stringify(
+      (0, _removePropertiesDeep.default)((0, _cloneNode.default)(key))
+    );
   }
 
   if (node.computed) {
@@ -39,7 +41,7 @@ toKeyAlias.uid = 0;
 
 toKeyAlias.increment = function () {
   if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {
-    return toKeyAlias.uid = 0;
+    return (toKeyAlias.uid = 0);
   } else {
     return toKeyAlias.uid++;
   }

node_modules/@babel/types/lib/converters/toSequenceExpression.js

@@ -1,11 +1,11 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = toSequenceExpression;
 
-var _gatherSequenceExpressions = require("./gatherSequenceExpressions");
+var _gatherSequenceExpressions = require('./gatherSequenceExpressions');
 
 function toSequenceExpression(nodes, scope) {
   if (!(nodes != null && nodes.length)) return;

node_modules/@babel/types/lib/converters/toStatement.js

@@ -1,13 +1,13 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = void 0;
 
-var _generated = require("../validators/generated");
+var _generated = require('../validators/generated');
 
-var _generated2 = require("../builders/generated");
+var _generated2 = require('../builders/generated');
 
 var _default = toStatement;
 exports.default = _default;
@@ -22,10 +22,10 @@ function toStatement(node, ignore) {
 
   if ((0, _generated.isClass)(node)) {
     mustHaveId = true;
-    newType = "ClassDeclaration";
+    newType = 'ClassDeclaration';
   } else if ((0, _generated.isFunction)(node)) {
     mustHaveId = true;
-    newType = "FunctionDeclaration";
+    newType = 'FunctionDeclaration';
   } else if ((0, _generated.isAssignmentExpression)(node)) {
     return (0, _generated2.expressionStatement)(node);
   }

node_modules/@babel/types/lib/converters/valueToNode.js

@@ -1,24 +1,28 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = void 0;
 
-var _isValidIdentifier = require("../validators/isValidIdentifier");
+var _isValidIdentifier = require('../validators/isValidIdentifier');
 
-var _generated = require("../builders/generated");
+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]";
+  return objectToString(value) === '[object RegExp]';
 }
 
 function isPlainObject(value) {
-  if (typeof value !== "object" || value === null || Object.prototype.toString.call(value) !== "[object Object]") {
+  if (
+    typeof value !== 'object' ||
+    value === null ||
+    Object.prototype.toString.call(value) !== '[object Object]'
+  ) {
     return false;
   }
 
@@ -28,7 +32,7 @@ function isPlainObject(value) {
 
 function valueToNode(value) {
   if (value === undefined) {
-    return (0, _generated.identifier)("undefined");
+    return (0, _generated.identifier)('undefined');
   }
 
   if (value === true || value === false) {
@@ -39,11 +43,11 @@ function valueToNode(value) {
     return (0, _generated.nullLiteral)();
   }
 
-  if (typeof value === "string") {
+  if (typeof value === 'string') {
     return (0, _generated.stringLiteral)(value);
   }
 
-  if (typeof value === "number") {
+  if (typeof value === 'number') {
     let result;
 
     if (Number.isFinite(value)) {
@@ -57,11 +61,15 @@ function valueToNode(value) {
         numerator = (0, _generated.numericLiteral)(1);
       }
 
-      result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0));
+      result = (0, _generated.binaryExpression)(
+        '/',
+        numerator,
+        (0, _generated.numericLiteral)(0)
+      );
     }
 
     if (value < 0 || Object.is(value, -0)) {
-      result = (0, _generated.unaryExpression)("-", result);
+      result = (0, _generated.unaryExpression)('-', result);
     }
 
     return result;
@@ -89,7 +97,9 @@ function valueToNode(value) {
         nodeKey = (0, _generated.stringLiteral)(key);
       }
 
-      props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key])));
+      props.push(
+        (0, _generated.objectProperty)(nodeKey, valueToNode(value[key]))
+      );
     }
 
     return (0, _generated.objectExpression)(props);

node_modules/@babel/types/lib/definitions/experimental.js

@@ -1,135 +1,148 @@
-"use strict";
+'use strict';
 
-var _utils = require("./utils");
+var _utils = require('./utils');
 
-(0, _utils.default)("ArgumentPlaceholder", {});
+(0, _utils.default)('ArgumentPlaceholder', {});
-(0, _utils.default)("BindExpression", {
+(0, _utils.default)('BindExpression', {
-  visitor: ["object", "callee"],
+  visitor: ['object', 'callee'],
-  aliases: ["Expression"],
+  aliases: ['Expression'],
-  fields: !process.env.BABEL_TYPES_8_BREAKING ? {
+  fields:
+    !process.env.BABEL_TYPES_8_BREAKING ?
+      {
         object: {
           validate: Object.assign(() => {}, {
-        oneOfNodeTypes: ["Expression"]
+            oneOfNodeTypes: ['Expression'],
-      })
+          }),
         },
         callee: {
           validate: Object.assign(() => {}, {
-        oneOfNodeTypes: ["Expression"]
+            oneOfNodeTypes: ['Expression'],
-      })
+          }),
+        },
       }
-  } : {
+    : {
         object: {
-      validate: (0, _utils.assertNodeType)("Expression")
+          validate: (0, _utils.assertNodeType)('Expression'),
         },
         callee: {
-      validate: (0, _utils.assertNodeType)("Expression")
+          validate: (0, _utils.assertNodeType)('Expression'),
-    }
+        },
-  }
+      },
 });
-(0, _utils.default)("ImportAttribute", {
+(0, _utils.default)('ImportAttribute', {
-  visitor: ["key", "value"],
+  visitor: ['key', 'value'],
   fields: {
     key: {
-      validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
+      validate: (0, _utils.assertNodeType)('Identifier', 'StringLiteral'),
     },
     value: {
-      validate: (0, _utils.assertNodeType)("StringLiteral")
+      validate: (0, _utils.assertNodeType)('StringLiteral'),
-    }
+    },
-  }
+  },
 });
-(0, _utils.default)("Decorator", {
+(0, _utils.default)('Decorator', {
-  visitor: ["expression"],
+  visitor: ['expression'],
   fields: {
     expression: {
-      validate: (0, _utils.assertNodeType)("Expression")
+      validate: (0, _utils.assertNodeType)('Expression'),
-    }
+    },
-  }
+  },
 });
-(0, _utils.default)("DoExpression", {
+(0, _utils.default)('DoExpression', {
-  visitor: ["body"],
+  visitor: ['body'],
-  builder: ["body", "async"],
+  builder: ['body', 'async'],
-  aliases: ["Expression"],
+  aliases: ['Expression'],
   fields: {
     body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement")
+      validate: (0, _utils.assertNodeType)('BlockStatement'),
     },
     async: {
-      validate: (0, _utils.assertValueType)("boolean"),
+      validate: (0, _utils.assertValueType)('boolean'),
-      default: false
+      default: false,
-    }
+    },
-  }
+  },
 });
-(0, _utils.default)("ExportDefaultSpecifier", {
+(0, _utils.default)('ExportDefaultSpecifier', {
-  visitor: ["exported"],
+  visitor: ['exported'],
-  aliases: ["ModuleSpecifier"],
+  aliases: ['ModuleSpecifier'],
   fields: {
     exported: {
-      validate: (0, _utils.assertNodeType)("Identifier")
+      validate: (0, _utils.assertNodeType)('Identifier'),
-    }
+    },
-  }
+  },
 });
-(0, _utils.default)("RecordExpression", {
+(0, _utils.default)('RecordExpression', {
-  visitor: ["properties"],
+  visitor: ['properties'],
-  aliases: ["Expression"],
+  aliases: ['Expression'],
   fields: {
     properties: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement")))
+      validate: (0, _utils.chain)(
-    }
+        (0, _utils.assertValueType)('array'),
-  }
+        (0, _utils.assertEach)(
+          (0, _utils.assertNodeType)('ObjectProperty', 'SpreadElement')
+        )
+      ),
+    },
+  },
 });
-(0, _utils.default)("TupleExpression", {
+(0, _utils.default)('TupleExpression', {
   fields: {
     elements: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))),
+      validate: (0, _utils.chain)(
-      default: []
+        (0, _utils.assertValueType)('array'),
-    }
+        (0, _utils.assertEach)(
+          (0, _utils.assertNodeType)('Expression', 'SpreadElement')
+        )
+      ),
+      default: [],
     },
-  visitor: ["elements"],
+  },
-  aliases: ["Expression"]
+  visitor: ['elements'],
+  aliases: ['Expression'],
 });
-(0, _utils.default)("DecimalLiteral", {
+(0, _utils.default)('DecimalLiteral', {
-  builder: ["value"],
+  builder: ['value'],
   fields: {
     value: {
-      validate: (0, _utils.assertValueType)("string")
+      validate: (0, _utils.assertValueType)('string'),
-    }
     },
-  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+  },
+  aliases: ['Expression', 'Pureish', 'Literal', 'Immutable'],
 });
-(0, _utils.default)("ModuleExpression", {
+(0, _utils.default)('ModuleExpression', {
-  visitor: ["body"],
+  visitor: ['body'],
   fields: {
     body: {
-      validate: (0, _utils.assertNodeType)("Program")
+      validate: (0, _utils.assertNodeType)('Program'),
-    }
     },
-  aliases: ["Expression"]
+  },
+  aliases: ['Expression'],
 });
-(0, _utils.default)("TopicReference", {
+(0, _utils.default)('TopicReference', {
-  aliases: ["Expression"]
+  aliases: ['Expression'],
 });
-(0, _utils.default)("PipelineTopicExpression", {
+(0, _utils.default)('PipelineTopicExpression', {
-  builder: ["expression"],
+  builder: ['expression'],
-  visitor: ["expression"],
+  visitor: ['expression'],
   fields: {
     expression: {
-      validate: (0, _utils.assertNodeType)("Expression")
+      validate: (0, _utils.assertNodeType)('Expression'),
-    }
     },
-  aliases: ["Expression"]
+  },
+  aliases: ['Expression'],
 });
-(0, _utils.default)("PipelineBareFunction", {
+(0, _utils.default)('PipelineBareFunction', {
-  builder: ["callee"],
+  builder: ['callee'],
-  visitor: ["callee"],
+  visitor: ['callee'],
   fields: {
     callee: {
-      validate: (0, _utils.assertNodeType)("Expression")
+      validate: (0, _utils.assertNodeType)('Expression'),
-    }
     },
-  aliases: ["Expression"]
+  },
+  aliases: ['Expression'],
 });
-(0, _utils.default)("PipelinePrimaryTopicReference", {
+(0, _utils.default)('PipelinePrimaryTopicReference', {
-  aliases: ["Expression"]
+  aliases: ['Expression'],
 });
 
 //# sourceMappingURL=experimental.js.map

node_modules/@babel/types/lib/definitions/flow.js

@@ -1,488 +1,563 @@
-"use strict";
+'use strict';
 
-var _utils = require("./utils");
+var _utils = require('./utils');
 
-const defineType = (0, _utils.defineAliasedType)("Flow");
+const defineType = (0, _utils.defineAliasedType)('Flow');
 
-const defineInterfaceishType = name => {
+const defineInterfaceishType = (name) => {
   defineType(name, {
-    builder: ["id", "typeParameters", "extends", "body"],
+    builder: ['id', 'typeParameters', 'extends', 'body'],
-    visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"],
+    visitor: [
-    aliases: ["FlowDeclaration", "Statement", "Declaration"],
+      'id',
+      'typeParameters',
+      'extends',
+      'mixins',
+      'implements',
+      'body',
+    ],
+    aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
     fields: {
-      id: (0, _utils.validateType)("Identifier"),
+      id: (0, _utils.validateType)('Identifier'),
-      typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+      typeParameters: (0, _utils.validateOptionalType)(
-      extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+        'TypeParameterDeclaration'
-      mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+      ),
-      implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")),
+      extends: (0, _utils.validateOptional)(
-      body: (0, _utils.validateType)("ObjectTypeAnnotation")
+        (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", {
+defineType('AnyTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("ArrayTypeAnnotation", {
+defineType('ArrayTypeAnnotation', {
-  visitor: ["elementType"],
+  visitor: ['elementType'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    elementType: (0, _utils.validateType)("FlowType")
+    elementType: (0, _utils.validateType)('FlowType'),
-  }
+  },
 });
-defineType("BooleanTypeAnnotation", {
+defineType('BooleanTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("BooleanLiteralTypeAnnotation", {
+defineType('BooleanLiteralTypeAnnotation', {
-  builder: ["value"],
+  builder: ['value'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+    value: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-  }
+  },
 });
-defineType("NullLiteralTypeAnnotation", {
+defineType('NullLiteralTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("ClassImplements", {
+defineType('ClassImplements', {
-  visitor: ["id", "typeParameters"],
+  visitor: ['id', 'typeParameters'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+    typeParameters: (0, _utils.validateOptionalType)(
-  }
+      'TypeParameterInstantiation'
+    ),
+  },
 });
-defineInterfaceishType("DeclareClass");
+defineInterfaceishType('DeclareClass');
-defineType("DeclareFunction", {
+defineType('DeclareFunction', {
-  visitor: ["id"],
+  visitor: ['id'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
+    predicate: (0, _utils.validateOptionalType)('DeclaredPredicate'),
-  }
+  },
 });
-defineInterfaceishType("DeclareInterface");
+defineInterfaceishType('DeclareInterface');
-defineType("DeclareModule", {
+defineType('DeclareModule', {
-  builder: ["id", "body", "kind"],
+  builder: ['id', 'body', 'kind'],
-  visitor: ["id", "body"],
+  visitor: ['id', 'body'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    id: (0, _utils.validateType)(['Identifier', 'StringLiteral']),
-    body: (0, _utils.validateType)("BlockStatement"),
+    body: (0, _utils.validateType)('BlockStatement'),
-    kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
+    kind: (0, _utils.validateOptional)(
-  }
+      (0, _utils.assertOneOf)('CommonJS', 'ES')
+    ),
+  },
 });
-defineType("DeclareModuleExports", {
+defineType('DeclareModuleExports', {
-  visitor: ["typeAnnotation"],
+  visitor: ['typeAnnotation'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+    typeAnnotation: (0, _utils.validateType)('TypeAnnotation'),
-  }
+  },
 });
-defineType("DeclareTypeAlias", {
+defineType('DeclareTypeAlias', {
-  visitor: ["id", "typeParameters", "right"],
+  visitor: ['id', 'typeParameters', 'right'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    typeParameters: (0, _utils.validateOptionalType)(
-    right: (0, _utils.validateType)("FlowType")
+      'TypeParameterDeclaration'
-  }
+    ),
+    right: (0, _utils.validateType)('FlowType'),
+  },
 });
-defineType("DeclareOpaqueType", {
+defineType('DeclareOpaqueType', {
-  visitor: ["id", "typeParameters", "supertype"],
+  visitor: ['id', 'typeParameters', 'supertype'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    typeParameters: (0, _utils.validateOptionalType)(
-    supertype: (0, _utils.validateOptionalType)("FlowType"),
+      'TypeParameterDeclaration'
-    impltype: (0, _utils.validateOptionalType)("FlowType")
+    ),
-  }
+    supertype: (0, _utils.validateOptionalType)('FlowType'),
+    impltype: (0, _utils.validateOptionalType)('FlowType'),
+  },
 });
-defineType("DeclareVariable", {
+defineType('DeclareVariable', {
-  visitor: ["id"],
+  visitor: ['id'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    id: (0, _utils.validateType)("Identifier")
+    id: (0, _utils.validateType)('Identifier'),
-  }
+  },
 });
-defineType("DeclareExportDeclaration", {
+defineType('DeclareExportDeclaration', {
-  visitor: ["declaration", "specifiers", "source"],
+  visitor: ['declaration', 'specifiers', 'source'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    declaration: (0, _utils.validateOptionalType)("Flow"),
+    declaration: (0, _utils.validateOptionalType)('Flow'),
-    specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
+    specifiers: (0, _utils.validateOptional)(
-    source: (0, _utils.validateOptionalType)("StringLiteral"),
+      (0, _utils.arrayOfType)(['ExportSpecifier', 'ExportNamespaceSpecifier'])
-    default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+    ),
-  }
+    source: (0, _utils.validateOptionalType)('StringLiteral'),
+    default: (0, _utils.validateOptional)(
+      (0, _utils.assertValueType)('boolean')
+    ),
+  },
 });
-defineType("DeclareExportAllDeclaration", {
+defineType('DeclareExportAllDeclaration', {
-  visitor: ["source"],
+  visitor: ['source'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    source: (0, _utils.validateType)("StringLiteral"),
+    source: (0, _utils.validateType)('StringLiteral'),
-    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
+    exportKind: (0, _utils.validateOptional)(
-  }
+      (0, _utils.assertOneOf)('type', 'value')
+    ),
+  },
 });
-defineType("DeclaredPredicate", {
+defineType('DeclaredPredicate', {
-  visitor: ["value"],
+  visitor: ['value'],
-  aliases: ["FlowPredicate"],
+  aliases: ['FlowPredicate'],
   fields: {
-    value: (0, _utils.validateType)("Flow")
+    value: (0, _utils.validateType)('Flow'),
-  }
+  },
 });
-defineType("ExistsTypeAnnotation", {
+defineType('ExistsTypeAnnotation', {
-  aliases: ["FlowType"]
+  aliases: ['FlowType'],
 });
-defineType("FunctionTypeAnnotation", {
+defineType('FunctionTypeAnnotation', {
-  visitor: ["typeParameters", "params", "rest", "returnType"],
+  visitor: ['typeParameters', 'params', 'rest', 'returnType'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    typeParameters: (0, _utils.validateOptionalType)(
-    params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
+      'TypeParameterDeclaration'
-    rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+    ),
-    this: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+    params: (0, _utils.validate)((0, _utils.arrayOfType)('FunctionTypeParam')),
-    returnType: (0, _utils.validateType)("FlowType")
+    rest: (0, _utils.validateOptionalType)('FunctionTypeParam'),
-  }
+    this: (0, _utils.validateOptionalType)('FunctionTypeParam'),
+    returnType: (0, _utils.validateType)('FlowType'),
+  },
 });
-defineType("FunctionTypeParam", {
+defineType('FunctionTypeParam', {
-  visitor: ["name", "typeAnnotation"],
+  visitor: ['name', 'typeAnnotation'],
   fields: {
-    name: (0, _utils.validateOptionalType)("Identifier"),
+    name: (0, _utils.validateOptionalType)('Identifier'),
-    typeAnnotation: (0, _utils.validateType)("FlowType"),
+    typeAnnotation: (0, _utils.validateType)('FlowType'),
-    optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+    optional: (0, _utils.validateOptional)(
-  }
+      (0, _utils.assertValueType)('boolean')
+    ),
+  },
 });
-defineType("GenericTypeAnnotation", {
+defineType('GenericTypeAnnotation', {
-  visitor: ["id", "typeParameters"],
+  visitor: ['id', 'typeParameters'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
+    id: (0, _utils.validateType)(['Identifier', 'QualifiedTypeIdentifier']),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+    typeParameters: (0, _utils.validateOptionalType)(
-  }
+      'TypeParameterInstantiation'
+    ),
+  },
 });
-defineType("InferredPredicate", {
+defineType('InferredPredicate', {
-  aliases: ["FlowPredicate"]
+  aliases: ['FlowPredicate'],
 });
-defineType("InterfaceExtends", {
+defineType('InterfaceExtends', {
-  visitor: ["id", "typeParameters"],
+  visitor: ['id', 'typeParameters'],
   fields: {
-    id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
+    id: (0, _utils.validateType)(['Identifier', 'QualifiedTypeIdentifier']),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+    typeParameters: (0, _utils.validateOptionalType)(
-  }
+      'TypeParameterInstantiation'
+    ),
+  },
 });
-defineInterfaceishType("InterfaceDeclaration");
+defineInterfaceishType('InterfaceDeclaration');
-defineType("InterfaceTypeAnnotation", {
+defineType('InterfaceTypeAnnotation', {
-  visitor: ["extends", "body"],
+  visitor: ['extends', 'body'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+    extends: (0, _utils.validateOptional)(
-    body: (0, _utils.validateType)("ObjectTypeAnnotation")
+      (0, _utils.arrayOfType)('InterfaceExtends')
-  }
+    ),
+    body: (0, _utils.validateType)('ObjectTypeAnnotation'),
+  },
 });
-defineType("IntersectionTypeAnnotation", {
+defineType('IntersectionTypeAnnotation', {
-  visitor: ["types"],
+  visitor: ['types'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+    types: (0, _utils.validate)((0, _utils.arrayOfType)('FlowType')),
-  }
+  },
 });
-defineType("MixedTypeAnnotation", {
+defineType('MixedTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("EmptyTypeAnnotation", {
+defineType('EmptyTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("NullableTypeAnnotation", {
+defineType('NullableTypeAnnotation', {
-  visitor: ["typeAnnotation"],
+  visitor: ['typeAnnotation'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    typeAnnotation: (0, _utils.validateType)("FlowType")
+    typeAnnotation: (0, _utils.validateType)('FlowType'),
-  }
+  },
 });
-defineType("NumberLiteralTypeAnnotation", {
+defineType('NumberLiteralTypeAnnotation', {
-  builder: ["value"],
+  builder: ['value'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
+    value: (0, _utils.validate)((0, _utils.assertValueType)('number')),
-  }
+  },
 });
-defineType("NumberTypeAnnotation", {
+defineType('NumberTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("ObjectTypeAnnotation", {
+defineType('ObjectTypeAnnotation', {
-  visitor: ["properties", "indexers", "callProperties", "internalSlots"],
+  visitor: ['properties', 'indexers', 'callProperties', 'internalSlots'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
-  builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
+  builder: [
+    'properties',
+    'indexers',
+    'callProperties',
+    'internalSlots',
+    'exact',
+  ],
   fields: {
-    properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
+    properties: (0, _utils.validate)(
+      (0, _utils.arrayOfType)([
+        'ObjectTypeProperty',
+        'ObjectTypeSpreadProperty',
+      ])
+    ),
     indexers: {
-      validate: (0, _utils.arrayOfType)("ObjectTypeIndexer"),
+      validate: (0, _utils.arrayOfType)('ObjectTypeIndexer'),
       optional: true,
-      default: []
+      default: [],
     },
     callProperties: {
-      validate: (0, _utils.arrayOfType)("ObjectTypeCallProperty"),
+      validate: (0, _utils.arrayOfType)('ObjectTypeCallProperty'),
       optional: true,
-      default: []
+      default: [],
     },
     internalSlots: {
-      validate: (0, _utils.arrayOfType)("ObjectTypeInternalSlot"),
+      validate: (0, _utils.arrayOfType)('ObjectTypeInternalSlot'),
       optional: true,
-      default: []
+      default: [],
     },
     exact: {
-      validate: (0, _utils.assertValueType)("boolean"),
+      validate: (0, _utils.assertValueType)('boolean'),
-      default: false
+      default: false,
+    },
+    inexact: (0, _utils.validateOptional)(
+      (0, _utils.assertValueType)('boolean')
+    ),
   },
-    inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
-  }
 });
-defineType("ObjectTypeInternalSlot", {
+defineType('ObjectTypeInternalSlot', {
-  visitor: ["id", "value", "optional", "static", "method"],
+  visitor: ['id', 'value', 'optional', 'static', 'method'],
-  aliases: ["UserWhitespacable"],
+  aliases: ['UserWhitespacable'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    value: (0, _utils.validateType)("FlowType"),
+    value: (0, _utils.validateType)('FlowType'),
-    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-    method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+    method: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-  }
+  },
 });
-defineType("ObjectTypeCallProperty", {
+defineType('ObjectTypeCallProperty', {
-  visitor: ["value"],
+  visitor: ['value'],
-  aliases: ["UserWhitespacable"],
+  aliases: ['UserWhitespacable'],
   fields: {
-    value: (0, _utils.validateType)("FlowType"),
+    value: (0, _utils.validateType)('FlowType'),
-    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+    static: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-  }
+  },
 });
-defineType("ObjectTypeIndexer", {
+defineType('ObjectTypeIndexer', {
-  visitor: ["id", "key", "value", "variance"],
+  visitor: ['id', 'key', 'value', 'variance'],
-  aliases: ["UserWhitespacable"],
+  aliases: ['UserWhitespacable'],
   fields: {
-    id: (0, _utils.validateOptionalType)("Identifier"),
+    id: (0, _utils.validateOptionalType)('Identifier'),
-    key: (0, _utils.validateType)("FlowType"),
+    key: (0, _utils.validateType)('FlowType'),
-    value: (0, _utils.validateType)("FlowType"),
+    value: (0, _utils.validateType)('FlowType'),
-    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-    variance: (0, _utils.validateOptionalType)("Variance")
+    variance: (0, _utils.validateOptionalType)('Variance'),
-  }
+  },
 });
-defineType("ObjectTypeProperty", {
+defineType('ObjectTypeProperty', {
-  visitor: ["key", "value", "variance"],
+  visitor: ['key', 'value', 'variance'],
-  aliases: ["UserWhitespacable"],
+  aliases: ['UserWhitespacable'],
   fields: {
-    key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    key: (0, _utils.validateType)(['Identifier', 'StringLiteral']),
-    value: (0, _utils.validateType)("FlowType"),
+    value: (0, _utils.validateType)('FlowType'),
-    kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
+    kind: (0, _utils.validate)((0, _utils.assertOneOf)('init', 'get', 'set')),
-    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-    proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    proto: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-    variance: (0, _utils.validateOptionalType)("Variance"),
+    variance: (0, _utils.validateOptionalType)('Variance'),
-    method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+    method: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-  }
+  },
 });
-defineType("ObjectTypeSpreadProperty", {
+defineType('ObjectTypeSpreadProperty', {
-  visitor: ["argument"],
+  visitor: ['argument'],
-  aliases: ["UserWhitespacable"],
+  aliases: ['UserWhitespacable'],
   fields: {
-    argument: (0, _utils.validateType)("FlowType")
+    argument: (0, _utils.validateType)('FlowType'),
-  }
+  },
 });
-defineType("OpaqueType", {
+defineType('OpaqueType', {
-  visitor: ["id", "typeParameters", "supertype", "impltype"],
+  visitor: ['id', 'typeParameters', 'supertype', 'impltype'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    typeParameters: (0, _utils.validateOptionalType)(
-    supertype: (0, _utils.validateOptionalType)("FlowType"),
+      'TypeParameterDeclaration'
-    impltype: (0, _utils.validateType)("FlowType")
+    ),
-  }
+    supertype: (0, _utils.validateOptionalType)('FlowType'),
+    impltype: (0, _utils.validateType)('FlowType'),
+  },
 });
-defineType("QualifiedTypeIdentifier", {
+defineType('QualifiedTypeIdentifier', {
-  visitor: ["id", "qualification"],
+  visitor: ['id', 'qualification'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
+    qualification: (0, _utils.validateType)([
-  }
+      'Identifier',
+      'QualifiedTypeIdentifier',
+    ]),
+  },
 });
-defineType("StringLiteralTypeAnnotation", {
+defineType('StringLiteralTypeAnnotation', {
-  builder: ["value"],
+  builder: ['value'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
+    value: (0, _utils.validate)((0, _utils.assertValueType)('string')),
-  }
+  },
 });
-defineType("StringTypeAnnotation", {
+defineType('StringTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("SymbolTypeAnnotation", {
+defineType('SymbolTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("ThisTypeAnnotation", {
+defineType('ThisTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("TupleTypeAnnotation", {
+defineType('TupleTypeAnnotation', {
-  visitor: ["types"],
+  visitor: ['types'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+    types: (0, _utils.validate)((0, _utils.arrayOfType)('FlowType')),
-  }
+  },
 });
-defineType("TypeofTypeAnnotation", {
+defineType('TypeofTypeAnnotation', {
-  visitor: ["argument"],
+  visitor: ['argument'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    argument: (0, _utils.validateType)("FlowType")
+    argument: (0, _utils.validateType)('FlowType'),
-  }
+  },
 });
-defineType("TypeAlias", {
+defineType('TypeAlias', {
-  visitor: ["id", "typeParameters", "right"],
+  visitor: ['id', 'typeParameters', 'right'],
-  aliases: ["FlowDeclaration", "Statement", "Declaration"],
+  aliases: ['FlowDeclaration', 'Statement', 'Declaration'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    typeParameters: (0, _utils.validateOptionalType)(
-    right: (0, _utils.validateType)("FlowType")
+      'TypeParameterDeclaration'
-  }
+    ),
+    right: (0, _utils.validateType)('FlowType'),
+  },
 });
-defineType("TypeAnnotation", {
+defineType('TypeAnnotation', {
-  visitor: ["typeAnnotation"],
+  visitor: ['typeAnnotation'],
   fields: {
-    typeAnnotation: (0, _utils.validateType)("FlowType")
+    typeAnnotation: (0, _utils.validateType)('FlowType'),
-  }
+  },
 });
-defineType("TypeCastExpression", {
+defineType('TypeCastExpression', {
-  visitor: ["expression", "typeAnnotation"],
+  visitor: ['expression', 'typeAnnotation'],
-  aliases: ["ExpressionWrapper", "Expression"],
+  aliases: ['ExpressionWrapper', 'Expression'],
   fields: {
-    expression: (0, _utils.validateType)("Expression"),
+    expression: (0, _utils.validateType)('Expression'),
-    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+    typeAnnotation: (0, _utils.validateType)('TypeAnnotation'),
-  }
+  },
 });
-defineType("TypeParameter", {
+defineType('TypeParameter', {
-  visitor: ["bound", "default", "variance"],
+  visitor: ['bound', 'default', 'variance'],
   fields: {
-    name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    name: (0, _utils.validate)((0, _utils.assertValueType)('string')),
-    bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
+    bound: (0, _utils.validateOptionalType)('TypeAnnotation'),
-    default: (0, _utils.validateOptionalType)("FlowType"),
+    default: (0, _utils.validateOptionalType)('FlowType'),
-    variance: (0, _utils.validateOptionalType)("Variance")
+    variance: (0, _utils.validateOptionalType)('Variance'),
-  }
+  },
 });
-defineType("TypeParameterDeclaration", {
+defineType('TypeParameterDeclaration', {
-  visitor: ["params"],
+  visitor: ['params'],
   fields: {
-    params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
+    params: (0, _utils.validate)((0, _utils.arrayOfType)('TypeParameter')),
-  }
+  },
 });
-defineType("TypeParameterInstantiation", {
+defineType('TypeParameterInstantiation', {
-  visitor: ["params"],
+  visitor: ['params'],
   fields: {
-    params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+    params: (0, _utils.validate)((0, _utils.arrayOfType)('FlowType')),
-  }
+  },
 });
-defineType("UnionTypeAnnotation", {
+defineType('UnionTypeAnnotation', {
-  visitor: ["types"],
+  visitor: ['types'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+    types: (0, _utils.validate)((0, _utils.arrayOfType)('FlowType')),
-  }
+  },
 });
-defineType("Variance", {
+defineType('Variance', {
-  builder: ["kind"],
+  builder: ['kind'],
   fields: {
-    kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
+    kind: (0, _utils.validate)((0, _utils.assertOneOf)('minus', 'plus')),
-  }
+  },
 });
-defineType("VoidTypeAnnotation", {
+defineType('VoidTypeAnnotation', {
-  aliases: ["FlowType", "FlowBaseAnnotation"]
+  aliases: ['FlowType', 'FlowBaseAnnotation'],
 });
-defineType("EnumDeclaration", {
+defineType('EnumDeclaration', {
-  aliases: ["Statement", "Declaration"],
+  aliases: ['Statement', 'Declaration'],
-  visitor: ["id", "body"],
+  visitor: ['id', 'body'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"])
+    body: (0, _utils.validateType)([
-  }
+      'EnumBooleanBody',
+      'EnumNumberBody',
+      'EnumStringBody',
+      'EnumSymbolBody',
+    ]),
+  },
 });
-defineType("EnumBooleanBody", {
+defineType('EnumBooleanBody', {
-  aliases: ["EnumBody"],
+  aliases: ['EnumBody'],
-  visitor: ["members"],
+  visitor: ['members'],
   fields: {
-    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    explicitType: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-    members: (0, _utils.validateArrayOfType)("EnumBooleanMember"),
+    members: (0, _utils.validateArrayOfType)('EnumBooleanMember'),
-    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+    hasUnknownMembers: (0, _utils.validate)(
-  }
+      (0, _utils.assertValueType)('boolean')
+    ),
+  },
 });
-defineType("EnumNumberBody", {
+defineType('EnumNumberBody', {
-  aliases: ["EnumBody"],
+  aliases: ['EnumBody'],
-  visitor: ["members"],
+  visitor: ['members'],
   fields: {
-    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    explicitType: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-    members: (0, _utils.validateArrayOfType)("EnumNumberMember"),
+    members: (0, _utils.validateArrayOfType)('EnumNumberMember'),
-    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+    hasUnknownMembers: (0, _utils.validate)(
-  }
+      (0, _utils.assertValueType)('boolean')
+    ),
+  },
 });
-defineType("EnumStringBody", {
+defineType('EnumStringBody', {
-  aliases: ["EnumBody"],
+  aliases: ['EnumBody'],
-  visitor: ["members"],
+  visitor: ['members'],
   fields: {
-    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    explicitType: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-    members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"]),
+    members: (0, _utils.validateArrayOfType)([
-    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+      'EnumStringMember',
-  }
+      'EnumDefaultedMember',
+    ]),
+    hasUnknownMembers: (0, _utils.validate)(
+      (0, _utils.assertValueType)('boolean')
+    ),
+  },
 });
-defineType("EnumSymbolBody", {
+defineType('EnumSymbolBody', {
-  aliases: ["EnumBody"],
+  aliases: ['EnumBody'],
-  visitor: ["members"],
+  visitor: ['members'],
   fields: {
-    members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"),
+    members: (0, _utils.validateArrayOfType)('EnumDefaultedMember'),
-    hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+    hasUnknownMembers: (0, _utils.validate)(
-  }
+      (0, _utils.assertValueType)('boolean')
+    ),
+  },
 });
-defineType("EnumBooleanMember", {
+defineType('EnumBooleanMember', {
-  aliases: ["EnumMember"],
+  aliases: ['EnumMember'],
-  visitor: ["id"],
+  visitor: ['id'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    init: (0, _utils.validateType)("BooleanLiteral")
+    init: (0, _utils.validateType)('BooleanLiteral'),
-  }
+  },
 });
-defineType("EnumNumberMember", {
+defineType('EnumNumberMember', {
-  aliases: ["EnumMember"],
+  aliases: ['EnumMember'],
-  visitor: ["id", "init"],
+  visitor: ['id', 'init'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    init: (0, _utils.validateType)("NumericLiteral")
+    init: (0, _utils.validateType)('NumericLiteral'),
-  }
+  },
 });
-defineType("EnumStringMember", {
+defineType('EnumStringMember', {
-  aliases: ["EnumMember"],
+  aliases: ['EnumMember'],
-  visitor: ["id", "init"],
+  visitor: ['id', 'init'],
   fields: {
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    init: (0, _utils.validateType)("StringLiteral")
+    init: (0, _utils.validateType)('StringLiteral'),
-  }
+  },
 });
-defineType("EnumDefaultedMember", {
+defineType('EnumDefaultedMember', {
-  aliases: ["EnumMember"],
+  aliases: ['EnumMember'],
-  visitor: ["id"],
+  visitor: ['id'],
   fields: {
-    id: (0, _utils.validateType)("Identifier")
+    id: (0, _utils.validateType)('Identifier'),
-  }
+  },
 });
-defineType("IndexedAccessType", {
+defineType('IndexedAccessType', {
-  visitor: ["objectType", "indexType"],
+  visitor: ['objectType', 'indexType'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    objectType: (0, _utils.validateType)("FlowType"),
+    objectType: (0, _utils.validateType)('FlowType'),
-    indexType: (0, _utils.validateType)("FlowType")
+    indexType: (0, _utils.validateType)('FlowType'),
-  }
+  },
 });
-defineType("OptionalIndexedAccessType", {
+defineType('OptionalIndexedAccessType', {
-  visitor: ["objectType", "indexType"],
+  visitor: ['objectType', 'indexType'],
-  aliases: ["FlowType"],
+  aliases: ['FlowType'],
   fields: {
-    objectType: (0, _utils.validateType)("FlowType"),
+    objectType: (0, _utils.validateType)('FlowType'),
-    indexType: (0, _utils.validateType)("FlowType"),
+    indexType: (0, _utils.validateType)('FlowType'),
-    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+    optional: (0, _utils.validate)((0, _utils.assertValueType)('boolean')),
-  }
+  },
 });
 
 //# sourceMappingURL=flow.js.map

node_modules/@babel/types/lib/definitions/index.js

@@ -1,87 +1,87 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
-Object.defineProperty(exports, "ALIAS_KEYS", {
+Object.defineProperty(exports, 'ALIAS_KEYS', {
   enumerable: true,
   get: function () {
     return _utils.ALIAS_KEYS;
-  }
+  },
 });
-Object.defineProperty(exports, "BUILDER_KEYS", {
+Object.defineProperty(exports, 'BUILDER_KEYS', {
   enumerable: true,
   get: function () {
     return _utils.BUILDER_KEYS;
-  }
+  },
 });
-Object.defineProperty(exports, "DEPRECATED_KEYS", {
+Object.defineProperty(exports, 'DEPRECATED_KEYS', {
   enumerable: true,
   get: function () {
     return _utils.DEPRECATED_KEYS;
-  }
+  },
 });
-Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
+Object.defineProperty(exports, 'FLIPPED_ALIAS_KEYS', {
   enumerable: true,
   get: function () {
     return _utils.FLIPPED_ALIAS_KEYS;
-  }
+  },
 });
-Object.defineProperty(exports, "NODE_FIELDS", {
+Object.defineProperty(exports, 'NODE_FIELDS', {
   enumerable: true,
   get: function () {
     return _utils.NODE_FIELDS;
-  }
+  },
 });
-Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", {
+Object.defineProperty(exports, 'NODE_PARENT_VALIDATIONS', {
   enumerable: true,
   get: function () {
     return _utils.NODE_PARENT_VALIDATIONS;
-  }
+  },
 });
-Object.defineProperty(exports, "PLACEHOLDERS", {
+Object.defineProperty(exports, 'PLACEHOLDERS', {
   enumerable: true,
   get: function () {
     return _placeholders.PLACEHOLDERS;
-  }
+  },
 });
-Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", {
+Object.defineProperty(exports, 'PLACEHOLDERS_ALIAS', {
   enumerable: true,
   get: function () {
     return _placeholders.PLACEHOLDERS_ALIAS;
-  }
+  },
 });
-Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_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", {
+Object.defineProperty(exports, 'VISITOR_KEYS', {
   enumerable: true,
   get: function () {
     return _utils.VISITOR_KEYS;
-  }
+  },
 });
 
-var _toFastProperties = require("to-fast-properties");
+var _toFastProperties = require('to-fast-properties');
 
-require("./core");
+require('./core');
 
-require("./flow");
+require('./flow');
 
-require("./jsx");
+require('./jsx');
 
-require("./misc");
+require('./misc');
 
-require("./experimental");
+require('./experimental');
 
-require("./typescript");
+require('./typescript');
 
-var _utils = require("./utils");
+var _utils = require('./utils');
 
-var _placeholders = require("./placeholders");
+var _placeholders = require('./placeholders');
 
 _toFastProperties(_utils.VISITOR_KEYS);
 
@@ -99,7 +99,11 @@ _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));
+const TYPES = [].concat(
+  Object.keys(_utils.VISITOR_KEYS),
+  Object.keys(_utils.FLIPPED_ALIAS_KEYS),
+  Object.keys(_utils.DEPRECATED_KEYS)
+);
 exports.TYPES = TYPES;
 
 //# sourceMappingURL=index.js.map

node_modules/@babel/types/lib/definitions/jsx.js

@@ -1,159 +1,211 @@
-"use strict";
+'use strict';
 
-var _utils = require("./utils");
+var _utils = require('./utils');
 
-const defineType = (0, _utils.defineAliasedType)("JSX");
+const defineType = (0, _utils.defineAliasedType)('JSX');
-defineType("JSXAttribute", {
+defineType('JSXAttribute', {
-  visitor: ["name", "value"],
+  visitor: ['name', 'value'],
-  aliases: ["Immutable"],
+  aliases: ['Immutable'],
   fields: {
     name: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
+      validate: (0, _utils.assertNodeType)(
+        'JSXIdentifier',
+        'JSXNamespacedName'
+      ),
     },
     value: {
       optional: true,
-      validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
+      validate: (0, _utils.assertNodeType)(
-    }
+        'JSXElement',
-  }
+        'JSXFragment',
+        'StringLiteral',
+        'JSXExpressionContainer'
+      ),
+    },
+  },
 });
-defineType("JSXClosingElement", {
+defineType('JSXClosingElement', {
-  visitor: ["name"],
+  visitor: ['name'],
-  aliases: ["Immutable"],
+  aliases: ['Immutable'],
   fields: {
     name: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
+      validate: (0, _utils.assertNodeType)(
-    }
+        'JSXIdentifier',
-  }
+        'JSXMemberExpression',
+        'JSXNamespacedName'
+      ),
+    },
+  },
 });
-defineType("JSXElement", {
+defineType('JSXElement', {
-  builder: ["openingElement", "closingElement", "children", "selfClosing"],
+  builder: ['openingElement', 'closingElement', 'children', 'selfClosing'],
-  visitor: ["openingElement", "children", "closingElement"],
+  visitor: ['openingElement', 'children', 'closingElement'],
-  aliases: ["Immutable", "Expression"],
+  aliases: ['Immutable', 'Expression'],
-  fields: Object.assign({
+  fields: Object.assign(
+    {
       openingElement: {
-      validate: (0, _utils.assertNodeType)("JSXOpeningElement")
+        validate: (0, _utils.assertNodeType)('JSXOpeningElement'),
       },
       closingElement: {
         optional: true,
-      validate: (0, _utils.assertNodeType)("JSXClosingElement")
+        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")))
+        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"),
+        validate: (0, _utils.assertValueType)('boolean'),
-      optional: true
+        optional: true,
+      },
     }
-  })
+  ),
 });
-defineType("JSXEmptyExpression", {});
+defineType('JSXEmptyExpression', {});
-defineType("JSXExpressionContainer", {
+defineType('JSXExpressionContainer', {
-  visitor: ["expression"],
+  visitor: ['expression'],
-  aliases: ["Immutable"],
+  aliases: ['Immutable'],
   fields: {
     expression: {
-      validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression")
+      validate: (0, _utils.assertNodeType)('Expression', 'JSXEmptyExpression'),
-    }
+    },
-  }
+  },
 });
-defineType("JSXSpreadChild", {
+defineType('JSXSpreadChild', {
-  visitor: ["expression"],
+  visitor: ['expression'],
-  aliases: ["Immutable"],
+  aliases: ['Immutable'],
   fields: {
     expression: {
-      validate: (0, _utils.assertNodeType)("Expression")
+      validate: (0, _utils.assertNodeType)('Expression'),
-    }
+    },
-  }
+  },
 });
-defineType("JSXIdentifier", {
+defineType('JSXIdentifier', {
-  builder: ["name"],
+  builder: ['name'],
   fields: {
     name: {
-      validate: (0, _utils.assertValueType)("string")
+      validate: (0, _utils.assertValueType)('string'),
-    }
+    },
-  }
+  },
 });
-defineType("JSXMemberExpression", {
+defineType('JSXMemberExpression', {
-  visitor: ["object", "property"],
+  visitor: ['object', 'property'],
   fields: {
     object: {
-      validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
+      validate: (0, _utils.assertNodeType)(
+        'JSXMemberExpression',
+        'JSXIdentifier'
+      ),
     },
     property: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier")
+      validate: (0, _utils.assertNodeType)('JSXIdentifier'),
-    }
+    },
-  }
+  },
 });
-defineType("JSXNamespacedName", {
+defineType('JSXNamespacedName', {
-  visitor: ["namespace", "name"],
+  visitor: ['namespace', 'name'],
   fields: {
     namespace: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier")
+      validate: (0, _utils.assertNodeType)('JSXIdentifier'),
     },
     name: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier")
+      validate: (0, _utils.assertNodeType)('JSXIdentifier'),
-    }
+    },
-  }
+  },
 });
-defineType("JSXOpeningElement", {
+defineType('JSXOpeningElement', {
-  builder: ["name", "attributes", "selfClosing"],
+  builder: ['name', 'attributes', 'selfClosing'],
-  visitor: ["name", "attributes"],
+  visitor: ['name', 'attributes'],
-  aliases: ["Immutable"],
+  aliases: ['Immutable'],
   fields: {
     name: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
+      validate: (0, _utils.assertNodeType)(
+        'JSXIdentifier',
+        'JSXMemberExpression',
+        'JSXNamespacedName'
+      ),
     },
     selfClosing: {
-      default: false
+      default: false,
     },
     attributes: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
+      validate: (0, _utils.chain)(
+        (0, _utils.assertValueType)('array'),
+        (0, _utils.assertEach)(
+          (0, _utils.assertNodeType)('JSXAttribute', 'JSXSpreadAttribute')
+        )
+      ),
     },
     typeParameters: {
-      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      validate: (0, _utils.assertNodeType)(
-      optional: true
+        'TypeParameterInstantiation',
-    }
+        'TSTypeParameterInstantiation'
-  }
+      ),
+      optional: true,
+    },
+  },
 });
-defineType("JSXSpreadAttribute", {
+defineType('JSXSpreadAttribute', {
-  visitor: ["argument"],
+  visitor: ['argument'],
   fields: {
     argument: {
-      validate: (0, _utils.assertNodeType)("Expression")
+      validate: (0, _utils.assertNodeType)('Expression'),
-    }
+    },
-  }
+  },
 });
-defineType("JSXText", {
+defineType('JSXText', {
-  aliases: ["Immutable"],
+  aliases: ['Immutable'],
-  builder: ["value"],
+  builder: ['value'],
   fields: {
     value: {
-      validate: (0, _utils.assertValueType)("string")
+      validate: (0, _utils.assertValueType)('string'),
-    }
+    },
-  }
+  },
 });
-defineType("JSXFragment", {
+defineType('JSXFragment', {
-  builder: ["openingFragment", "closingFragment", "children"],
+  builder: ['openingFragment', 'closingFragment', 'children'],
-  visitor: ["openingFragment", "children", "closingFragment"],
+  visitor: ['openingFragment', 'children', 'closingFragment'],
-  aliases: ["Immutable", "Expression"],
+  aliases: ['Immutable', 'Expression'],
   fields: {
     openingFragment: {
-      validate: (0, _utils.assertNodeType)("JSXOpeningFragment")
+      validate: (0, _utils.assertNodeType)('JSXOpeningFragment'),
     },
     closingFragment: {
-      validate: (0, _utils.assertNodeType)("JSXClosingFragment")
+      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")))
+      validate: (0, _utils.chain)(
-    }
+        (0, _utils.assertValueType)('array'),
-  }
+        (0, _utils.assertEach)(
+          (0, _utils.assertNodeType)(
+            'JSXText',
+            'JSXExpressionContainer',
+            'JSXSpreadChild',
+            'JSXElement',
+            'JSXFragment'
+          )
+        )
+      ),
+    },
+  },
 });
-defineType("JSXOpeningFragment", {
+defineType('JSXOpeningFragment', {
-  aliases: ["Immutable"]
+  aliases: ['Immutable'],
 });
-defineType("JSXClosingFragment", {
+defineType('JSXClosingFragment', {
-  aliases: ["Immutable"]
+  aliases: ['Immutable'],
 });
 
 //# sourceMappingURL=jsx.js.map

node_modules/@babel/types/lib/definitions/misc.js

@@ -1,34 +1,34 @@
-"use strict";
+'use strict';
 
-var _utils = require("./utils");
+var _utils = require('./utils');
 
-var _placeholders = require("./placeholders");
+var _placeholders = require('./placeholders');
 
-const defineType = (0, _utils.defineAliasedType)("Miscellaneous");
+const defineType = (0, _utils.defineAliasedType)('Miscellaneous');
 {
-  defineType("Noop", {
+  defineType('Noop', {
-    visitor: []
+    visitor: [],
   });
 }
-defineType("Placeholder", {
+defineType('Placeholder', {
   visitor: [],
-  builder: ["expectedNode", "name"],
+  builder: ['expectedNode', 'name'],
   fields: {
     name: {
-      validate: (0, _utils.assertNodeType)("Identifier")
+      validate: (0, _utils.assertNodeType)('Identifier'),
     },
     expectedNode: {
-      validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS)
+      validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS),
-    }
+    },
-  }
+  },
 });
-defineType("V8IntrinsicIdentifier", {
+defineType('V8IntrinsicIdentifier', {
-  builder: ["name"],
+  builder: ['name'],
   fields: {
     name: {
-      validate: (0, _utils.assertValueType)("string")
+      validate: (0, _utils.assertValueType)('string'),
-    }
+    },
-  }
+  },
 });
 
 //# sourceMappingURL=misc.js.map

node_modules/@babel/types/lib/definitions/placeholders.js

@@ -1,17 +1,29 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
-exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0;
+exports.PLACEHOLDERS_FLIPPED_ALIAS =
+  exports.PLACEHOLDERS_ALIAS =
+  exports.PLACEHOLDERS =
+    void 0;
 
-var _utils = require("./utils");
+var _utils = require('./utils');
 
-const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
+const PLACEHOLDERS = [
+  'Identifier',
+  'StringLiteral',
+  'Expression',
+  'Statement',
+  'Declaration',
+  'BlockStatement',
+  'ClassBody',
+  'Pattern',
+];
 exports.PLACEHOLDERS = PLACEHOLDERS;
 const PLACEHOLDERS_ALIAS = {
-  Declaration: ["Statement"],
+  Declaration: ['Statement'],
-  Pattern: ["PatternLike", "LVal"]
+  Pattern: ['PatternLike', 'LVal'],
 };
 exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS;
 
@@ -22,8 +34,8 @@ for (const type of PLACEHOLDERS) {
 
 const PLACEHOLDERS_FLIPPED_ALIAS = {};
 exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS;
-Object.keys(PLACEHOLDERS_ALIAS).forEach(type => {
+Object.keys(PLACEHOLDERS_ALIAS).forEach((type) => {
-  PLACEHOLDERS_ALIAS[type].forEach(alias => {
+  PLACEHOLDERS_ALIAS[type].forEach((alias) => {
     if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {
       PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];
     }

node_modules/@babel/types/lib/definitions/typescript.js

@@ -1,497 +1,589 @@
-"use strict";
+'use strict';
 
-var _utils = require("./utils");
+var _utils = require('./utils');
 
-var _core = require("./core");
+var _core = require('./core');
 
-var _is = require("../validators/is");
+var _is = require('../validators/is');
 
-const defineType = (0, _utils.defineAliasedType)("TypeScript");
+const defineType = (0, _utils.defineAliasedType)('TypeScript');
-const bool = (0, _utils.assertValueType)("boolean");
+const bool = (0, _utils.assertValueType)('boolean');
 
 const tSFunctionTypeAnnotationCommon = () => ({
   returnType: {
-    validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
+    validate: (0, _utils.assertNodeType)('TSTypeAnnotation', 'Noop'),
-    optional: true
+    optional: true,
   },
   typeParameters: {
-    validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
+    validate: (0, _utils.assertNodeType)('TSTypeParameterDeclaration', 'Noop'),
-    optional: true
+    optional: true,
-  }
+  },
 });
 
-defineType("TSParameterProperty", {
+defineType('TSParameterProperty', {
-  aliases: ["LVal"],
+  aliases: ['LVal'],
-  visitor: ["parameter"],
+  visitor: ['parameter'],
   fields: {
     accessibility: {
-      validate: (0, _utils.assertOneOf)("public", "private", "protected"),
+      validate: (0, _utils.assertOneOf)('public', 'private', 'protected'),
-      optional: true
+      optional: true,
     },
     readonly: {
-      validate: (0, _utils.assertValueType)("boolean"),
+      validate: (0, _utils.assertValueType)('boolean'),
-      optional: true
+      optional: true,
     },
     parameter: {
-      validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
+      validate: (0, _utils.assertNodeType)('Identifier', 'AssignmentPattern'),
     },
     override: {
-      validate: (0, _utils.assertValueType)("boolean"),
+      validate: (0, _utils.assertValueType)('boolean'),
-      optional: true
+      optional: true,
     },
     decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+      validate: (0, _utils.chain)(
-      optional: true
+        (0, _utils.assertValueType)('array'),
-    }
+        (0, _utils.assertEach)((0, _utils.assertNodeType)('Decorator'))
-  }
+      ),
+      optional: true,
+    },
+  },
 });
-defineType("TSDeclareFunction", {
+defineType('TSDeclareFunction', {
-  aliases: ["Statement", "Declaration"],
+  aliases: ['Statement', 'Declaration'],
-  visitor: ["id", "typeParameters", "params", "returnType"],
+  visitor: ['id', 'typeParameters', 'params', 'returnType'],
-  fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon())
+  fields: Object.assign(
+    {},
+    (0, _core.functionDeclarationCommon)(),
+    tSFunctionTypeAnnotationCommon()
+  ),
 });
-defineType("TSDeclareMethod", {
+defineType('TSDeclareMethod', {
-  visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
+  visitor: ['decorators', 'key', 'typeParameters', 'params', 'returnType'],
-  fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon())
+  fields: Object.assign(
+    {},
+    (0, _core.classMethodOrDeclareMethodCommon)(),
+    tSFunctionTypeAnnotationCommon()
+  ),
 });
-defineType("TSQualifiedName", {
+defineType('TSQualifiedName', {
-  aliases: ["TSEntityName"],
+  aliases: ['TSEntityName'],
-  visitor: ["left", "right"],
+  visitor: ['left', 'right'],
   fields: {
-    left: (0, _utils.validateType)("TSEntityName"),
+    left: (0, _utils.validateType)('TSEntityName'),
-    right: (0, _utils.validateType)("Identifier")
+    right: (0, _utils.validateType)('Identifier'),
-  }
+  },
 });
 
 const signatureDeclarationCommon = () => ({
-  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+  typeParameters: (0, _utils.validateOptionalType)(
-  ["parameters"]: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
+    'TSTypeParameterDeclaration'
-  ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation")
+  ),
+  ['parameters']: (0, _utils.validateArrayOfType)([
+    'Identifier',
+    'RestElement',
+  ]),
+  ['typeAnnotation']: (0, _utils.validateOptionalType)('TSTypeAnnotation'),
 });
 
 const callConstructSignatureDeclaration = {
-  aliases: ["TSTypeElement"],
+  aliases: ['TSTypeElement'],
-  visitor: ["typeParameters", "parameters", "typeAnnotation"],
+  visitor: ['typeParameters', 'parameters', 'typeAnnotation'],
-  fields: signatureDeclarationCommon()
+  fields: signatureDeclarationCommon(),
 };
-defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
+defineType('TSCallSignatureDeclaration', callConstructSignatureDeclaration);
-defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
+defineType(
+  'TSConstructSignatureDeclaration',
+  callConstructSignatureDeclaration
+);
 
 const namedTypeElementCommon = () => ({
-  key: (0, _utils.validateType)("Expression"),
+  key: (0, _utils.validateType)('Expression'),
   computed: {
-    default: false
+    default: false,
   },
-  optional: (0, _utils.validateOptional)(bool)
+  optional: (0, _utils.validateOptional)(bool),
 });
 
-defineType("TSPropertySignature", {
+defineType('TSPropertySignature', {
-  aliases: ["TSTypeElement"],
+  aliases: ['TSTypeElement'],
-  visitor: ["key", "typeAnnotation", "initializer"],
+  visitor: ['key', 'typeAnnotation', 'initializer'],
   fields: Object.assign({}, namedTypeElementCommon(), {
     readonly: (0, _utils.validateOptional)(bool),
-    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+    typeAnnotation: (0, _utils.validateOptionalType)('TSTypeAnnotation'),
-    initializer: (0, _utils.validateOptionalType)("Expression"),
+    initializer: (0, _utils.validateOptionalType)('Expression'),
     kind: {
-      validate: (0, _utils.assertOneOf)("get", "set")
+      validate: (0, _utils.assertOneOf)('get', 'set'),
-    }
+    },
-  })
+  }),
 });
-defineType("TSMethodSignature", {
+defineType('TSMethodSignature', {
-  aliases: ["TSTypeElement"],
+  aliases: ['TSTypeElement'],
-  visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
+  visitor: ['key', 'typeParameters', 'parameters', 'typeAnnotation'],
-  fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), {
+  fields: Object.assign(
+    {},
+    signatureDeclarationCommon(),
+    namedTypeElementCommon(),
+    {
       kind: {
-      validate: (0, _utils.assertOneOf)("method", "get", "set")
+        validate: (0, _utils.assertOneOf)('method', 'get', 'set'),
+      },
     }
-  })
+  ),
 });
-defineType("TSIndexSignature", {
+defineType('TSIndexSignature', {
-  aliases: ["TSTypeElement"],
+  aliases: ['TSTypeElement'],
-  visitor: ["parameters", "typeAnnotation"],
+  visitor: ['parameters', 'typeAnnotation'],
   fields: {
     readonly: (0, _utils.validateOptional)(bool),
     static: (0, _utils.validateOptional)(bool),
-    parameters: (0, _utils.validateArrayOfType)("Identifier"),
+    parameters: (0, _utils.validateArrayOfType)('Identifier'),
-    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
+    typeAnnotation: (0, _utils.validateOptionalType)('TSTypeAnnotation'),
-  }
+  },
 });
-const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
+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"],
+    aliases: ['TSType', 'TSBaseType'],
     visitor: [],
-    fields: {}
+    fields: {},
   });
 }
 
-defineType("TSThisType", {
+defineType('TSThisType', {
-  aliases: ["TSType", "TSBaseType"],
+  aliases: ['TSType', 'TSBaseType'],
   visitor: [],
-  fields: {}
+  fields: {},
 });
 const fnOrCtrBase = {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["typeParameters", "parameters", "typeAnnotation"]
+  visitor: ['typeParameters', 'parameters', 'typeAnnotation'],
 };
-defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, {
+defineType(
-  fields: signatureDeclarationCommon()
+  'TSFunctionType',
-}));
+  Object.assign({}, fnOrCtrBase, {
-defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, {
+    fields: signatureDeclarationCommon(),
-  fields: Object.assign({}, signatureDeclarationCommon(), {
-    abstract: (0, _utils.validateOptional)(bool)
   })
-}));
+);
-defineType("TSTypeReference", {
+defineType(
-  aliases: ["TSType"],
+  'TSConstructorType',
-  visitor: ["typeName", "typeParameters"],
+  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"),
+    typeName: (0, _utils.validateType)('TSEntityName'),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+    typeParameters: (0, _utils.validateOptionalType)(
-  }
+      'TSTypeParameterInstantiation'
+    ),
+  },
 });
-defineType("TSTypePredicate", {
+defineType('TSTypePredicate', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["parameterName", "typeAnnotation"],
+  visitor: ['parameterName', 'typeAnnotation'],
-  builder: ["parameterName", "typeAnnotation", "asserts"],
+  builder: ['parameterName', 'typeAnnotation', 'asserts'],
   fields: {
-    parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
+    parameterName: (0, _utils.validateType)(['Identifier', 'TSThisType']),
-    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+    typeAnnotation: (0, _utils.validateOptionalType)('TSTypeAnnotation'),
-    asserts: (0, _utils.validateOptional)(bool)
+    asserts: (0, _utils.validateOptional)(bool),
-  }
+  },
 });
-defineType("TSTypeQuery", {
+defineType('TSTypeQuery', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["exprName", "typeParameters"],
+  visitor: ['exprName', 'typeParameters'],
   fields: {
-    exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"]),
+    exprName: (0, _utils.validateType)(['TSEntityName', 'TSImportType']),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+    typeParameters: (0, _utils.validateOptionalType)(
-  }
+      'TSTypeParameterInstantiation'
+    ),
+  },
 });
-defineType("TSTypeLiteral", {
+defineType('TSTypeLiteral', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["members"],
+  visitor: ['members'],
   fields: {
-    members: (0, _utils.validateArrayOfType)("TSTypeElement")
+    members: (0, _utils.validateArrayOfType)('TSTypeElement'),
-  }
+  },
 });
-defineType("TSArrayType", {
+defineType('TSArrayType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["elementType"],
+  visitor: ['elementType'],
   fields: {
-    elementType: (0, _utils.validateType)("TSType")
+    elementType: (0, _utils.validateType)('TSType'),
-  }
+  },
 });
-defineType("TSTupleType", {
+defineType('TSTupleType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["elementTypes"],
+  visitor: ['elementTypes'],
   fields: {
-    elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
+    elementTypes: (0, _utils.validateArrayOfType)([
-  }
+      'TSType',
+      'TSNamedTupleMember',
+    ]),
+  },
 });
-defineType("TSOptionalType", {
+defineType('TSOptionalType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["typeAnnotation"],
+  visitor: ['typeAnnotation'],
   fields: {
-    typeAnnotation: (0, _utils.validateType)("TSType")
+    typeAnnotation: (0, _utils.validateType)('TSType'),
-  }
+  },
 });
-defineType("TSRestType", {
+defineType('TSRestType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["typeAnnotation"],
+  visitor: ['typeAnnotation'],
   fields: {
-    typeAnnotation: (0, _utils.validateType)("TSType")
+    typeAnnotation: (0, _utils.validateType)('TSType'),
-  }
+  },
 });
-defineType("TSNamedTupleMember", {
+defineType('TSNamedTupleMember', {
-  visitor: ["label", "elementType"],
+  visitor: ['label', 'elementType'],
-  builder: ["label", "elementType", "optional"],
+  builder: ['label', 'elementType', 'optional'],
   fields: {
-    label: (0, _utils.validateType)("Identifier"),
+    label: (0, _utils.validateType)('Identifier'),
     optional: {
       validate: bool,
-      default: false
+      default: false,
+    },
+    elementType: (0, _utils.validateType)('TSType'),
   },
-    elementType: (0, _utils.validateType)("TSType")
-  }
 });
 const unionOrIntersection = {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["types"],
+  visitor: ['types'],
   fields: {
-    types: (0, _utils.validateArrayOfType)("TSType")
+    types: (0, _utils.validateArrayOfType)('TSType'),
-  }
+  },
 };
-defineType("TSUnionType", unionOrIntersection);
+defineType('TSUnionType', unionOrIntersection);
-defineType("TSIntersectionType", unionOrIntersection);
+defineType('TSIntersectionType', unionOrIntersection);
-defineType("TSConditionalType", {
+defineType('TSConditionalType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["checkType", "extendsType", "trueType", "falseType"],
+  visitor: ['checkType', 'extendsType', 'trueType', 'falseType'],
   fields: {
-    checkType: (0, _utils.validateType)("TSType"),
+    checkType: (0, _utils.validateType)('TSType'),
-    extendsType: (0, _utils.validateType)("TSType"),
+    extendsType: (0, _utils.validateType)('TSType'),
-    trueType: (0, _utils.validateType)("TSType"),
+    trueType: (0, _utils.validateType)('TSType'),
-    falseType: (0, _utils.validateType)("TSType")
+    falseType: (0, _utils.validateType)('TSType'),
-  }
+  },
 });
-defineType("TSInferType", {
+defineType('TSInferType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["typeParameter"],
+  visitor: ['typeParameter'],
   fields: {
-    typeParameter: (0, _utils.validateType)("TSTypeParameter")
+    typeParameter: (0, _utils.validateType)('TSTypeParameter'),
-  }
+  },
 });
-defineType("TSParenthesizedType", {
+defineType('TSParenthesizedType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["typeAnnotation"],
+  visitor: ['typeAnnotation'],
   fields: {
-    typeAnnotation: (0, _utils.validateType)("TSType")
+    typeAnnotation: (0, _utils.validateType)('TSType'),
-  }
+  },
 });
-defineType("TSTypeOperator", {
+defineType('TSTypeOperator', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["typeAnnotation"],
+  visitor: ['typeAnnotation'],
   fields: {
-    operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    operator: (0, _utils.validate)((0, _utils.assertValueType)('string')),
-    typeAnnotation: (0, _utils.validateType)("TSType")
+    typeAnnotation: (0, _utils.validateType)('TSType'),
-  }
+  },
 });
-defineType("TSIndexedAccessType", {
+defineType('TSIndexedAccessType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["objectType", "indexType"],
+  visitor: ['objectType', 'indexType'],
   fields: {
-    objectType: (0, _utils.validateType)("TSType"),
+    objectType: (0, _utils.validateType)('TSType'),
-    indexType: (0, _utils.validateType)("TSType")
+    indexType: (0, _utils.validateType)('TSType'),
-  }
+  },
 });
-defineType("TSMappedType", {
+defineType('TSMappedType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["typeParameter", "typeAnnotation", "nameType"],
+  visitor: ['typeParameter', 'typeAnnotation', 'nameType'],
   fields: {
-    readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")),
+    readonly: (0, _utils.validateOptional)(
-    typeParameter: (0, _utils.validateType)("TSTypeParameter"),
+      (0, _utils.assertOneOf)(true, false, '+', '-')
-    optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")),
+    ),
-    typeAnnotation: (0, _utils.validateOptionalType)("TSType"),
+    typeParameter: (0, _utils.validateType)('TSTypeParameter'),
-    nameType: (0, _utils.validateOptionalType)("TSType")
+    optional: (0, _utils.validateOptional)(
-  }
+      (0, _utils.assertOneOf)(true, false, '+', '-')
+    ),
+    typeAnnotation: (0, _utils.validateOptionalType)('TSType'),
+    nameType: (0, _utils.validateOptionalType)('TSType'),
+  },
 });
-defineType("TSLiteralType", {
+defineType('TSLiteralType', {
-  aliases: ["TSType", "TSBaseType"],
+  aliases: ['TSType', 'TSBaseType'],
-  visitor: ["literal"],
+  visitor: ['literal'],
   fields: {
     literal: {
-      validate: function () {
+      validate: (function () {
-        const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral");
+        const unaryExpression = (0, _utils.assertNodeType)(
-        const unaryOperator = (0, _utils.assertOneOf)("-");
+          'NumericLiteral',
-        const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
+          'BigIntLiteral'
+        );
+        const unaryOperator = (0, _utils.assertOneOf)('-');
+        const literal = (0, _utils.assertNodeType)(
+          'NumericLiteral',
+          'StringLiteral',
+          'BooleanLiteral',
+          'BigIntLiteral',
+          'TemplateLiteral'
+        );
 
         function validator(parent, key, node) {
-          if ((0, _is.default)("UnaryExpression", node)) {
+          if ((0, _is.default)('UnaryExpression', node)) {
-            unaryOperator(node, "operator", node.operator);
+            unaryOperator(node, 'operator', node.operator);
-            unaryExpression(node, "argument", node.argument);
+            unaryExpression(node, 'argument', node.argument);
           } else {
             literal(parent, key, node);
           }
         }
 
-        validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"];
+        validator.oneOfNodeTypes = [
+          'NumericLiteral',
+          'StringLiteral',
+          'BooleanLiteral',
+          'BigIntLiteral',
+          'TemplateLiteral',
+          'UnaryExpression',
+        ];
         return validator;
-      }()
+      })(),
-    }
+    },
-  }
+  },
 });
-defineType("TSExpressionWithTypeArguments", {
+defineType('TSExpressionWithTypeArguments', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["expression", "typeParameters"],
+  visitor: ['expression', 'typeParameters'],
   fields: {
-    expression: (0, _utils.validateType)("TSEntityName"),
+    expression: (0, _utils.validateType)('TSEntityName'),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+    typeParameters: (0, _utils.validateOptionalType)(
-  }
+      'TSTypeParameterInstantiation'
+    ),
+  },
 });
-defineType("TSInterfaceDeclaration", {
+defineType('TSInterfaceDeclaration', {
-  aliases: ["Statement", "Declaration"],
+  aliases: ['Statement', 'Declaration'],
-  visitor: ["id", "typeParameters", "extends", "body"],
+  visitor: ['id', 'typeParameters', 'extends', 'body'],
   fields: {
     declare: (0, _utils.validateOptional)(bool),
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    typeParameters: (0, _utils.validateOptionalType)(
-    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
+      'TSTypeParameterDeclaration'
-    body: (0, _utils.validateType)("TSInterfaceBody")
+    ),
-  }
+    extends: (0, _utils.validateOptional)(
+      (0, _utils.arrayOfType)('TSExpressionWithTypeArguments')
+    ),
+    body: (0, _utils.validateType)('TSInterfaceBody'),
+  },
 });
-defineType("TSInterfaceBody", {
+defineType('TSInterfaceBody', {
-  visitor: ["body"],
+  visitor: ['body'],
   fields: {
-    body: (0, _utils.validateArrayOfType)("TSTypeElement")
+    body: (0, _utils.validateArrayOfType)('TSTypeElement'),
-  }
+  },
 });
-defineType("TSTypeAliasDeclaration", {
+defineType('TSTypeAliasDeclaration', {
-  aliases: ["Statement", "Declaration"],
+  aliases: ['Statement', 'Declaration'],
-  visitor: ["id", "typeParameters", "typeAnnotation"],
+  visitor: ['id', 'typeParameters', 'typeAnnotation'],
   fields: {
     declare: (0, _utils.validateOptional)(bool),
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    typeParameters: (0, _utils.validateOptionalType)(
-    typeAnnotation: (0, _utils.validateType)("TSType")
+      'TSTypeParameterDeclaration'
-  }
+    ),
+    typeAnnotation: (0, _utils.validateType)('TSType'),
+  },
 });
-defineType("TSInstantiationExpression", {
+defineType('TSInstantiationExpression', {
-  aliases: ["Expression"],
+  aliases: ['Expression'],
-  visitor: ["expression", "typeParameters"],
+  visitor: ['expression', 'typeParameters'],
   fields: {
-    expression: (0, _utils.validateType)("Expression"),
+    expression: (0, _utils.validateType)('Expression'),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+    typeParameters: (0, _utils.validateOptionalType)(
-  }
+      'TSTypeParameterInstantiation'
+    ),
+  },
 });
-defineType("TSAsExpression", {
+defineType('TSAsExpression', {
-  aliases: ["Expression", "LVal", "PatternLike"],
+  aliases: ['Expression', 'LVal', 'PatternLike'],
-  visitor: ["expression", "typeAnnotation"],
+  visitor: ['expression', 'typeAnnotation'],
   fields: {
-    expression: (0, _utils.validateType)("Expression"),
+    expression: (0, _utils.validateType)('Expression'),
-    typeAnnotation: (0, _utils.validateType)("TSType")
+    typeAnnotation: (0, _utils.validateType)('TSType'),
-  }
+  },
 });
-defineType("TSTypeAssertion", {
+defineType('TSTypeAssertion', {
-  aliases: ["Expression", "LVal", "PatternLike"],
+  aliases: ['Expression', 'LVal', 'PatternLike'],
-  visitor: ["typeAnnotation", "expression"],
+  visitor: ['typeAnnotation', 'expression'],
   fields: {
-    typeAnnotation: (0, _utils.validateType)("TSType"),
+    typeAnnotation: (0, _utils.validateType)('TSType'),
-    expression: (0, _utils.validateType)("Expression")
+    expression: (0, _utils.validateType)('Expression'),
-  }
+  },
 });
-defineType("TSEnumDeclaration", {
+defineType('TSEnumDeclaration', {
-  aliases: ["Statement", "Declaration"],
+  aliases: ['Statement', 'Declaration'],
-  visitor: ["id", "members"],
+  visitor: ['id', 'members'],
   fields: {
     declare: (0, _utils.validateOptional)(bool),
     const: (0, _utils.validateOptional)(bool),
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    members: (0, _utils.validateArrayOfType)("TSEnumMember"),
+    members: (0, _utils.validateArrayOfType)('TSEnumMember'),
-    initializer: (0, _utils.validateOptionalType)("Expression")
+    initializer: (0, _utils.validateOptionalType)('Expression'),
-  }
+  },
 });
-defineType("TSEnumMember", {
+defineType('TSEnumMember', {
-  visitor: ["id", "initializer"],
+  visitor: ['id', 'initializer'],
   fields: {
-    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    id: (0, _utils.validateType)(['Identifier', 'StringLiteral']),
-    initializer: (0, _utils.validateOptionalType)("Expression")
+    initializer: (0, _utils.validateOptionalType)('Expression'),
-  }
+  },
 });
-defineType("TSModuleDeclaration", {
+defineType('TSModuleDeclaration', {
-  aliases: ["Statement", "Declaration"],
+  aliases: ['Statement', 'Declaration'],
-  visitor: ["id", "body"],
+  visitor: ['id', 'body'],
   fields: {
     declare: (0, _utils.validateOptional)(bool),
     global: (0, _utils.validateOptional)(bool),
-    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    id: (0, _utils.validateType)(['Identifier', 'StringLiteral']),
-    body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
+    body: (0, _utils.validateType)(['TSModuleBlock', 'TSModuleDeclaration']),
-  }
+  },
 });
-defineType("TSModuleBlock", {
+defineType('TSModuleBlock', {
-  aliases: ["Scopable", "Block", "BlockParent"],
+  aliases: ['Scopable', 'Block', 'BlockParent'],
-  visitor: ["body"],
+  visitor: ['body'],
   fields: {
-    body: (0, _utils.validateArrayOfType)("Statement")
+    body: (0, _utils.validateArrayOfType)('Statement'),
-  }
+  },
 });
-defineType("TSImportType", {
+defineType('TSImportType', {
-  aliases: ["TSType"],
+  aliases: ['TSType'],
-  visitor: ["argument", "qualifier", "typeParameters"],
+  visitor: ['argument', 'qualifier', 'typeParameters'],
   fields: {
-    argument: (0, _utils.validateType)("StringLiteral"),
+    argument: (0, _utils.validateType)('StringLiteral'),
-    qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
+    qualifier: (0, _utils.validateOptionalType)('TSEntityName'),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
+    typeParameters: (0, _utils.validateOptionalType)(
-  }
+      'TSTypeParameterInstantiation'
+    ),
+  },
 });
-defineType("TSImportEqualsDeclaration", {
+defineType('TSImportEqualsDeclaration', {
-  aliases: ["Statement"],
+  aliases: ['Statement'],
-  visitor: ["id", "moduleReference"],
+  visitor: ['id', 'moduleReference'],
   fields: {
     isExport: (0, _utils.validate)(bool),
-    id: (0, _utils.validateType)("Identifier"),
+    id: (0, _utils.validateType)('Identifier'),
-    moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]),
+    moduleReference: (0, _utils.validateType)([
+      'TSEntityName',
+      'TSExternalModuleReference',
+    ]),
     importKind: {
-      validate: (0, _utils.assertOneOf)("type", "value"),
+      validate: (0, _utils.assertOneOf)('type', 'value'),
-      optional: true
+      optional: true,
-    }
+    },
-  }
+  },
 });
-defineType("TSExternalModuleReference", {
+defineType('TSExternalModuleReference', {
-  visitor: ["expression"],
+  visitor: ['expression'],
   fields: {
-    expression: (0, _utils.validateType)("StringLiteral")
+    expression: (0, _utils.validateType)('StringLiteral'),
-  }
+  },
 });
-defineType("TSNonNullExpression", {
+defineType('TSNonNullExpression', {
-  aliases: ["Expression", "LVal", "PatternLike"],
+  aliases: ['Expression', 'LVal', 'PatternLike'],
-  visitor: ["expression"],
+  visitor: ['expression'],
   fields: {
-    expression: (0, _utils.validateType)("Expression")
+    expression: (0, _utils.validateType)('Expression'),
-  }
+  },
 });
-defineType("TSExportAssignment", {
+defineType('TSExportAssignment', {
-  aliases: ["Statement"],
+  aliases: ['Statement'],
-  visitor: ["expression"],
+  visitor: ['expression'],
   fields: {
-    expression: (0, _utils.validateType)("Expression")
+    expression: (0, _utils.validateType)('Expression'),
-  }
+  },
 });
-defineType("TSNamespaceExportDeclaration", {
+defineType('TSNamespaceExportDeclaration', {
-  aliases: ["Statement"],
+  aliases: ['Statement'],
-  visitor: ["id"],
+  visitor: ['id'],
   fields: {
-    id: (0, _utils.validateType)("Identifier")
+    id: (0, _utils.validateType)('Identifier'),
-  }
+  },
 });
-defineType("TSTypeAnnotation", {
+defineType('TSTypeAnnotation', {
-  visitor: ["typeAnnotation"],
+  visitor: ['typeAnnotation'],
   fields: {
     typeAnnotation: {
-      validate: (0, _utils.assertNodeType)("TSType")
+      validate: (0, _utils.assertNodeType)('TSType'),
-    }
+    },
-  }
+  },
 });
-defineType("TSTypeParameterInstantiation", {
+defineType('TSTypeParameterInstantiation', {
-  visitor: ["params"],
+  visitor: ['params'],
   fields: {
     params: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
+      validate: (0, _utils.chain)(
-    }
+        (0, _utils.assertValueType)('array'),
-  }
+        (0, _utils.assertEach)((0, _utils.assertNodeType)('TSType'))
+      ),
+    },
+  },
 });
-defineType("TSTypeParameterDeclaration", {
+defineType('TSTypeParameterDeclaration', {
-  visitor: ["params"],
+  visitor: ['params'],
   fields: {
     params: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
+      validate: (0, _utils.chain)(
-    }
+        (0, _utils.assertValueType)('array'),
-  }
+        (0, _utils.assertEach)((0, _utils.assertNodeType)('TSTypeParameter'))
+      ),
+    },
+  },
 });
-defineType("TSTypeParameter", {
+defineType('TSTypeParameter', {
-  builder: ["constraint", "default", "name"],
+  builder: ['constraint', 'default', 'name'],
-  visitor: ["constraint", "default"],
+  visitor: ['constraint', 'default'],
   fields: {
     name: {
-      validate: (0, _utils.assertValueType)("string")
+      validate: (0, _utils.assertValueType)('string'),
     },
     in: {
-      validate: (0, _utils.assertValueType)("boolean"),
+      validate: (0, _utils.assertValueType)('boolean'),
-      optional: true
+      optional: true,
     },
     out: {
-      validate: (0, _utils.assertValueType)("boolean"),
+      validate: (0, _utils.assertValueType)('boolean'),
-      optional: true
+      optional: true,
     },
     constraint: {
-      validate: (0, _utils.assertNodeType)("TSType"),
+      validate: (0, _utils.assertNodeType)('TSType'),
-      optional: true
+      optional: true,
     },
     default: {
-      validate: (0, _utils.assertNodeType)("TSType"),
+      validate: (0, _utils.assertNodeType)('TSType'),
-      optional: true
+      optional: true,
-    }
+    },
-  }
+  },
 });
 
 //# sourceMappingURL=typescript.js.map

node_modules/@babel/types/lib/definitions/utils.js

@@ -1,9 +1,16 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  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.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;
@@ -23,9 +30,9 @@ exports.validateOptional = validateOptional;
 exports.validateOptionalType = validateOptionalType;
 exports.validateType = validateType;
 
-var _is = require("../validators/is");
+var _is = require('../validators/is');
 
-var _validate = require("../validators/validate");
+var _validate = require('../validators/validate');
 
 const VISITOR_KEYS = {};
 exports.VISITOR_KEYS = VISITOR_KEYS;
@@ -44,9 +51,9 @@ exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
 
 function getType(val) {
   if (Array.isArray(val)) {
-    return "array";
+    return 'array';
   } else if (val === null) {
-    return "null";
+    return 'null';
   } else {
     return typeof val;
   }
@@ -54,12 +61,14 @@ function getType(val) {
 
 function validate(validate) {
   return {
-    validate
+    validate,
   };
 }
 
 function typeIs(typeName) {
-  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
+  return typeof typeName === 'string' ?
+      assertNodeType(typeName)
+    : assertNodeType(...typeName);
 }
 
 function validateType(typeName) {
@@ -69,19 +78,19 @@ function validateType(typeName) {
 function validateOptional(validate) {
   return {
     validate,
-    optional: true
+    optional: true,
   };
 }
 
 function validateOptionalType(typeName) {
   return {
     validate: typeIs(typeName),
-    optional: true
+    optional: true,
   };
 }
 
 function arrayOf(elementType) {
-  return chain(assertValueType("array"), assertEach(elementType));
+  return chain(assertValueType('array'), assertEach(elementType));
 }
 
 function arrayOfType(typeName) {
@@ -100,7 +109,8 @@ function assertEach(callback) {
       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);
+      if (process.env.BABEL_TYPES_8_BREAKING)
+        (0, _validate.validateChild)(node, subkey, v);
     }
   }
 
@@ -111,7 +121,9 @@ function assertEach(callback) {
 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)}`);
+      throw new TypeError(
+        `Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`
+      );
     }
   }
 
@@ -128,7 +140,9 @@ function assertNodeType(...types) {
       }
     }
 
-    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)}`);
+    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;
@@ -144,7 +158,9 @@ function assertNodeOrValueType(...types) {
       }
     }
 
-    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)}`);
+    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;
@@ -156,7 +172,9 @@ function assertValueType(type) {
     const valid = getType(val) === type;
 
     if (!valid) {
-      throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
+      throw new TypeError(
+        `Property ${key} expected type of ${type} but got ${getType(val)}`
+      );
     }
   }
 
@@ -170,7 +188,12 @@ function assertShape(shape) {
 
     for (const property of Object.keys(shape)) {
       try {
-        (0, _validate.validateField)(node, property, val[property], shape[property]);
+        (0, _validate.validateField)(
+          node,
+          property,
+          val[property],
+          shape[property]
+        );
       } catch (error) {
         if (error instanceof TypeError) {
           errors.push(error.message);
@@ -182,7 +205,9 @@ function assertShape(shape) {
     }
 
     if (errors.length) {
-      throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`);
+      throw new TypeError(
+        `Property ${key} of ${node.type} expected to have the following:\n${errors.join('\n')}`
+      );
     }
   }
 
@@ -197,17 +222,15 @@ function assertOptionalChainStart() {
     let current = node;
 
     while (node) {
-      const {
+      const { type } = current;
-        type
-      } = current;
 
-      if (type === "OptionalCallExpression") {
+      if (type === 'OptionalCallExpression') {
         if (current.optional) return;
         current = current.callee;
         continue;
       }
 
-      if (type === "OptionalMemberExpression") {
+      if (type === 'OptionalMemberExpression') {
         if (current.optional) return;
         current = current.object;
         continue;
@@ -216,7 +239,9 @@ function assertOptionalChainStart() {
       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}`);
+    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;
@@ -231,15 +256,30 @@ function chain(...fns) {
 
   validate.chainOf = fns;
 
-  if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) {
+  if (
-    throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`);
+    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 validTypeOpts = [
-const validFieldKeys = ["default", "optional", "validate"];
+  'aliases',
+  'builder',
+  'deprecatedAlias',
+  'fields',
+  'inherits',
+  'visitor',
+  'validate',
+];
+const validFieldKeys = ['default', 'optional', 'validate'];
 
 function defineAliasedType(...aliases) {
   return (type, opts = {}) => {
@@ -248,19 +288,23 @@ function defineAliasedType(...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();
+      if (opts.inherits)
-      (_defined = defined) != null ? _defined : defined = [];
+        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));
+    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] || {};
+  const inherits = (opts.inherits && store[opts.inherits]) || {};
   let fields = opts.fields;
 
   if (!fields) {
@@ -273,14 +317,18 @@ function defineType(type, opts = {}) {
         const field = inherits.fields[key];
         const def = field.default;
 
-        if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") {
+        if (
-          throw new Error("field defaults can only be primitives or empty arrays currently");
+          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
+          validate: field.validate,
         };
       }
     }
@@ -328,7 +376,7 @@ function defineType(type, opts = {}) {
   BUILDER_KEYS[type] = opts.builder = builder;
   NODE_FIELDS[type] = opts.fields = fields;
   ALIAS_KEYS[type] = opts.aliases = aliases;
-  aliases.forEach(alias => {
+  aliases.forEach((alias) => {
     FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
     FLIPPED_ALIAS_KEYS[alias].push(type);
   });

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

@@ -1,7 +1,7 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 var _exportNames = {
   react: true,
@@ -60,589 +60,589 @@ var _exportNames = {
   isVar: true,
   matchesPattern: true,
   validate: true,
-  buildMatchMemberExpression: true
+  buildMatchMemberExpression: true,
 };
-Object.defineProperty(exports, "addComment", {
+Object.defineProperty(exports, 'addComment', {
   enumerable: true,
   get: function () {
     return _addComment.default;
-  }
+  },
 });
-Object.defineProperty(exports, "addComments", {
+Object.defineProperty(exports, 'addComments', {
   enumerable: true,
   get: function () {
     return _addComments.default;
-  }
+  },
 });
-Object.defineProperty(exports, "appendToMemberExpression", {
+Object.defineProperty(exports, 'appendToMemberExpression', {
   enumerable: true,
   get: function () {
     return _appendToMemberExpression.default;
-  }
+  },
 });
-Object.defineProperty(exports, "assertNode", {
+Object.defineProperty(exports, 'assertNode', {
   enumerable: true,
   get: function () {
     return _assertNode.default;
-  }
+  },
 });
-Object.defineProperty(exports, "buildMatchMemberExpression", {
+Object.defineProperty(exports, 'buildMatchMemberExpression', {
   enumerable: true,
   get: function () {
     return _buildMatchMemberExpression.default;
-  }
+  },
 });
-Object.defineProperty(exports, "clone", {
+Object.defineProperty(exports, 'clone', {
   enumerable: true,
   get: function () {
     return _clone.default;
-  }
+  },
 });
-Object.defineProperty(exports, "cloneDeep", {
+Object.defineProperty(exports, 'cloneDeep', {
   enumerable: true,
   get: function () {
     return _cloneDeep.default;
-  }
+  },
 });
-Object.defineProperty(exports, "cloneDeepWithoutLoc", {
+Object.defineProperty(exports, 'cloneDeepWithoutLoc', {
   enumerable: true,
   get: function () {
     return _cloneDeepWithoutLoc.default;
-  }
+  },
 });
-Object.defineProperty(exports, "cloneNode", {
+Object.defineProperty(exports, 'cloneNode', {
   enumerable: true,
   get: function () {
     return _cloneNode.default;
-  }
+  },
 });
-Object.defineProperty(exports, "cloneWithoutLoc", {
+Object.defineProperty(exports, 'cloneWithoutLoc', {
   enumerable: true,
   get: function () {
     return _cloneWithoutLoc.default;
-  }
+  },
 });
-Object.defineProperty(exports, "createFlowUnionType", {
+Object.defineProperty(exports, 'createFlowUnionType', {
   enumerable: true,
   get: function () {
     return _createFlowUnionType.default;
-  }
+  },
 });
-Object.defineProperty(exports, "createTSUnionType", {
+Object.defineProperty(exports, 'createTSUnionType', {
   enumerable: true,
   get: function () {
     return _createTSUnionType.default;
-  }
+  },
 });
-Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
+Object.defineProperty(exports, 'createTypeAnnotationBasedOnTypeof', {
   enumerable: true,
   get: function () {
     return _createTypeAnnotationBasedOnTypeof.default;
-  }
+  },
 });
-Object.defineProperty(exports, "createUnionTypeAnnotation", {
+Object.defineProperty(exports, 'createUnionTypeAnnotation', {
   enumerable: true,
   get: function () {
     return _createFlowUnionType.default;
-  }
+  },
 });
-Object.defineProperty(exports, "ensureBlock", {
+Object.defineProperty(exports, 'ensureBlock', {
   enumerable: true,
   get: function () {
     return _ensureBlock.default;
-  }
+  },
 });
-Object.defineProperty(exports, "getBindingIdentifiers", {
+Object.defineProperty(exports, 'getBindingIdentifiers', {
   enumerable: true,
   get: function () {
     return _getBindingIdentifiers.default;
-  }
+  },
 });
-Object.defineProperty(exports, "getOuterBindingIdentifiers", {
+Object.defineProperty(exports, 'getOuterBindingIdentifiers', {
   enumerable: true,
   get: function () {
     return _getOuterBindingIdentifiers.default;
-  }
+  },
 });
-Object.defineProperty(exports, "inheritInnerComments", {
+Object.defineProperty(exports, 'inheritInnerComments', {
   enumerable: true,
   get: function () {
     return _inheritInnerComments.default;
-  }
+  },
 });
-Object.defineProperty(exports, "inheritLeadingComments", {
+Object.defineProperty(exports, 'inheritLeadingComments', {
   enumerable: true,
   get: function () {
     return _inheritLeadingComments.default;
-  }
+  },
 });
-Object.defineProperty(exports, "inheritTrailingComments", {
+Object.defineProperty(exports, 'inheritTrailingComments', {
   enumerable: true,
   get: function () {
     return _inheritTrailingComments.default;
-  }
+  },
 });
-Object.defineProperty(exports, "inherits", {
+Object.defineProperty(exports, 'inherits', {
   enumerable: true,
   get: function () {
     return _inherits.default;
-  }
+  },
 });
-Object.defineProperty(exports, "inheritsComments", {
+Object.defineProperty(exports, 'inheritsComments', {
   enumerable: true,
   get: function () {
     return _inheritsComments.default;
-  }
+  },
 });
-Object.defineProperty(exports, "is", {
+Object.defineProperty(exports, 'is', {
   enumerable: true,
   get: function () {
     return _is.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isBinding", {
+Object.defineProperty(exports, 'isBinding', {
   enumerable: true,
   get: function () {
     return _isBinding.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isBlockScoped", {
+Object.defineProperty(exports, 'isBlockScoped', {
   enumerable: true,
   get: function () {
     return _isBlockScoped.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isImmutable", {
+Object.defineProperty(exports, 'isImmutable', {
   enumerable: true,
   get: function () {
     return _isImmutable.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isLet", {
+Object.defineProperty(exports, 'isLet', {
   enumerable: true,
   get: function () {
     return _isLet.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isNode", {
+Object.defineProperty(exports, 'isNode', {
   enumerable: true,
   get: function () {
     return _isNode.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isNodesEquivalent", {
+Object.defineProperty(exports, 'isNodesEquivalent', {
   enumerable: true,
   get: function () {
     return _isNodesEquivalent.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isPlaceholderType", {
+Object.defineProperty(exports, 'isPlaceholderType', {
   enumerable: true,
   get: function () {
     return _isPlaceholderType.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isReferenced", {
+Object.defineProperty(exports, 'isReferenced', {
   enumerable: true,
   get: function () {
     return _isReferenced.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isScope", {
+Object.defineProperty(exports, 'isScope', {
   enumerable: true,
   get: function () {
     return _isScope.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isSpecifierDefault", {
+Object.defineProperty(exports, 'isSpecifierDefault', {
   enumerable: true,
   get: function () {
     return _isSpecifierDefault.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isType", {
+Object.defineProperty(exports, 'isType', {
   enumerable: true,
   get: function () {
     return _isType.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isValidES3Identifier", {
+Object.defineProperty(exports, 'isValidES3Identifier', {
   enumerable: true,
   get: function () {
     return _isValidES3Identifier.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isValidIdentifier", {
+Object.defineProperty(exports, 'isValidIdentifier', {
   enumerable: true,
   get: function () {
     return _isValidIdentifier.default;
-  }
+  },
 });
-Object.defineProperty(exports, "isVar", {
+Object.defineProperty(exports, 'isVar', {
   enumerable: true,
   get: function () {
     return _isVar.default;
-  }
+  },
 });
-Object.defineProperty(exports, "matchesPattern", {
+Object.defineProperty(exports, 'matchesPattern', {
   enumerable: true,
   get: function () {
     return _matchesPattern.default;
-  }
+  },
 });
-Object.defineProperty(exports, "prependToMemberExpression", {
+Object.defineProperty(exports, 'prependToMemberExpression', {
   enumerable: true,
   get: function () {
     return _prependToMemberExpression.default;
-  }
+  },
 });
 exports.react = void 0;
-Object.defineProperty(exports, "removeComments", {
+Object.defineProperty(exports, 'removeComments', {
   enumerable: true,
   get: function () {
     return _removeComments.default;
-  }
+  },
 });
-Object.defineProperty(exports, "removeProperties", {
+Object.defineProperty(exports, 'removeProperties', {
   enumerable: true,
   get: function () {
     return _removeProperties.default;
-  }
+  },
 });
-Object.defineProperty(exports, "removePropertiesDeep", {
+Object.defineProperty(exports, 'removePropertiesDeep', {
   enumerable: true,
   get: function () {
     return _removePropertiesDeep.default;
-  }
+  },
 });
-Object.defineProperty(exports, "removeTypeDuplicates", {
+Object.defineProperty(exports, 'removeTypeDuplicates', {
   enumerable: true,
   get: function () {
     return _removeTypeDuplicates.default;
-  }
+  },
 });
-Object.defineProperty(exports, "shallowEqual", {
+Object.defineProperty(exports, 'shallowEqual', {
   enumerable: true,
   get: function () {
     return _shallowEqual.default;
-  }
+  },
 });
-Object.defineProperty(exports, "toBindingIdentifierName", {
+Object.defineProperty(exports, 'toBindingIdentifierName', {
   enumerable: true,
   get: function () {
     return _toBindingIdentifierName.default;
-  }
+  },
 });
-Object.defineProperty(exports, "toBlock", {
+Object.defineProperty(exports, 'toBlock', {
   enumerable: true,
   get: function () {
     return _toBlock.default;
-  }
+  },
 });
-Object.defineProperty(exports, "toComputedKey", {
+Object.defineProperty(exports, 'toComputedKey', {
   enumerable: true,
   get: function () {
     return _toComputedKey.default;
-  }
+  },
 });
-Object.defineProperty(exports, "toExpression", {
+Object.defineProperty(exports, 'toExpression', {
   enumerable: true,
   get: function () {
     return _toExpression.default;
-  }
+  },
 });
-Object.defineProperty(exports, "toIdentifier", {
+Object.defineProperty(exports, 'toIdentifier', {
   enumerable: true,
   get: function () {
     return _toIdentifier.default;
-  }
+  },
 });
-Object.defineProperty(exports, "toKeyAlias", {
+Object.defineProperty(exports, 'toKeyAlias', {
   enumerable: true,
   get: function () {
     return _toKeyAlias.default;
-  }
+  },
 });
-Object.defineProperty(exports, "toSequenceExpression", {
+Object.defineProperty(exports, 'toSequenceExpression', {
   enumerable: true,
   get: function () {
     return _toSequenceExpression.default;
-  }
+  },
 });
-Object.defineProperty(exports, "toStatement", {
+Object.defineProperty(exports, 'toStatement', {
   enumerable: true,
   get: function () {
     return _toStatement.default;
-  }
+  },
 });
-Object.defineProperty(exports, "traverse", {
+Object.defineProperty(exports, 'traverse', {
   enumerable: true,
   get: function () {
     return _traverse.default;
-  }
+  },
 });
-Object.defineProperty(exports, "traverseFast", {
+Object.defineProperty(exports, 'traverseFast', {
   enumerable: true,
   get: function () {
     return _traverseFast.default;
-  }
+  },
 });
-Object.defineProperty(exports, "validate", {
+Object.defineProperty(exports, 'validate', {
   enumerable: true,
   get: function () {
     return _validate.default;
-  }
+  },
 });
-Object.defineProperty(exports, "valueToNode", {
+Object.defineProperty(exports, 'valueToNode', {
   enumerable: true,
   get: function () {
     return _valueToNode.default;
-  }
+  },
 });
 
-var _isReactComponent = require("./validators/react/isReactComponent");
+var _isReactComponent = require('./validators/react/isReactComponent');
 
-var _isCompatTag = require("./validators/react/isCompatTag");
+var _isCompatTag = require('./validators/react/isCompatTag');
 
-var _buildChildren = require("./builders/react/buildChildren");
+var _buildChildren = require('./builders/react/buildChildren');
 
-var _assertNode = require("./asserts/assertNode");
+var _assertNode = require('./asserts/assertNode');
 
-var _generated = require("./asserts/generated");
+var _generated = require('./asserts/generated');
 
 Object.keys(_generated).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  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 _createTypeAnnotationBasedOnTypeof = require('./builders/flow/createTypeAnnotationBasedOnTypeof');
 
-var _createFlowUnionType = require("./builders/flow/createFlowUnionType");
+var _createFlowUnionType = require('./builders/flow/createFlowUnionType');
 
-var _createTSUnionType = require("./builders/typescript/createTSUnionType");
+var _createTSUnionType = require('./builders/typescript/createTSUnionType');
 
-var _generated2 = require("./builders/generated");
+var _generated2 = require('./builders/generated');
 
 Object.keys(_generated2).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  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");
+var _uppercase = require('./builders/generated/uppercase');
 
 Object.keys(_uppercase).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  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 _cloneNode = require('./clone/cloneNode');
 
-var _clone = require("./clone/clone");
+var _clone = require('./clone/clone');
 
-var _cloneDeep = require("./clone/cloneDeep");
+var _cloneDeep = require('./clone/cloneDeep');
 
-var _cloneDeepWithoutLoc = require("./clone/cloneDeepWithoutLoc");
+var _cloneDeepWithoutLoc = require('./clone/cloneDeepWithoutLoc');
 
-var _cloneWithoutLoc = require("./clone/cloneWithoutLoc");
+var _cloneWithoutLoc = require('./clone/cloneWithoutLoc');
 
-var _addComment = require("./comments/addComment");
+var _addComment = require('./comments/addComment');
 
-var _addComments = require("./comments/addComments");
+var _addComments = require('./comments/addComments');
 
-var _inheritInnerComments = require("./comments/inheritInnerComments");
+var _inheritInnerComments = require('./comments/inheritInnerComments');
 
-var _inheritLeadingComments = require("./comments/inheritLeadingComments");
+var _inheritLeadingComments = require('./comments/inheritLeadingComments');
 
-var _inheritsComments = require("./comments/inheritsComments");
+var _inheritsComments = require('./comments/inheritsComments');
 
-var _inheritTrailingComments = require("./comments/inheritTrailingComments");
+var _inheritTrailingComments = require('./comments/inheritTrailingComments');
 
-var _removeComments = require("./comments/removeComments");
+var _removeComments = require('./comments/removeComments');
 
-var _generated3 = require("./constants/generated");
+var _generated3 = require('./constants/generated');
 
 Object.keys(_generated3).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  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");
+var _constants = require('./constants');
 
 Object.keys(_constants).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  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 _ensureBlock = require('./converters/ensureBlock');
 
-var _toBindingIdentifierName = require("./converters/toBindingIdentifierName");
+var _toBindingIdentifierName = require('./converters/toBindingIdentifierName');
 
-var _toBlock = require("./converters/toBlock");
+var _toBlock = require('./converters/toBlock');
 
-var _toComputedKey = require("./converters/toComputedKey");
+var _toComputedKey = require('./converters/toComputedKey');
 
-var _toExpression = require("./converters/toExpression");
+var _toExpression = require('./converters/toExpression');
 
-var _toIdentifier = require("./converters/toIdentifier");
+var _toIdentifier = require('./converters/toIdentifier');
 
-var _toKeyAlias = require("./converters/toKeyAlias");
+var _toKeyAlias = require('./converters/toKeyAlias');
 
-var _toSequenceExpression = require("./converters/toSequenceExpression");
+var _toSequenceExpression = require('./converters/toSequenceExpression');
 
-var _toStatement = require("./converters/toStatement");
+var _toStatement = require('./converters/toStatement');
 
-var _valueToNode = require("./converters/valueToNode");
+var _valueToNode = require('./converters/valueToNode');
 
-var _definitions = require("./definitions");
+var _definitions = require('./definitions');
 
 Object.keys(_definitions).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  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 _appendToMemberExpression = require('./modifications/appendToMemberExpression');
 
-var _inherits = require("./modifications/inherits");
+var _inherits = require('./modifications/inherits');
 
-var _prependToMemberExpression = require("./modifications/prependToMemberExpression");
+var _prependToMemberExpression = require('./modifications/prependToMemberExpression');
 
-var _removeProperties = require("./modifications/removeProperties");
+var _removeProperties = require('./modifications/removeProperties');
 
-var _removePropertiesDeep = require("./modifications/removePropertiesDeep");
+var _removePropertiesDeep = require('./modifications/removePropertiesDeep');
 
-var _removeTypeDuplicates = require("./modifications/flow/removeTypeDuplicates");
+var _removeTypeDuplicates = require('./modifications/flow/removeTypeDuplicates');
 
-var _getBindingIdentifiers = require("./retrievers/getBindingIdentifiers");
+var _getBindingIdentifiers = require('./retrievers/getBindingIdentifiers');
 
-var _getOuterBindingIdentifiers = require("./retrievers/getOuterBindingIdentifiers");
+var _getOuterBindingIdentifiers = require('./retrievers/getOuterBindingIdentifiers');
 
-var _traverse = require("./traverse/traverse");
+var _traverse = require('./traverse/traverse');
 
 Object.keys(_traverse).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  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 _traverseFast = require('./traverse/traverseFast');
 
-var _shallowEqual = require("./utils/shallowEqual");
+var _shallowEqual = require('./utils/shallowEqual');
 
-var _is = require("./validators/is");
+var _is = require('./validators/is');
 
-var _isBinding = require("./validators/isBinding");
+var _isBinding = require('./validators/isBinding');
 
-var _isBlockScoped = require("./validators/isBlockScoped");
+var _isBlockScoped = require('./validators/isBlockScoped');
 
-var _isImmutable = require("./validators/isImmutable");
+var _isImmutable = require('./validators/isImmutable');
 
-var _isLet = require("./validators/isLet");
+var _isLet = require('./validators/isLet');
 
-var _isNode = require("./validators/isNode");
+var _isNode = require('./validators/isNode');
 
-var _isNodesEquivalent = require("./validators/isNodesEquivalent");
+var _isNodesEquivalent = require('./validators/isNodesEquivalent');
 
-var _isPlaceholderType = require("./validators/isPlaceholderType");
+var _isPlaceholderType = require('./validators/isPlaceholderType');
 
-var _isReferenced = require("./validators/isReferenced");
+var _isReferenced = require('./validators/isReferenced');
 
-var _isScope = require("./validators/isScope");
+var _isScope = require('./validators/isScope');
 
-var _isSpecifierDefault = require("./validators/isSpecifierDefault");
+var _isSpecifierDefault = require('./validators/isSpecifierDefault');
 
-var _isType = require("./validators/isType");
+var _isType = require('./validators/isType');
 
-var _isValidES3Identifier = require("./validators/isValidES3Identifier");
+var _isValidES3Identifier = require('./validators/isValidES3Identifier');
 
-var _isValidIdentifier = require("./validators/isValidIdentifier");
+var _isValidIdentifier = require('./validators/isValidIdentifier');
 
-var _isVar = require("./validators/isVar");
+var _isVar = require('./validators/isVar');
 
-var _matchesPattern = require("./validators/matchesPattern");
+var _matchesPattern = require('./validators/matchesPattern');
 
-var _validate = require("./validators/validate");
+var _validate = require('./validators/validate');
 
-var _buildMatchMemberExpression = require("./validators/buildMatchMemberExpression");
+var _buildMatchMemberExpression = require('./validators/buildMatchMemberExpression');
 
-var _generated4 = require("./validators/generated");
+var _generated4 = require('./validators/generated');
 
 Object.keys(_generated4).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  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");
+var _generated5 = require('./ast-types/generated');
 
 Object.keys(_generated5).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
+  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
+  buildChildren: _buildChildren.default,
 };
 exports.react = react;
 

node_modules/@babel/types/lib/modifications/appendToMemberExpression.js

@@ -1,14 +1,18 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = appendToMemberExpression;
 
-var _generated = require("../builders/generated");
+var _generated = require('../builders/generated');
 
 function appendToMemberExpression(member, append, computed = false) {
-  member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed);
+  member.object = (0, _generated.memberExpression)(
+    member.object,
+    member.property,
+    member.computed
+  );
   member.property = append;
   member.computed = !!computed;
   return member;

node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js

@@ -1,14 +1,16 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = removeTypeDuplicates;
 
-var _generated = require("../../validators/generated");
+var _generated = require('../../validators/generated');
 
 function getQualifiedName(node) {
-  return (0, _generated.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
+  return (0, _generated.isIdentifier)(node) ?
+      node.name
+    : `${node.id.name}.${getQualifiedName(node.qualification)}`;
 }
 
 function removeTypeDuplicates(nodes) {
@@ -51,7 +53,9 @@ function removeTypeDuplicates(nodes) {
 
         if (existing.typeParameters) {
           if (node.typeParameters) {
-            existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params));
+            existing.typeParameters.params = removeTypeDuplicates(
+              existing.typeParameters.params.concat(node.typeParameters.params)
+            );
           }
         } else {
           existing = node.typeParameters;

node_modules/@babel/types/lib/modifications/inherits.js

@@ -1,13 +1,13 @@
-"use strict";
+'use strict';
 
-Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, '__esModule', {
-  value: true
+  value: true,
 });
 exports.default = inherits;
 
-var _constants = require("../constants");
+var _constants = require('../constants');
 
-var _inheritsComments = require("../comments/inheritsComments");
+var _inheritsComments = require('../comments/inheritsComments');
 
 function inherits(child, parent) {
   if (!child || !parent) return child;
@@ -19,7 +19,7 @@ function inherits(child, parent) {
   }
 
   for (const key of Object.keys(parent)) {
-    if (key[0] === "_" && key !== "__clone") {
+    if (key[0] === '_' && key !== '__clone') {
       child[key] = parent[key];
     }
   }