fix: issue with user-activity.log not being generated

.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

.gitignore

@@ -0,0 +1,3 @@
+/dist
+/public
+/logs

.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

@@ -21,30 +21,76 @@ COD Tracker provides a clean interface to fetch, display, and export Call of Dut
 
 - [Node.js](https://nodejs.org/) (v14.x or higher)
 - npm (comes with Node.js)
-- Call of Duty account with API security settings set to "Open"
+- Call of Duty account with API security settings set to "ALL"
 
 ## Authentication Setup
 
-1. Log in to [Call of Duty](https://profile.callofduty.com)
-2. Open developer tools (F12)
-3. Navigate to: Application → Storage → Cookies → https://www.callofduty.com/
-4. Copy the value of `ACT_SSO_COOKIE`
-5. Provide this value when prompted by the tool
+<!-- <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:
+
+1. Log in to [Call of Duty](https://profile.callofduty.com/cod/profile)
+2. Navigate to the **Privacy & Security** tab
+3. Scroll down to **Game Data and Profile Privacy** section
+4. Set the following options to **ALL**:
+   - Game Tag Searchable
+   - Game Play Data
+
+### Obtaining Your SSO Token
+
+<table>
+<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>**
+4. Find and copy the value of `ACT_SSO_COOKIE`
+5. Paste this token into the "SSO Token" field
+
+> ⚠️ **Note**: Your SSO token is sensitive information. Never share it publicly.
+
+</td>
+<td width="40%">
+
+```plaintext
+Application
+ └─ Storage
+    └─ Cookies
+       └─ ACT_SSO_COOKIE
+```
+
+</td>
+</tr>
+</table>
+
+### Token Expiration
+
+The SSO token typically expires after 24 hours. If you encounter authentication errors, repeat Step 2 to obtain a fresh token.
 
 ## Installation
 
 1. Clone the repository:
+
    ```bash
    git clone https://git.rimmyscorner.com/Rim/codtracker-js.git && cd codtracker-js
    ```
 
 2. Start the application:
+
    ```bash
-   node app.js
+   npm run start
    ```
 
 3. Open your browser and navigate to:
-   ```
+
+   ```bash
    http://127.0.0.1:3513
    ```
 

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/acorn.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/../acorn/bin/acorn" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../acorn/bin/acorn" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../acorn/bin/acorn" $args
+  } else {
+    & "node$exe"  "$basedir/../acorn/bin/acorn" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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/glob.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/../glob/dist/esm/bin.mjs" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../glob/dist/esm/bin.mjs" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../glob/dist/esm/bin.mjs" $args
+  } else {
+    & "node$exe"  "$basedir/../glob/dist/esm/bin.mjs" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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/he.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/../he/bin/he" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../he/bin/he" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../he/bin/he" $args
+  } else {
+    & "node$exe"  "$basedir/../he/bin/he" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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/html-minifier.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/../html-minifier/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../html-minifier/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../html-minifier/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../html-minifier/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/jsesc

@@ -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/../jsesc/bin/jsesc" "$@"
+else 
+  exec node  "$basedir/../jsesc/bin/jsesc" "$@"
+fi

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/jsesc.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/../jsesc/bin/jsesc" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../jsesc/bin/jsesc" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../jsesc/bin/jsesc" $args
+  } else {
+    & "node$exe"  "$basedir/../jsesc/bin/jsesc" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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/mime.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/../mime/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../mime/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../mime/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../mime/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/node-which

@@ -1,16 +0,0 @@
-#!/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/../which/bin/node-which" "$@"
-else 
-  exec node  "$basedir/../which/bin/node-which" "$@"
-fi

node_modules/.bin/nodemon

@@ -1,16 +0,0 @@
-#!/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/../nodemon/bin/nodemon.js" "$@"
-else 
-  exec node  "$basedir/../nodemon/bin/nodemon.js" "$@"
-fi

node_modules/.bin/nodetouch

@@ -1,16 +0,0 @@
-#!/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/../touch/bin/nodetouch.js" "$@"
-else 
-  exec node  "$basedir/../touch/bin/nodetouch.js" "$@"
-fi

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

@@ -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/../pkg/lib-es5/bin.js" "$@"
+else 
+  exec node  "$basedir/../pkg/lib-es5/bin.js" "$@"
+fi

node_modules/.bin/pkg-fetch

@@ -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/../pkg-fetch/lib-es5/bin.js" "$@"
+else 
+  exec node  "$basedir/../pkg-fetch/lib-es5/bin.js" "$@"
+fi

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-fetch.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/../pkg-fetch/lib-es5/bin.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../pkg-fetch/lib-es5/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../pkg-fetch/lib-es5/bin.js" $args
+  } else {
+    & "node$exe"  "$basedir/../pkg-fetch/lib-es5/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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/pkg.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/../pkg/lib-es5/bin.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../pkg/lib-es5/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../pkg/lib-es5/bin.js" $args
+  } else {
+    & "node$exe"  "$basedir/../pkg/lib-es5/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/prebuild-install

@@ -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/../prebuild-install/bin.js" "$@"
+else 
+  exec node  "$basedir/../prebuild-install/bin.js" "$@"
+fi

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/prebuild-install.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/../prebuild-install/bin.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../prebuild-install/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../prebuild-install/bin.js" $args
+  } else {
+    & "node$exe"  "$basedir/../prebuild-install/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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

@@ -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/../rc/cli.js" "$@"
+else 
+  exec node  "$basedir/../rc/cli.js" "$@"
+fi

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/rc.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/../rc/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../rc/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../rc/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../rc/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/replace-in-file

@@ -1,16 +0,0 @@
-#!/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/../replace-in-file/bin/cli.js" "$@"
-else 
-  exec node  "$basedir/../replace-in-file/bin/cli.js" "$@"
-fi

node_modules/.bin/resolve

@@ -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/../resolve/bin/resolve" "$@"
+else 
+  exec node  "$basedir/../resolve/bin/resolve" "$@"
+fi

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/resolve.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/../resolve/bin/resolve" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../resolve/bin/resolve" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../resolve/bin/resolve" $args
+  } else {
+    & "node$exe"  "$basedir/../resolve/bin/resolve" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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/semver.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/../semver/bin/semver.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../semver/bin/semver.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../semver/bin/semver.js" $args
+  } else {
+    & "node$exe"  "$basedir/../semver/bin/semver.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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/terser.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/../terser/bin/terser" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../terser/bin/terser" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../terser/bin/terser" $args
+  } else {
+    & "node$exe"  "$basedir/../terser/bin/terser" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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/.bin/uglifyjs.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/../uglify-js/bin/uglifyjs" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../uglify-js/bin/uglifyjs" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../uglify-js/bin/uglifyjs" $args
+  } else {
+    & "node$exe"  "$basedir/../uglify-js/bin/uglifyjs" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

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

@@ -0,0 +1,254 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.default = void 0;
+
+function SourcePos() {
+  return {
+    identifierName: undefined,
+    line: undefined,
+    column: undefined,
+    filename: undefined,
+  };
+}
+
+const SPACES_RE = /^[ \t]+$/;
+
+class Buffer {
+  constructor(map) {
+    this._map = null;
+    this._buf = '';
+    this._last = 0;
+    this._queue = [];
+    this._position = {
+      line: 1,
+      column: 0,
+    };
+    this._sourcePosition = SourcePos();
+    this._disallowedPop = null;
+    this._map = map;
+  }
+
+  get() {
+    this._flush();
+
+    const map = this._map;
+    const result = {
+      code: this._buf.trimRight(),
+      decodedMap: map == null ? void 0 : map.getDecoded(),
+
+      get map() {
+        return (result.map = map ? map.get() : null);
+      },
+
+      set map(value) {
+        Object.defineProperty(result, 'map', {
+          value,
+          writable: true,
+        });
+      },
+
+      get rawMappings() {
+        return (result.rawMappings =
+          map == null ? void 0 : map.getRawMappings());
+      },
+
+      set rawMappings(value) {
+        Object.defineProperty(result, 'rawMappings', {
+          value,
+          writable: true,
+        });
+      },
+    };
+    return result;
+  }
+
+  append(str) {
+    this._flush();
+
+    const { line, column, filename, identifierName } = this._sourcePosition;
+
+    this._append(str, line, column, identifierName, filename);
+  }
+
+  queue(str) {
+    if (str === '\n') {
+      while (this._queue.length > 0 && SPACES_RE.test(this._queue[0][0])) {
+        this._queue.shift();
+      }
+    }
+
+    const { line, column, filename, identifierName } = this._sourcePosition;
+
+    this._queue.unshift([str, line, column, identifierName, filename]);
+  }
+
+  queueIndentation(str) {
+    this._queue.unshift([str, undefined, undefined, undefined, undefined]);
+  }
+
+  _flush() {
+    let item;
+
+    while ((item = this._queue.pop())) {
+      this._append(...item);
+    }
+  }
+
+  _append(str, line, column, identifierName, filename) {
+    this._buf += str;
+    this._last = str.charCodeAt(str.length - 1);
+    let i = str.indexOf('\n');
+    let last = 0;
+
+    if (i !== 0) {
+      this._mark(line, column, identifierName, filename);
+    }
+
+    while (i !== -1) {
+      this._position.line++;
+      this._position.column = 0;
+      last = i + 1;
+
+      if (last < str.length) {
+        this._mark(++line, 0, identifierName, filename);
+      }
+
+      i = str.indexOf('\n', last);
+    }
+
+    this._position.column += str.length - last;
+  }
+
+  _mark(line, column, identifierName, filename) {
+    var _this$_map;
+
+    (_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') {
+      this._queue.shift();
+    }
+  }
+
+  removeLastSemicolon() {
+    if (this._queue.length > 0 && this._queue[0][0] === ';') {
+      this._queue.shift();
+    }
+  }
+
+  getLastChar() {
+    let last;
+
+    if (this._queue.length > 0) {
+      const str = this._queue[0][0];
+      last = str.charCodeAt(0);
+    } else {
+      last = this._last;
+    }
+
+    return last;
+  }
+
+  endsWithCharAndNewline() {
+    const queue = this._queue;
+
+    if (queue.length > 0) {
+      const last = queue[0][0];
+      const lastCp = last.charCodeAt(0);
+      if (lastCp !== 10) return;
+
+      if (queue.length > 1) {
+        const secondLast = queue[1][0];
+        return secondLast.charCodeAt(0);
+      } else {
+        return this._last;
+      }
+    }
+  }
+
+  hasContent() {
+    return this._queue.length > 0 || !!this._last;
+  }
+
+  exactSource(loc, cb) {
+    this.source('start', loc);
+    cb();
+    this.source('end', loc);
+
+    this._disallowPop('start', loc);
+  }
+
+  source(prop, loc) {
+    if (prop && !loc) return;
+
+    this._normalizePosition(prop, loc, this._sourcePosition);
+  }
+
+  withSource(prop, loc, cb) {
+    if (!this._map) return cb();
+    const originalLine = this._sourcePosition.line;
+    const originalColumn = this._sourcePosition.column;
+    const originalFilename = this._sourcePosition.filename;
+    const originalIdentifierName = this._sourcePosition.identifierName;
+    this.source(prop, loc);
+    cb();
+
+    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;
+      this._sourcePosition.identifierName = originalIdentifierName;
+      this._disallowedPop = null;
+    }
+  }
+
+  _disallowPop(prop, loc) {
+    if (prop && !loc) return;
+    this._disallowedPop = this._normalizePosition(prop, loc, SourcePos());
+  }
+
+  _normalizePosition(prop, loc, targetObj) {
+    const pos = loc ? loc[prop] : null;
+    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;
+    return targetObj;
+  }
+
+  getCurrentColumn() {
+    const extra = this._queue.reduce((acc, item) => item[0] + acc, '');
+
+    const lastIndex = extra.lastIndexOf('\n');
+    return lastIndex === -1 ?
+        this._position.column + extra.length
+      : extra.length - 1 - lastIndex;
+  }
+
+  getCurrentLine() {
+    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++;
+    }
+
+    return this._position.line + count;
+  }
+}
+
+exports.default = Buffer;

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

@@ -0,0 +1,100 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.BlockStatement = BlockStatement;
+exports.Directive = Directive;
+exports.DirectiveLiteral = DirectiveLiteral;
+exports.File = File;
+exports.InterpreterDirective = InterpreterDirective;
+exports.Placeholder = Placeholder;
+exports.Program = Program;
+
+function File(node) {
+  if (node.program) {
+    this.print(node.program.interpreter, node);
+  }
+
+  this.print(node.program, node);
+}
+
+function Program(node) {
+  this.printInnerComments(node, false);
+  this.printSequence(node.directives, node);
+  if (node.directives && node.directives.length) this.newline();
+  this.printSequence(node.body, node);
+}
+
+function BlockStatement(node) {
+  var _node$directives;
+
+  this.token('{');
+  this.printInnerComments(node);
+  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,
+    });
+    if (hasDirectives) this.newline();
+    this.printSequence(node.body, node, {
+      indent: true,
+    });
+    this.removeTrailingNewline();
+    this.source('end', node.loc);
+    if (!this.endsWith(10)) this.newline();
+    this.rightBrace();
+  } else {
+    this.source('end', node.loc);
+    this.token('}');
+  }
+}
+
+function Directive(node) {
+  this.print(node.value, node);
+  this.semicolon();
+}
+
+const unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/;
+const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
+
+function DirectiveLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (!this.format.minified && raw != null) {
+    this.token(raw);
+    return;
+  }
+
+  const { 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.'
+    );
+  }
+}
+
+function InterpreterDirective(node) {
+  this.token(`#!${node.value}\n`);
+}
+
+function Placeholder(node) {
+  this.token('%%');
+  this.print(node.name);
+  this.token('%%');
+
+  if (node.expectedNode === 'Statement') {
+    this.semicolon();
+  }
+}

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

@@ -0,0 +1,213 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.ClassAccessorProperty = ClassAccessorProperty;
+exports.ClassBody = ClassBody;
+exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration;
+exports.ClassMethod = ClassMethod;
+exports.ClassPrivateMethod = ClassPrivateMethod;
+exports.ClassPrivateProperty = ClassPrivateProperty;
+exports.ClassProperty = ClassProperty;
+exports.StaticBlock = StaticBlock;
+exports._classMethodHead = _classMethodHead;
+
+var _t = require('@babel/types');
+
+const { isExportDefaultDeclaration, isExportNamedDeclaration } = _t;
+
+function ClassDeclaration(node, parent) {
+  if (
+    !this.format.decoratorsBeforeExport ||
+    (!isExportDefaultDeclaration(parent) && !isExportNamedDeclaration(parent))
+  ) {
+    this.printJoin(node.decorators, node);
+  }
+
+  if (node.declare) {
+    this.word('declare');
+    this.space();
+  }
+
+  if (node.abstract) {
+    this.word('abstract');
+    this.space();
+  }
+
+  this.word('class');
+  this.printInnerComments(node);
+
+  if (node.id) {
+    this.space();
+    this.print(node.id, node);
+  }
+
+  this.print(node.typeParameters, node);
+
+  if (node.superClass) {
+    this.space();
+    this.word('extends');
+    this.space();
+    this.print(node.superClass, node);
+    this.print(node.superTypeParameters, node);
+  }
+
+  if (node.implements) {
+    this.space();
+    this.word('implements');
+    this.space();
+    this.printList(node.implements, node);
+  }
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ClassBody(node) {
+  this.token('{');
+  this.printInnerComments(node);
+
+  if (node.body.length === 0) {
+    this.token('}');
+  } else {
+    this.newline();
+    this.indent();
+    this.printSequence(node.body, node);
+    this.dedent();
+    if (!this.endsWith(10)) this.newline();
+    this.rightBrace();
+  }
+}
+
+function ClassProperty(node) {
+  this.printJoin(node.decorators, node);
+  this.source('end', node.key.loc);
+  this.tsPrintClassMemberModifiers(node, true);
+
+  if (node.computed) {
+    this.token('[');
+    this.print(node.key, node);
+    this.token(']');
+  } else {
+    this._variance(node);
+
+    this.print(node.key, node);
+  }
+
+  if (node.optional) {
+    this.token('?');
+  }
+
+  if (node.definite) {
+    this.token('!');
+  }
+
+  this.print(node.typeAnnotation, node);
+
+  if (node.value) {
+    this.space();
+    this.token('=');
+    this.space();
+    this.print(node.value, node);
+  }
+
+  this.semicolon();
+}
+
+function ClassAccessorProperty(node) {
+  this.printJoin(node.decorators, node);
+  this.source('end', node.key.loc);
+  this.tsPrintClassMemberModifiers(node, true);
+  this.word('accessor');
+  this.printInnerComments(node);
+  this.space();
+
+  if (node.computed) {
+    this.token('[');
+    this.print(node.key, node);
+    this.token(']');
+  } else {
+    this._variance(node);
+
+    this.print(node.key, node);
+  }
+
+  if (node.optional) {
+    this.token('?');
+  }
+
+  if (node.definite) {
+    this.token('!');
+  }
+
+  this.print(node.typeAnnotation, node);
+
+  if (node.value) {
+    this.space();
+    this.token('=');
+    this.space();
+    this.print(node.value, node);
+  }
+
+  this.semicolon();
+}
+
+function ClassPrivateProperty(node) {
+  this.printJoin(node.decorators, node);
+
+  if (node.static) {
+    this.word('static');
+    this.space();
+  }
+
+  this.print(node.key, node);
+  this.print(node.typeAnnotation, node);
+
+  if (node.value) {
+    this.space();
+    this.token('=');
+    this.space();
+    this.print(node.value, node);
+  }
+
+  this.semicolon();
+}
+
+function ClassMethod(node) {
+  this._classMethodHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ClassPrivateMethod(node) {
+  this._classMethodHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function _classMethodHead(node) {
+  this.printJoin(node.decorators, node);
+  this.source('end', node.key.loc);
+  this.tsPrintClassMemberModifiers(node, false);
+
+  this._methodHead(node);
+}
+
+function StaticBlock(node) {
+  this.word('static');
+  this.space();
+  this.token('{');
+
+  if (node.body.length === 0) {
+    this.token('}');
+  } else {
+    this.newline();
+    this.printSequence(node.body, node, {
+      indent: true,
+    });
+    this.rightBrace();
+  }
+}

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

@@ -0,0 +1,369 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.LogicalExpression =
+  exports.BinaryExpression =
+  exports.AssignmentExpression =
+    AssignmentExpression;
+exports.AssignmentPattern = AssignmentPattern;
+exports.AwaitExpression = void 0;
+exports.BindExpression = BindExpression;
+exports.CallExpression = CallExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.Decorator = Decorator;
+exports.DoExpression = DoExpression;
+exports.EmptyStatement = EmptyStatement;
+exports.ExpressionStatement = ExpressionStatement;
+exports.Import = Import;
+exports.MemberExpression = MemberExpression;
+exports.MetaProperty = MetaProperty;
+exports.ModuleExpression = ModuleExpression;
+exports.NewExpression = NewExpression;
+exports.OptionalCallExpression = OptionalCallExpression;
+exports.OptionalMemberExpression = OptionalMemberExpression;
+exports.ParenthesizedExpression = ParenthesizedExpression;
+exports.PrivateName = PrivateName;
+exports.SequenceExpression = SequenceExpression;
+exports.Super = Super;
+exports.ThisExpression = ThisExpression;
+exports.UnaryExpression = UnaryExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
+exports.YieldExpression = void 0;
+
+var _t = require('@babel/types');
+
+var n = require('../node');
+
+const { isCallExpression, isLiteral, isMemberExpression, isNewExpression } = _t;
+
+function UnaryExpression(node) {
+  if (
+    node.operator === 'void' ||
+    node.operator === 'delete' ||
+    node.operator === 'typeof' ||
+    node.operator === 'throw'
+  ) {
+    this.word(node.operator);
+    this.space();
+  } else {
+    this.token(node.operator);
+  }
+
+  this.print(node.argument, node);
+}
+
+function DoExpression(node) {
+  if (node.async) {
+    this.word('async');
+    this.space();
+  }
+
+  this.word('do');
+  this.space();
+  this.print(node.body, node);
+}
+
+function ParenthesizedExpression(node) {
+  this.token('(');
+  this.print(node.expression, node);
+  this.token(')');
+}
+
+function UpdateExpression(node) {
+  if (node.prefix) {
+    this.token(node.operator);
+    this.print(node.argument, node);
+  } else {
+    this.startTerminatorless(true);
+    this.print(node.argument, node);
+    this.endTerminatorless();
+    this.token(node.operator);
+  }
+}
+
+function ConditionalExpression(node) {
+  this.print(node.test, node);
+  this.space();
+  this.token('?');
+  this.space();
+  this.print(node.consequent, node);
+  this.space();
+  this.token(':');
+  this.space();
+  this.print(node.alternate, node);
+}
+
+function NewExpression(node, parent) {
+  this.word('new');
+  this.space();
+  this.print(node.callee, node);
+
+  if (
+    this.format.minified &&
+    node.arguments.length === 0 &&
+    !node.optional &&
+    !isCallExpression(parent, {
+      callee: node,
+    }) &&
+    !isMemberExpression(parent) &&
+    !isNewExpression(parent)
+  ) {
+    return;
+  }
+
+  this.print(node.typeArguments, node);
+  this.print(node.typeParameters, node);
+
+  if (node.optional) {
+    this.token('?.');
+  }
+
+  this.token('(');
+  this.printList(node.arguments, node);
+  this.token(')');
+}
+
+function SequenceExpression(node) {
+  this.printList(node.expressions, node);
+}
+
+function ThisExpression() {
+  this.word('this');
+}
+
+function Super() {
+  this.word('super');
+}
+
+function isDecoratorMemberExpression(node) {
+  switch (node.type) {
+    case 'Identifier':
+      return true;
+
+    case 'MemberExpression':
+      return (
+        !node.computed &&
+        node.property.type === 'Identifier' &&
+        isDecoratorMemberExpression(node.object)
+      );
+
+    default:
+      return false;
+  }
+}
+
+function shouldParenthesizeDecoratorExpression(node) {
+  if (node.type === 'CallExpression') {
+    node = node.callee;
+  }
+
+  if (node.type === 'ParenthesizedExpression') {
+    return false;
+  }
+
+  return !isDecoratorMemberExpression(node);
+}
+
+function Decorator(node) {
+  this.token('@');
+  const { expression } = node;
+
+  if (shouldParenthesizeDecoratorExpression(expression)) {
+    this.token('(');
+    this.print(expression, node);
+    this.token(')');
+  } else {
+    this.print(expression, node);
+  }
+
+  this.newline();
+}
+
+function OptionalMemberExpression(node) {
+  this.print(node.object, node);
+
+  if (!node.computed && isMemberExpression(node.property)) {
+    throw new TypeError('Got a MemberExpression for MemberExpression property');
+  }
+
+  let computed = node.computed;
+
+  if (isLiteral(node.property) && typeof node.property.value === 'number') {
+    computed = true;
+  }
+
+  if (node.optional) {
+    this.token('?.');
+  }
+
+  if (computed) {
+    this.token('[');
+    this.print(node.property, node);
+    this.token(']');
+  } else {
+    if (!node.optional) {
+      this.token('.');
+    }
+
+    this.print(node.property, node);
+  }
+}
+
+function OptionalCallExpression(node) {
+  this.print(node.callee, node);
+  this.print(node.typeArguments, node);
+  this.print(node.typeParameters, node);
+
+  if (node.optional) {
+    this.token('?.');
+  }
+
+  this.token('(');
+  this.printList(node.arguments, node);
+  this.token(')');
+}
+
+function CallExpression(node) {
+  this.print(node.callee, node);
+  this.print(node.typeArguments, node);
+  this.print(node.typeParameters, node);
+  this.token('(');
+  this.printList(node.arguments, node);
+  this.token(')');
+}
+
+function Import() {
+  this.word('import');
+}
+
+function buildYieldAwait(keyword) {
+  return function (node) {
+    this.word(keyword);
+
+    if (node.delegate) {
+      this.token('*');
+    }
+
+    if (node.argument) {
+      this.space();
+      const terminatorState = this.startTerminatorless();
+      this.print(node.argument, node);
+      this.endTerminatorless(terminatorState);
+    }
+  };
+}
+
+const YieldExpression = buildYieldAwait('yield');
+exports.YieldExpression = YieldExpression;
+const AwaitExpression = buildYieldAwait('await');
+exports.AwaitExpression = AwaitExpression;
+
+function EmptyStatement() {
+  this.semicolon(true);
+}
+
+function ExpressionStatement(node) {
+  this.print(node.expression, node);
+  this.semicolon();
+}
+
+function AssignmentPattern(node) {
+  this.print(node.left, node);
+  if (node.left.optional) this.token('?');
+  this.print(node.left.typeAnnotation, node);
+  this.space();
+  this.token('=');
+  this.space();
+  this.print(node.right, node);
+}
+
+function AssignmentExpression(node, parent) {
+  const parens =
+    this.inForStatementInitCounter &&
+    node.operator === 'in' &&
+    !n.needsParens(node, parent);
+
+  if (parens) {
+    this.token('(');
+  }
+
+  this.print(node.left, node);
+  this.space();
+
+  if (node.operator === 'in' || node.operator === 'instanceof') {
+    this.word(node.operator);
+  } else {
+    this.token(node.operator);
+  }
+
+  this.space();
+  this.print(node.right, node);
+
+  if (parens) {
+    this.token(')');
+  }
+}
+
+function BindExpression(node) {
+  this.print(node.object, node);
+  this.token('::');
+  this.print(node.callee, node);
+}
+
+function MemberExpression(node) {
+  this.print(node.object, node);
+
+  if (!node.computed && isMemberExpression(node.property)) {
+    throw new TypeError('Got a MemberExpression for MemberExpression property');
+  }
+
+  let computed = node.computed;
+
+  if (isLiteral(node.property) && typeof node.property.value === 'number') {
+    computed = true;
+  }
+
+  if (computed) {
+    this.token('[');
+    this.print(node.property, node);
+    this.token(']');
+  } else {
+    this.token('.');
+    this.print(node.property, node);
+  }
+}
+
+function MetaProperty(node) {
+  this.print(node.meta, node);
+  this.token('.');
+  this.print(node.property, node);
+}
+
+function PrivateName(node) {
+  this.token('#');
+  this.print(node.id, node);
+}
+
+function V8IntrinsicIdentifier(node) {
+  this.token('%');
+  this.word(node.name);
+}
+
+function ModuleExpression(node) {
+  this.word('module');
+  this.space();
+  this.token('{');
+
+  if (node.body.body.length === 0) {
+    this.token('}');
+  } else {
+    this.newline();
+    this.printSequence(node.body.body, node, {
+      indent: true,
+    });
+    this.rightBrace();
+  }
+}

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

@@ -0,0 +1,790 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.AnyTypeAnnotation = AnyTypeAnnotation;
+exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
+exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
+exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
+exports.DeclareClass = DeclareClass;
+exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
+exports.DeclareExportDeclaration = DeclareExportDeclaration;
+exports.DeclareFunction = DeclareFunction;
+exports.DeclareInterface = DeclareInterface;
+exports.DeclareModule = DeclareModule;
+exports.DeclareModuleExports = DeclareModuleExports;
+exports.DeclareOpaqueType = DeclareOpaqueType;
+exports.DeclareTypeAlias = DeclareTypeAlias;
+exports.DeclareVariable = DeclareVariable;
+exports.DeclaredPredicate = DeclaredPredicate;
+exports.EmptyTypeAnnotation = EmptyTypeAnnotation;
+exports.EnumBooleanBody = EnumBooleanBody;
+exports.EnumBooleanMember = EnumBooleanMember;
+exports.EnumDeclaration = EnumDeclaration;
+exports.EnumDefaultedMember = EnumDefaultedMember;
+exports.EnumNumberBody = EnumNumberBody;
+exports.EnumNumberMember = EnumNumberMember;
+exports.EnumStringBody = EnumStringBody;
+exports.EnumStringMember = EnumStringMember;
+exports.EnumSymbolBody = EnumSymbolBody;
+exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
+exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.FunctionTypeParam = FunctionTypeParam;
+exports.IndexedAccessType = IndexedAccessType;
+exports.InferredPredicate = InferredPredicate;
+exports.InterfaceDeclaration = InterfaceDeclaration;
+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', {
+  enumerable: true,
+  get: function () {
+    return _types2.NumericLiteral;
+  },
+});
+exports.NumberTypeAnnotation = NumberTypeAnnotation;
+exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
+exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
+exports.ObjectTypeIndexer = ObjectTypeIndexer;
+exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
+exports.ObjectTypeProperty = ObjectTypeProperty;
+exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
+exports.OpaqueType = OpaqueType;
+exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
+exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
+Object.defineProperty(exports, 'StringLiteralTypeAnnotation', {
+  enumerable: true,
+  get: function () {
+    return _types2.StringLiteral;
+  },
+});
+exports.StringTypeAnnotation = StringTypeAnnotation;
+exports.SymbolTypeAnnotation = SymbolTypeAnnotation;
+exports.ThisTypeAnnotation = ThisTypeAnnotation;
+exports.TupleTypeAnnotation = TupleTypeAnnotation;
+exports.TypeAlias = TypeAlias;
+exports.TypeAnnotation = TypeAnnotation;
+exports.TypeCastExpression = TypeCastExpression;
+exports.TypeParameter = TypeParameter;
+exports.TypeParameterDeclaration = exports.TypeParameterInstantiation =
+  TypeParameterInstantiation;
+exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
+exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.Variance = Variance;
+exports.VoidTypeAnnotation = VoidTypeAnnotation;
+exports._interfaceish = _interfaceish;
+exports._variance = _variance;
+
+var _t = require('@babel/types');
+
+var _modules = require('./modules');
+
+var _types2 = require('./types');
+
+const { isDeclareExportDeclaration, isStatement } = _t;
+
+function AnyTypeAnnotation() {
+  this.word('any');
+}
+
+function ArrayTypeAnnotation(node) {
+  this.print(node.elementType, node);
+  this.token('[');
+  this.token(']');
+}
+
+function BooleanTypeAnnotation() {
+  this.word('boolean');
+}
+
+function BooleanLiteralTypeAnnotation(node) {
+  this.word(node.value ? 'true' : 'false');
+}
+
+function NullLiteralTypeAnnotation() {
+  this.word('null');
+}
+
+function DeclareClass(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word('declare');
+    this.space();
+  }
+
+  this.word('class');
+  this.space();
+
+  this._interfaceish(node);
+}
+
+function DeclareFunction(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word('declare');
+    this.space();
+  }
+
+  this.word('function');
+  this.space();
+  this.print(node.id, node);
+  this.print(node.id.typeAnnotation.typeAnnotation, node);
+
+  if (node.predicate) {
+    this.space();
+    this.print(node.predicate, node);
+  }
+
+  this.semicolon();
+}
+
+function InferredPredicate() {
+  this.token('%');
+  this.word('checks');
+}
+
+function DeclaredPredicate(node) {
+  this.token('%');
+  this.word('checks');
+  this.token('(');
+  this.print(node.value, node);
+  this.token(')');
+}
+
+function DeclareInterface(node) {
+  this.word('declare');
+  this.space();
+  this.InterfaceDeclaration(node);
+}
+
+function DeclareModule(node) {
+  this.word('declare');
+  this.space();
+  this.word('module');
+  this.space();
+  this.print(node.id, node);
+  this.space();
+  this.print(node.body, node);
+}
+
+function DeclareModuleExports(node) {
+  this.word('declare');
+  this.space();
+  this.word('module');
+  this.token('.');
+  this.word('exports');
+  this.print(node.typeAnnotation, node);
+}
+
+function DeclareTypeAlias(node) {
+  this.word('declare');
+  this.space();
+  this.TypeAlias(node);
+}
+
+function DeclareOpaqueType(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word('declare');
+    this.space();
+  }
+
+  this.OpaqueType(node);
+}
+
+function DeclareVariable(node, parent) {
+  if (!isDeclareExportDeclaration(parent)) {
+    this.word('declare');
+    this.space();
+  }
+
+  this.word('var');
+  this.space();
+  this.print(node.id, node);
+  this.print(node.id.typeAnnotation, node);
+  this.semicolon();
+}
+
+function DeclareExportDeclaration(node) {
+  this.word('declare');
+  this.space();
+  this.word('export');
+  this.space();
+
+  if (node.default) {
+    this.word('default');
+    this.space();
+  }
+
+  FlowExportDeclaration.apply(this, arguments);
+}
+
+function DeclareExportAllDeclaration() {
+  this.word('declare');
+  this.space();
+
+  _modules.ExportAllDeclaration.apply(this, arguments);
+}
+
+function EnumDeclaration(node) {
+  const { id, body } = node;
+  this.word('enum');
+  this.space();
+  this.print(id, node);
+  this.print(body, node);
+}
+
+function enumExplicitType(context, name, hasExplicitType) {
+  if (hasExplicitType) {
+    context.space();
+    context.word('of');
+    context.space();
+    context.word(name);
+  }
+
+  context.space();
+}
+
+function enumBody(context, node) {
+  const { members } = node;
+  context.token('{');
+  context.indent();
+  context.newline();
+
+  for (const member of members) {
+    context.print(member, node);
+    context.newline();
+  }
+
+  if (node.hasUnknownMembers) {
+    context.token('...');
+    context.newline();
+  }
+
+  context.dedent();
+  context.token('}');
+}
+
+function EnumBooleanBody(node) {
+  const { explicitType } = node;
+  enumExplicitType(this, 'boolean', explicitType);
+  enumBody(this, node);
+}
+
+function EnumNumberBody(node) {
+  const { explicitType } = node;
+  enumExplicitType(this, 'number', explicitType);
+  enumBody(this, node);
+}
+
+function EnumStringBody(node) {
+  const { explicitType } = node;
+  enumExplicitType(this, 'string', explicitType);
+  enumBody(this, node);
+}
+
+function EnumSymbolBody(node) {
+  enumExplicitType(this, 'symbol', true);
+  enumBody(this, node);
+}
+
+function EnumDefaultedMember(node) {
+  const { id } = node;
+  this.print(id, node);
+  this.token(',');
+}
+
+function enumInitializedMember(context, node) {
+  const { id, init } = node;
+  context.print(id, node);
+  context.space();
+  context.token('=');
+  context.space();
+  context.print(init, node);
+  context.token(',');
+}
+
+function EnumBooleanMember(node) {
+  enumInitializedMember(this, node);
+}
+
+function EnumNumberMember(node) {
+  enumInitializedMember(this, node);
+}
+
+function EnumStringMember(node) {
+  enumInitializedMember(this, node);
+}
+
+function FlowExportDeclaration(node) {
+  if (node.declaration) {
+    const declar = node.declaration;
+    this.print(declar, node);
+    if (!isStatement(declar)) this.semicolon();
+  } else {
+    this.token('{');
+
+    if (node.specifiers.length) {
+      this.space();
+      this.printList(node.specifiers, node);
+      this.space();
+    }
+
+    this.token('}');
+
+    if (node.source) {
+      this.space();
+      this.word('from');
+      this.space();
+      this.print(node.source, node);
+    }
+
+    this.semicolon();
+  }
+}
+
+function ExistsTypeAnnotation() {
+  this.token('*');
+}
+
+function FunctionTypeAnnotation(node, parent) {
+  this.print(node.typeParameters, node);
+  this.token('(');
+
+  if (node.this) {
+    this.word('this');
+    this.token(':');
+    this.space();
+    this.print(node.this.typeAnnotation, node);
+
+    if (node.params.length || node.rest) {
+      this.token(',');
+      this.space();
+    }
+  }
+
+  this.printList(node.params, node);
+
+  if (node.rest) {
+    if (node.params.length) {
+      this.token(',');
+      this.space();
+    }
+
+    this.token('...');
+    this.print(node.rest, node);
+  }
+
+  this.token(')');
+
+  if (
+    parent &&
+    (parent.type === 'ObjectTypeCallProperty' ||
+      parent.type === 'DeclareFunction' ||
+      (parent.type === 'ObjectTypeProperty' && parent.method))
+  ) {
+    this.token(':');
+  } else {
+    this.space();
+    this.token('=>');
+  }
+
+  this.space();
+  this.print(node.returnType, node);
+}
+
+function FunctionTypeParam(node) {
+  this.print(node.name, node);
+  if (node.optional) this.token('?');
+
+  if (node.name) {
+    this.token(':');
+    this.space();
+  }
+
+  this.print(node.typeAnnotation, node);
+}
+
+function InterfaceExtends(node) {
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+}
+
+function _interfaceish(node) {
+  var _node$extends;
+
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+
+  if ((_node$extends = node.extends) != null && _node$extends.length) {
+    this.space();
+    this.word('extends');
+    this.space();
+    this.printList(node.extends, node);
+  }
+
+  if (node.mixins && node.mixins.length) {
+    this.space();
+    this.word('mixins');
+    this.space();
+    this.printList(node.mixins, node);
+  }
+
+  if (node.implements && node.implements.length) {
+    this.space();
+    this.word('implements');
+    this.space();
+    this.printList(node.implements, node);
+  }
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function _variance(node) {
+  if (node.variance) {
+    if (node.variance.kind === 'plus') {
+      this.token('+');
+    } else if (node.variance.kind === 'minus') {
+      this.token('-');
+    }
+  }
+}
+
+function InterfaceDeclaration(node) {
+  this.word('interface');
+  this.space();
+
+  this._interfaceish(node);
+}
+
+function andSeparator() {
+  this.space();
+  this.token('&');
+  this.space();
+}
+
+function InterfaceTypeAnnotation(node) {
+  this.word('interface');
+
+  if (node.extends && node.extends.length) {
+    this.space();
+    this.word('extends');
+    this.space();
+    this.printList(node.extends, node);
+  }
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function IntersectionTypeAnnotation(node) {
+  this.printJoin(node.types, node, {
+    separator: andSeparator,
+  });
+}
+
+function MixedTypeAnnotation() {
+  this.word('mixed');
+}
+
+function EmptyTypeAnnotation() {
+  this.word('empty');
+}
+
+function NullableTypeAnnotation(node) {
+  this.token('?');
+  this.print(node.typeAnnotation, node);
+}
+
+function NumberTypeAnnotation() {
+  this.word('number');
+}
+
+function StringTypeAnnotation() {
+  this.word('string');
+}
+
+function ThisTypeAnnotation() {
+  this.word('this');
+}
+
+function TupleTypeAnnotation(node) {
+  this.token('[');
+  this.printList(node.types, node);
+  this.token(']');
+}
+
+function TypeofTypeAnnotation(node) {
+  this.word('typeof');
+  this.space();
+  this.print(node.argument, node);
+}
+
+function TypeAlias(node) {
+  this.word('type');
+  this.space();
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+  this.space();
+  this.token('=');
+  this.space();
+  this.print(node.right, node);
+  this.semicolon();
+}
+
+function TypeAnnotation(node) {
+  this.token(':');
+  this.space();
+  if (node.optional) this.token('?');
+  this.print(node.typeAnnotation, node);
+}
+
+function TypeParameterInstantiation(node) {
+  this.token('<');
+  this.printList(node.params, node, {});
+  this.token('>');
+}
+
+function TypeParameter(node) {
+  this._variance(node);
+
+  this.word(node.name);
+
+  if (node.bound) {
+    this.print(node.bound, node);
+  }
+
+  if (node.default) {
+    this.space();
+    this.token('=');
+    this.space();
+    this.print(node.default, node);
+  }
+}
+
+function OpaqueType(node) {
+  this.word('opaque');
+  this.space();
+  this.word('type');
+  this.space();
+  this.print(node.id, node);
+  this.print(node.typeParameters, node);
+
+  if (node.supertype) {
+    this.token(':');
+    this.space();
+    this.print(node.supertype, node);
+  }
+
+  if (node.impltype) {
+    this.space();
+    this.token('=');
+    this.space();
+    this.print(node.impltype, node);
+  }
+
+  this.semicolon();
+}
+
+function ObjectTypeAnnotation(node) {
+  if (node.exact) {
+    this.token('{|');
+  } else {
+    this.token('{');
+  }
+
+  const props = [
+    ...node.properties,
+    ...(node.callProperties || []),
+    ...(node.indexers || []),
+    ...(node.internalSlots || []),
+  ];
+
+  if (props.length) {
+    this.space();
+    this.printJoin(props, node, {
+      addNewlines(leading) {
+        if (leading && !props[0]) return 1;
+      },
+
+      indent: true,
+      statement: true,
+      iterator: () => {
+        if (props.length !== 1 || node.inexact) {
+          this.token(',');
+          this.space();
+        }
+      },
+    });
+    this.space();
+  }
+
+  if (node.inexact) {
+    this.indent();
+    this.token('...');
+
+    if (props.length) {
+      this.newline();
+    }
+
+    this.dedent();
+  }
+
+  if (node.exact) {
+    this.token('|}');
+  } else {
+    this.token('}');
+  }
+}
+
+function ObjectTypeInternalSlot(node) {
+  if (node.static) {
+    this.word('static');
+    this.space();
+  }
+
+  this.token('[');
+  this.token('[');
+  this.print(node.id, node);
+  this.token(']');
+  this.token(']');
+  if (node.optional) this.token('?');
+
+  if (!node.method) {
+    this.token(':');
+    this.space();
+  }
+
+  this.print(node.value, node);
+}
+
+function ObjectTypeCallProperty(node) {
+  if (node.static) {
+    this.word('static');
+    this.space();
+  }
+
+  this.print(node.value, node);
+}
+
+function ObjectTypeIndexer(node) {
+  if (node.static) {
+    this.word('static');
+    this.space();
+  }
+
+  this._variance(node);
+
+  this.token('[');
+
+  if (node.id) {
+    this.print(node.id, node);
+    this.token(':');
+    this.space();
+  }
+
+  this.print(node.key, node);
+  this.token(']');
+  this.token(':');
+  this.space();
+  this.print(node.value, node);
+}
+
+function ObjectTypeProperty(node) {
+  if (node.proto) {
+    this.word('proto');
+    this.space();
+  }
+
+  if (node.static) {
+    this.word('static');
+    this.space();
+  }
+
+  if (node.kind === 'get' || node.kind === 'set') {
+    this.word(node.kind);
+    this.space();
+  }
+
+  this._variance(node);
+
+  this.print(node.key, node);
+  if (node.optional) this.token('?');
+
+  if (!node.method) {
+    this.token(':');
+    this.space();
+  }
+
+  this.print(node.value, node);
+}
+
+function ObjectTypeSpreadProperty(node) {
+  this.token('...');
+  this.print(node.argument, node);
+}
+
+function QualifiedTypeIdentifier(node) {
+  this.print(node.qualification, node);
+  this.token('.');
+  this.print(node.id, node);
+}
+
+function SymbolTypeAnnotation() {
+  this.word('symbol');
+}
+
+function orSeparator() {
+  this.space();
+  this.token('|');
+  this.space();
+}
+
+function UnionTypeAnnotation(node) {
+  this.printJoin(node.types, node, {
+    separator: orSeparator,
+  });
+}
+
+function TypeCastExpression(node) {
+  this.token('(');
+  this.print(node.expression, node);
+  this.print(node.typeAnnotation, node);
+  this.token(')');
+}
+
+function Variance(node) {
+  if (node.kind === 'plus') {
+    this.token('+');
+  } else {
+    this.token('-');
+  }
+}
+
+function VoidTypeAnnotation() {
+  this.word('void');
+}
+
+function IndexedAccessType(node) {
+  this.print(node.objectType, node);
+  this.token('[');
+  this.print(node.indexType, node);
+  this.token(']');
+}
+
+function OptionalIndexedAccessType(node) {
+  this.print(node.objectType, node);
+
+  if (node.optional) {
+    this.token('?.');
+  }
+
+  this.token('[');
+  this.print(node.indexType, node);
+  this.token(']');
+}

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

@@ -0,0 +1,148 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+
+var _templateLiterals = require('./template-literals');
+
+Object.keys(_templateLiterals).forEach(function (key) {
+  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');
+
+Object.keys(_expressions).forEach(function (key) {
+  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');
+
+Object.keys(_statements).forEach(function (key) {
+  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');
+
+Object.keys(_classes).forEach(function (key) {
+  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');
+
+Object.keys(_methods).forEach(function (key) {
+  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');
+
+Object.keys(_modules).forEach(function (key) {
+  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');
+
+Object.keys(_types).forEach(function (key) {
+  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');
+
+Object.keys(_flow).forEach(function (key) {
+  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');
+
+Object.keys(_base).forEach(function (key) {
+  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');
+
+Object.keys(_jsx).forEach(function (key) {
+  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');
+
+Object.keys(_typescript).forEach(function (key) {
+  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

@@ -0,0 +1,145 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.JSXAttribute = JSXAttribute;
+exports.JSXClosingElement = JSXClosingElement;
+exports.JSXClosingFragment = JSXClosingFragment;
+exports.JSXElement = JSXElement;
+exports.JSXEmptyExpression = JSXEmptyExpression;
+exports.JSXExpressionContainer = JSXExpressionContainer;
+exports.JSXFragment = JSXFragment;
+exports.JSXIdentifier = JSXIdentifier;
+exports.JSXMemberExpression = JSXMemberExpression;
+exports.JSXNamespacedName = JSXNamespacedName;
+exports.JSXOpeningElement = JSXOpeningElement;
+exports.JSXOpeningFragment = JSXOpeningFragment;
+exports.JSXSpreadAttribute = JSXSpreadAttribute;
+exports.JSXSpreadChild = JSXSpreadChild;
+exports.JSXText = JSXText;
+
+function JSXAttribute(node) {
+  this.print(node.name, node);
+
+  if (node.value) {
+    this.token('=');
+    this.print(node.value, node);
+  }
+}
+
+function JSXIdentifier(node) {
+  this.word(node.name);
+}
+
+function JSXNamespacedName(node) {
+  this.print(node.namespace, node);
+  this.token(':');
+  this.print(node.name, node);
+}
+
+function JSXMemberExpression(node) {
+  this.print(node.object, node);
+  this.token('.');
+  this.print(node.property, node);
+}
+
+function JSXSpreadAttribute(node) {
+  this.token('{');
+  this.token('...');
+  this.print(node.argument, node);
+  this.token('}');
+}
+
+function JSXExpressionContainer(node) {
+  this.token('{');
+  this.print(node.expression, node);
+  this.token('}');
+}
+
+function JSXSpreadChild(node) {
+  this.token('{');
+  this.token('...');
+  this.print(node.expression, node);
+  this.token('}');
+}
+
+function JSXText(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (raw != null) {
+    this.token(raw);
+  } else {
+    this.token(node.value);
+  }
+}
+
+function JSXElement(node) {
+  const open = node.openingElement;
+  this.print(open, node);
+  if (open.selfClosing) return;
+  this.indent();
+
+  for (const child of node.children) {
+    this.print(child, node);
+  }
+
+  this.dedent();
+  this.print(node.closingElement, node);
+}
+
+function spaceSeparator() {
+  this.space();
+}
+
+function JSXOpeningElement(node) {
+  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,
+    });
+  }
+
+  if (node.selfClosing) {
+    this.space();
+    this.token('/>');
+  } else {
+    this.token('>');
+  }
+}
+
+function JSXClosingElement(node) {
+  this.token('</');
+  this.print(node.name, node);
+  this.token('>');
+}
+
+function JSXEmptyExpression(node) {
+  this.printInnerComments(node);
+}
+
+function JSXFragment(node) {
+  this.print(node.openingFragment, node);
+  this.indent();
+
+  for (const child of node.children) {
+    this.print(child, node);
+  }
+
+  this.dedent();
+  this.print(node.closingFragment, node);
+}
+
+function JSXOpeningFragment() {
+  this.token('<');
+  this.token('>');
+}
+
+function JSXClosingFragment() {
+  this.token('</');
+  this.token('>');
+}

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

@@ -0,0 +1,165 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression;
+exports._functionHead = _functionHead;
+exports._methodHead = _methodHead;
+exports._param = _param;
+exports._parameters = _parameters;
+exports._params = _params;
+exports._predicate = _predicate;
+
+var _t = require('@babel/types');
+
+const { isIdentifier } = _t;
+
+function _params(node) {
+  this.print(node.typeParameters, node);
+  this.token('(');
+
+  this._parameters(node.params, node);
+
+  this.token(')');
+  this.print(node.returnType, node);
+}
+
+function _parameters(parameters, parent) {
+  for (let i = 0; i < parameters.length; i++) {
+    this._param(parameters[i], parent);
+
+    if (i < parameters.length - 1) {
+      this.token(',');
+      this.space();
+    }
+  }
+}
+
+function _param(parameter, parent) {
+  this.printJoin(parameter.decorators, parameter);
+  this.print(parameter, parent);
+  if (parameter.optional) this.token('?');
+  this.print(parameter.typeAnnotation, parameter);
+}
+
+function _methodHead(node) {
+  const kind = node.kind;
+  const key = node.key;
+
+  if (kind === 'get' || kind === 'set') {
+    this.word(kind);
+    this.space();
+  }
+
+  if (node.async) {
+    this._catchUp('start', key.loc);
+
+    this.word('async');
+    this.space();
+  }
+
+  if (kind === 'method' || kind === 'init') {
+    if (node.generator) {
+      this.token('*');
+    }
+  }
+
+  if (node.computed) {
+    this.token('[');
+    this.print(key, node);
+    this.token(']');
+  } else {
+    this.print(key, node);
+  }
+
+  if (node.optional) {
+    this.token('?');
+  }
+
+  this._params(node);
+}
+
+function _predicate(node) {
+  if (node.predicate) {
+    if (!node.returnType) {
+      this.token(':');
+    }
+
+    this.space();
+    this.print(node.predicate, node);
+  }
+}
+
+function _functionHead(node) {
+  if (node.async) {
+    this.word('async');
+    this.space();
+  }
+
+  this.word('function');
+  if (node.generator) this.token('*');
+  this.printInnerComments(node);
+  this.space();
+
+  if (node.id) {
+    this.print(node.id, node);
+  }
+
+  this._params(node);
+
+  this._predicate(node);
+}
+
+function FunctionExpression(node) {
+  this._functionHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ArrowFunctionExpression(node) {
+  if (node.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)
+  ) {
+    this.print(firstParam, node);
+  } else {
+    this._params(node);
+  }
+
+  this._predicate(node);
+
+  this.space();
+  this.token('=>');
+  this.space();
+  this.print(node.body, 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)
+  );
+}

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

@@ -0,0 +1,256 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.ExportAllDeclaration = ExportAllDeclaration;
+exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
+exports.ExportDefaultSpecifier = ExportDefaultSpecifier;
+exports.ExportNamedDeclaration = ExportNamedDeclaration;
+exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
+exports.ExportSpecifier = ExportSpecifier;
+exports.ImportAttribute = ImportAttribute;
+exports.ImportDeclaration = ImportDeclaration;
+exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
+exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
+exports.ImportSpecifier = ImportSpecifier;
+
+var _t = require('@babel/types');
+
+const {
+  isClassDeclaration,
+  isExportDefaultSpecifier,
+  isExportNamespaceSpecifier,
+  isImportDefaultSpecifier,
+  isImportNamespaceSpecifier,
+  isStatement,
+} = _t;
+
+function ImportSpecifier(node) {
+  if (node.importKind === 'type' || node.importKind === 'typeof') {
+    this.word(node.importKind);
+    this.space();
+  }
+
+  this.print(node.imported, node);
+
+  if (node.local && node.local.name !== node.imported.name) {
+    this.space();
+    this.word('as');
+    this.space();
+    this.print(node.local, node);
+  }
+}
+
+function ImportDefaultSpecifier(node) {
+  this.print(node.local, node);
+}
+
+function ExportDefaultSpecifier(node) {
+  this.print(node.exported, node);
+}
+
+function ExportSpecifier(node) {
+  if (node.exportKind === 'type') {
+    this.word('type');
+    this.space();
+  }
+
+  this.print(node.local, node);
+
+  if (node.exported && node.local.name !== node.exported.name) {
+    this.space();
+    this.word('as');
+    this.space();
+    this.print(node.exported, node);
+  }
+}
+
+function ExportNamespaceSpecifier(node) {
+  this.token('*');
+  this.space();
+  this.word('as');
+  this.space();
+  this.print(node.exported, node);
+}
+
+function ExportAllDeclaration(node) {
+  this.word('export');
+  this.space();
+
+  if (node.exportKind === 'type') {
+    this.word('type');
+    this.space();
+  }
+
+  this.token('*');
+  this.space();
+  this.word('from');
+  this.space();
+  this.print(node.source, node);
+  this.printAssertions(node);
+  this.semicolon();
+}
+
+function ExportNamedDeclaration(node) {
+  if (
+    this.format.decoratorsBeforeExport &&
+    isClassDeclaration(node.declaration)
+  ) {
+    this.printJoin(node.declaration.decorators, node);
+  }
+
+  this.word('export');
+  this.space();
+  ExportDeclaration.apply(this, arguments);
+}
+
+function ExportDefaultDeclaration(node) {
+  if (
+    this.format.decoratorsBeforeExport &&
+    isClassDeclaration(node.declaration)
+  ) {
+    this.printJoin(node.declaration.decorators, node);
+  }
+
+  this.word('export');
+  this.space();
+  this.word('default');
+  this.space();
+  ExportDeclaration.apply(this, arguments);
+}
+
+function ExportDeclaration(node) {
+  if (node.declaration) {
+    const declar = node.declaration;
+    this.print(declar, node);
+    if (!isStatement(declar)) this.semicolon();
+  } else {
+    if (node.exportKind === 'type') {
+      this.word('type');
+      this.space();
+    }
+
+    const specifiers = node.specifiers.slice(0);
+    let hasSpecial = false;
+
+    for (;;) {
+      const first = specifiers[0];
+
+      if (
+        isExportDefaultSpecifier(first) ||
+        isExportNamespaceSpecifier(first)
+      ) {
+        hasSpecial = true;
+        this.print(specifiers.shift(), node);
+
+        if (specifiers.length) {
+          this.token(',');
+          this.space();
+        }
+      } else {
+        break;
+      }
+    }
+
+    if (specifiers.length || (!specifiers.length && !hasSpecial)) {
+      this.token('{');
+
+      if (specifiers.length) {
+        this.space();
+        this.printList(specifiers, node);
+        this.space();
+      }
+
+      this.token('}');
+    }
+
+    if (node.source) {
+      this.space();
+      this.word('from');
+      this.space();
+      this.print(node.source, node);
+      this.printAssertions(node);
+    }
+
+    this.semicolon();
+  }
+}
+
+function ImportDeclaration(node) {
+  this.word('import');
+  this.space();
+  const isTypeKind = node.importKind === 'type' || node.importKind === 'typeof';
+
+  if (isTypeKind) {
+    this.word(node.importKind);
+    this.space();
+  }
+
+  const specifiers = node.specifiers.slice(0);
+  const hasSpecifiers = !!specifiers.length;
+
+  while (hasSpecifiers) {
+    const first = specifiers[0];
+
+    if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) {
+      this.print(specifiers.shift(), node);
+
+      if (specifiers.length) {
+        this.token(',');
+        this.space();
+      }
+    } else {
+      break;
+    }
+  }
+
+  if (specifiers.length) {
+    this.token('{');
+    this.space();
+    this.printList(specifiers, node);
+    this.space();
+    this.token('}');
+  } else if (isTypeKind && !hasSpecifiers) {
+    this.token('{');
+    this.token('}');
+  }
+
+  if (hasSpecifiers || isTypeKind) {
+    this.space();
+    this.word('from');
+    this.space();
+  }
+
+  this.print(node.source, node);
+  this.printAssertions(node);
+  {
+    var _node$attributes;
+
+    if (
+      (_node$attributes = node.attributes) != null &&
+      _node$attributes.length
+    ) {
+      this.space();
+      this.word('with');
+      this.space();
+      this.printList(node.attributes, node);
+    }
+  }
+  this.semicolon();
+}
+
+function ImportAttribute(node) {
+  this.print(node.key);
+  this.token(':');
+  this.space();
+  this.print(node.value);
+}
+
+function ImportNamespaceSpecifier(node) {
+  this.token('*');
+  this.space();
+  this.word('as');
+  this.space();
+  this.print(node.local, node);
+}

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

@@ -0,0 +1,329 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.BreakStatement = void 0;
+exports.CatchClause = CatchClause;
+exports.ContinueStatement = void 0;
+exports.DebuggerStatement = DebuggerStatement;
+exports.DoWhileStatement = DoWhileStatement;
+exports.ForOfStatement = exports.ForInStatement = void 0;
+exports.ForStatement = ForStatement;
+exports.IfStatement = IfStatement;
+exports.LabeledStatement = LabeledStatement;
+exports.ReturnStatement = void 0;
+exports.SwitchCase = SwitchCase;
+exports.SwitchStatement = SwitchStatement;
+exports.ThrowStatement = void 0;
+exports.TryStatement = TryStatement;
+exports.VariableDeclaration = VariableDeclaration;
+exports.VariableDeclarator = VariableDeclarator;
+exports.WhileStatement = WhileStatement;
+exports.WithStatement = WithStatement;
+
+var _t = require('@babel/types');
+
+const { isFor, isForStatement, isIfStatement, isStatement } = _t;
+
+function WithStatement(node) {
+  this.word('with');
+  this.space();
+  this.token('(');
+  this.print(node.object, node);
+  this.token(')');
+  this.printBlock(node);
+}
+
+function IfStatement(node) {
+  this.word('if');
+  this.space();
+  this.token('(');
+  this.print(node.test, node);
+  this.token(')');
+  this.space();
+  const needsBlock =
+    node.alternate && isIfStatement(getLastStatement(node.consequent));
+
+  if (needsBlock) {
+    this.token('{');
+    this.newline();
+    this.indent();
+  }
+
+  this.printAndIndentOnComments(node.consequent, node);
+
+  if (needsBlock) {
+    this.dedent();
+    this.newline();
+    this.token('}');
+  }
+
+  if (node.alternate) {
+    if (this.endsWith(125)) this.space();
+    this.word('else');
+    this.space();
+    this.printAndIndentOnComments(node.alternate, node);
+  }
+}
+
+function getLastStatement(statement) {
+  if (!isStatement(statement.body)) return statement;
+  return getLastStatement(statement.body);
+}
+
+function ForStatement(node) {
+  this.word('for');
+  this.space();
+  this.token('(');
+  this.inForStatementInitCounter++;
+  this.print(node.init, node);
+  this.inForStatementInitCounter--;
+  this.token(';');
+
+  if (node.test) {
+    this.space();
+    this.print(node.test, node);
+  }
+
+  this.token(';');
+
+  if (node.update) {
+    this.space();
+    this.print(node.update, node);
+  }
+
+  this.token(')');
+  this.printBlock(node);
+}
+
+function WhileStatement(node) {
+  this.word('while');
+  this.space();
+  this.token('(');
+  this.print(node.test, node);
+  this.token(')');
+  this.printBlock(node);
+}
+
+const buildForXStatement = function (op) {
+  return function (node) {
+    this.word('for');
+    this.space();
+
+    if (op === 'of' && node.await) {
+      this.word('await');
+      this.space();
+    }
+
+    this.token('(');
+    this.print(node.left, node);
+    this.space();
+    this.word(op);
+    this.space();
+    this.print(node.right, node);
+    this.token(')');
+    this.printBlock(node);
+  };
+};
+
+const ForInStatement = buildForXStatement('in');
+exports.ForInStatement = ForInStatement;
+const ForOfStatement = buildForXStatement('of');
+exports.ForOfStatement = ForOfStatement;
+
+function DoWhileStatement(node) {
+  this.word('do');
+  this.space();
+  this.print(node.body, node);
+  this.space();
+  this.word('while');
+  this.space();
+  this.token('(');
+  this.print(node.test, node);
+  this.token(')');
+  this.semicolon();
+}
+
+function buildLabelStatement(prefix, key = 'label') {
+  return function (node) {
+    this.word(prefix);
+    const label = node[key];
+
+    if (label) {
+      this.space();
+      const isLabel = key == 'label';
+      const terminatorState = this.startTerminatorless(isLabel);
+      this.print(label, node);
+      this.endTerminatorless(terminatorState);
+    }
+
+    this.semicolon();
+  };
+}
+
+const ContinueStatement = buildLabelStatement('continue');
+exports.ContinueStatement = ContinueStatement;
+const ReturnStatement = buildLabelStatement('return', 'argument');
+exports.ReturnStatement = ReturnStatement;
+const BreakStatement = buildLabelStatement('break');
+exports.BreakStatement = BreakStatement;
+const ThrowStatement = buildLabelStatement('throw', 'argument');
+exports.ThrowStatement = ThrowStatement;
+
+function LabeledStatement(node) {
+  this.print(node.label, node);
+  this.token(':');
+  this.space();
+  this.print(node.body, node);
+}
+
+function TryStatement(node) {
+  this.word('try');
+  this.space();
+  this.print(node.block, node);
+  this.space();
+
+  if (node.handlers) {
+    this.print(node.handlers[0], node);
+  } else {
+    this.print(node.handler, node);
+  }
+
+  if (node.finalizer) {
+    this.space();
+    this.word('finally');
+    this.space();
+    this.print(node.finalizer, node);
+  }
+}
+
+function CatchClause(node) {
+  this.word('catch');
+  this.space();
+
+  if (node.param) {
+    this.token('(');
+    this.print(node.param, node);
+    this.print(node.param.typeAnnotation, node);
+    this.token(')');
+    this.space();
+  }
+
+  this.print(node.body, node);
+}
+
+function SwitchStatement(node) {
+  this.word('switch');
+  this.space();
+  this.token('(');
+  this.print(node.discriminant, node);
+  this.token(')');
+  this.space();
+  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('}');
+}
+
+function SwitchCase(node) {
+  if (node.test) {
+    this.word('case');
+    this.space();
+    this.print(node.test, node);
+    this.token(':');
+  } else {
+    this.word('default');
+    this.token(':');
+  }
+
+  if (node.consequent.length) {
+    this.newline();
+    this.printSequence(node.consequent, node, {
+      indent: true,
+    });
+  }
+}
+
+function DebuggerStatement() {
+  this.word('debugger');
+  this.semicolon();
+}
+
+function variableDeclarationIndent() {
+  this.token(',');
+  this.newline();
+
+  if (this.endsWith(10)) {
+    for (let i = 0; i < 4; i++) this.space(true);
+  }
+}
+
+function constDeclarationIndent() {
+  this.token(',');
+  this.newline();
+
+  if (this.endsWith(10)) {
+    for (let i = 0; i < 6; i++) this.space(true);
+  }
+}
+
+function VariableDeclaration(node, parent) {
+  if (node.declare) {
+    this.word('declare');
+    this.space();
+  }
+
+  this.word(node.kind);
+  this.space();
+  let hasInits = false;
+
+  if (!isFor(parent)) {
+    for (const declar of node.declarations) {
+      if (declar.init) {
+        hasInits = true;
+      }
+    }
+  }
+
+  let separator;
+
+  if (hasInits) {
+    separator =
+      node.kind === 'const' ?
+        constDeclarationIndent
+      : variableDeclarationIndent;
+  }
+
+  this.printList(node.declarations, node, {
+    separator,
+  });
+
+  if (isFor(parent)) {
+    if (isForStatement(parent)) {
+      if (parent.init === node) return;
+    } else {
+      if (parent.left === node) return;
+    }
+  }
+
+  this.semicolon();
+}
+
+function VariableDeclarator(node) {
+  this.print(node.id, node);
+  if (node.definite) this.token('!');
+  this.print(node.id.typeAnnotation, node);
+
+  if (node.init) {
+    this.space();
+    this.token('=');
+    this.space();
+    this.print(node.init, node);
+  }
+}

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

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+exports.TemplateElement = TemplateElement;
+exports.TemplateLiteral = TemplateLiteral;
+
+function TaggedTemplateExpression(node) {
+  this.print(node.tag, node);
+  this.print(node.typeParameters, node);
+  this.print(node.quasi, 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 ? '`' : '${');
+  this.token(value);
+}
+
+function TemplateLiteral(node) {
+  const quasis = node.quasis;
+
+  for (let i = 0; i < quasis.length; i++) {
+    this.print(quasis[i], node);
+
+    if (i + 1 < quasis.length) {
+      this.print(node.expressions[i], node);
+    }
+  }
+}

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

@@ -0,0 +1,295 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.ArgumentPlaceholder = ArgumentPlaceholder;
+exports.ArrayPattern = exports.ArrayExpression = ArrayExpression;
+exports.BigIntLiteral = BigIntLiteral;
+exports.BooleanLiteral = BooleanLiteral;
+exports.DecimalLiteral = DecimalLiteral;
+exports.Identifier = Identifier;
+exports.NullLiteral = NullLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.ObjectPattern = exports.ObjectExpression = ObjectExpression;
+exports.ObjectMethod = ObjectMethod;
+exports.ObjectProperty = ObjectProperty;
+exports.PipelineBareFunction = PipelineBareFunction;
+exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference;
+exports.PipelineTopicExpression = PipelineTopicExpression;
+exports.RecordExpression = RecordExpression;
+exports.RegExpLiteral = RegExpLiteral;
+exports.SpreadElement = exports.RestElement = RestElement;
+exports.StringLiteral = StringLiteral;
+exports.TopicReference = TopicReference;
+exports.TupleExpression = TupleExpression;
+
+var _t = require('@babel/types');
+
+var _jsesc = require('jsesc');
+
+const { isAssignmentPattern, isIdentifier } = _t;
+
+function Identifier(node) {
+  this.exactSource(node.loc, () => {
+    this.word(node.name);
+  });
+}
+
+function ArgumentPlaceholder() {
+  this.token('?');
+}
+
+function RestElement(node) {
+  this.token('...');
+  this.print(node.argument, node);
+}
+
+function ObjectExpression(node) {
+  const props = node.properties;
+  this.token('{');
+  this.printInnerComments(node);
+
+  if (props.length) {
+    this.space();
+    this.printList(props, node, {
+      indent: true,
+      statement: true,
+    });
+    this.space();
+  }
+
+  this.token('}');
+}
+
+function ObjectMethod(node) {
+  this.printJoin(node.decorators, node);
+
+  this._methodHead(node);
+
+  this.space();
+  this.print(node.body, node);
+}
+
+function ObjectProperty(node) {
+  this.printJoin(node.decorators, node);
+
+  if (node.computed) {
+    this.token('[');
+    this.print(node.key, node);
+    this.token(']');
+  } else {
+    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
+    ) {
+      return;
+    }
+  }
+
+  this.token(':');
+  this.space();
+  this.print(node.value, node);
+}
+
+function ArrayExpression(node) {
+  const elems = node.elements;
+  const len = elems.length;
+  this.token('[');
+  this.printInnerComments(node);
+
+  for (let i = 0; i < elems.length; i++) {
+    const elem = elems[i];
+
+    if (elem) {
+      if (i > 0) this.space();
+      this.print(elem, node);
+      if (i < len - 1) this.token(',');
+    } else {
+      this.token(',');
+    }
+  }
+
+  this.token(']');
+}
+
+function RecordExpression(node) {
+  const props = node.properties;
+  let startToken;
+  let endToken;
+
+  if (this.format.recordAndTupleSyntaxType === 'bar') {
+    startToken = '{|';
+    endToken = '|}';
+  } else if (this.format.recordAndTupleSyntaxType === 'hash') {
+    startToken = '#{';
+    endToken = '}';
+  } else {
+    throw new Error(
+      `The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`
+    );
+  }
+
+  this.token(startToken);
+  this.printInnerComments(node);
+
+  if (props.length) {
+    this.space();
+    this.printList(props, node, {
+      indent: true,
+      statement: true,
+    });
+    this.space();
+  }
+
+  this.token(endToken);
+}
+
+function TupleExpression(node) {
+  const elems = node.elements;
+  const len = elems.length;
+  let startToken;
+  let endToken;
+
+  if (this.format.recordAndTupleSyntaxType === 'bar') {
+    startToken = '[|';
+    endToken = '|]';
+  } else if (this.format.recordAndTupleSyntaxType === 'hash') {
+    startToken = '#[';
+    endToken = ']';
+  } else {
+    throw new Error(
+      `${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`
+    );
+  }
+
+  this.token(startToken);
+  this.printInnerComments(node);
+
+  for (let i = 0; i < elems.length; i++) {
+    const elem = elems[i];
+
+    if (elem) {
+      if (i > 0) this.space();
+      this.print(elem, node);
+      if (i < len - 1) this.token(',');
+    }
+  }
+
+  this.token(endToken);
+}
+
+function RegExpLiteral(node) {
+  this.word(`/${node.pattern}/${node.flags}`);
+}
+
+function BooleanLiteral(node) {
+  this.word(node.value ? 'true' : 'false');
+}
+
+function NullLiteral() {
+  this.word('null');
+}
+
+function NumericLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+  const opts = this.format.jsescOption;
+  const value = node.value + '';
+
+  if (opts.numbers) {
+    this.number(_jsesc(node.value, opts));
+  } else if (raw == null) {
+    this.number(value);
+  } else if (this.format.minified) {
+    this.number(raw.length < value.length ? raw : value);
+  } else {
+    this.number(raw);
+  }
+}
+
+function StringLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (!this.format.minified && raw != null) {
+    this.token(raw);
+    return;
+  }
+
+  const val = _jsesc(
+    node.value,
+    Object.assign(
+      this.format.jsescOption,
+      this.format.jsonCompatibleStrings && {
+        json: true,
+      }
+    )
+  );
+
+  return this.token(val);
+}
+
+function BigIntLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (!this.format.minified && raw != null) {
+    this.word(raw);
+    return;
+  }
+
+  this.word(node.value + 'n');
+}
+
+function DecimalLiteral(node) {
+  const raw = this.getPossibleRaw(node);
+
+  if (!this.format.minified && raw != null) {
+    this.word(raw);
+    return;
+  }
+
+  this.word(node.value + 'm');
+}
+
+const validTopicTokenSet = new Set(['^^', '@@', '^', '%', '#']);
+
+function TopicReference() {
+  const { 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)
+    );
+    throw new Error(
+      `The "topicToken" generator option must be one of ` +
+        `${validTopics.join(', ')} (${givenTopicTokenJSON} received instead).`
+    );
+  }
+}
+
+function PipelineTopicExpression(node) {
+  this.print(node.expression, node);
+}
+
+function PipelineBareFunction(node) {
+  this.print(node.callee, node);
+}
+
+function PipelinePrimaryTopicReference() {
+  this.token('#');
+}

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

@@ -0,0 +1,780 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.TSAnyKeyword = TSAnyKeyword;
+exports.TSArrayType = TSArrayType;
+exports.TSAsExpression = TSAsExpression;
+exports.TSBigIntKeyword = TSBigIntKeyword;
+exports.TSBooleanKeyword = TSBooleanKeyword;
+exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
+exports.TSConditionalType = TSConditionalType;
+exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
+exports.TSConstructorType = TSConstructorType;
+exports.TSDeclareFunction = TSDeclareFunction;
+exports.TSDeclareMethod = TSDeclareMethod;
+exports.TSEnumDeclaration = TSEnumDeclaration;
+exports.TSEnumMember = TSEnumMember;
+exports.TSExportAssignment = TSExportAssignment;
+exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
+exports.TSExternalModuleReference = TSExternalModuleReference;
+exports.TSFunctionType = TSFunctionType;
+exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
+exports.TSImportType = TSImportType;
+exports.TSIndexSignature = TSIndexSignature;
+exports.TSIndexedAccessType = TSIndexedAccessType;
+exports.TSInferType = TSInferType;
+exports.TSInstantiationExpression = TSInstantiationExpression;
+exports.TSInterfaceBody = TSInterfaceBody;
+exports.TSInterfaceDeclaration = TSInterfaceDeclaration;
+exports.TSIntersectionType = TSIntersectionType;
+exports.TSIntrinsicKeyword = TSIntrinsicKeyword;
+exports.TSLiteralType = TSLiteralType;
+exports.TSMappedType = TSMappedType;
+exports.TSMethodSignature = TSMethodSignature;
+exports.TSModuleBlock = TSModuleBlock;
+exports.TSModuleDeclaration = TSModuleDeclaration;
+exports.TSNamedTupleMember = TSNamedTupleMember;
+exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
+exports.TSNeverKeyword = TSNeverKeyword;
+exports.TSNonNullExpression = TSNonNullExpression;
+exports.TSNullKeyword = TSNullKeyword;
+exports.TSNumberKeyword = TSNumberKeyword;
+exports.TSObjectKeyword = TSObjectKeyword;
+exports.TSOptionalType = TSOptionalType;
+exports.TSParameterProperty = TSParameterProperty;
+exports.TSParenthesizedType = TSParenthesizedType;
+exports.TSPropertySignature = TSPropertySignature;
+exports.TSQualifiedName = TSQualifiedName;
+exports.TSRestType = TSRestType;
+exports.TSStringKeyword = TSStringKeyword;
+exports.TSSymbolKeyword = TSSymbolKeyword;
+exports.TSThisType = TSThisType;
+exports.TSTupleType = TSTupleType;
+exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
+exports.TSTypeAnnotation = TSTypeAnnotation;
+exports.TSTypeAssertion = TSTypeAssertion;
+exports.TSTypeLiteral = TSTypeLiteral;
+exports.TSTypeOperator = TSTypeOperator;
+exports.TSTypeParameter = TSTypeParameter;
+exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation =
+  TSTypeParameterInstantiation;
+exports.TSTypePredicate = TSTypePredicate;
+exports.TSTypeQuery = TSTypeQuery;
+exports.TSTypeReference = TSTypeReference;
+exports.TSUndefinedKeyword = TSUndefinedKeyword;
+exports.TSUnionType = TSUnionType;
+exports.TSUnknownKeyword = TSUnknownKeyword;
+exports.TSVoidKeyword = TSVoidKeyword;
+exports.tsPrintBraced = tsPrintBraced;
+exports.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers;
+exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType;
+exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName;
+exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;
+exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody;
+exports.tsPrintUnionOrIntersectionType = tsPrintUnionOrIntersectionType;
+
+function TSTypeAnnotation(node) {
+  this.token(':');
+  this.space();
+  if (node.optional) this.token('?');
+  this.print(node.typeAnnotation, node);
+}
+
+function TSTypeParameterInstantiation(node, parent) {
+  this.token('<');
+  this.printList(node.params, node, {});
+
+  if (parent.type === 'ArrowFunctionExpression' && node.params.length === 1) {
+    this.token(',');
+  }
+
+  this.token('>');
+}
+
+function TSTypeParameter(node) {
+  if (node.in) {
+    this.word('in');
+    this.space();
+  }
+
+  if (node.out) {
+    this.word('out');
+    this.space();
+  }
+
+  this.word(node.name);
+
+  if (node.constraint) {
+    this.space();
+    this.word('extends');
+    this.space();
+    this.print(node.constraint, node);
+  }
+
+  if (node.default) {
+    this.space();
+    this.token('=');
+    this.space();
+    this.print(node.default, node);
+  }
+}
+
+function TSParameterProperty(node) {
+  if (node.accessibility) {
+    this.word(node.accessibility);
+    this.space();
+  }
+
+  if (node.readonly) {
+    this.word('readonly');
+    this.space();
+  }
+
+  this._param(node.parameter);
+}
+
+function TSDeclareFunction(node) {
+  if (node.declare) {
+    this.word('declare');
+    this.space();
+  }
+
+  this._functionHead(node);
+
+  this.token(';');
+}
+
+function TSDeclareMethod(node) {
+  this._classMethodHead(node);
+
+  this.token(';');
+}
+
+function TSQualifiedName(node) {
+  this.print(node.left, node);
+  this.token('.');
+  this.print(node.right, node);
+}
+
+function TSCallSignatureDeclaration(node) {
+  this.tsPrintSignatureDeclarationBase(node);
+  this.token(';');
+}
+
+function TSConstructSignatureDeclaration(node) {
+  this.word('new');
+  this.space();
+  this.tsPrintSignatureDeclarationBase(node);
+  this.token(';');
+}
+
+function TSPropertySignature(node) {
+  const { readonly, initializer } = node;
+
+  if (readonly) {
+    this.word('readonly');
+    this.space();
+  }
+
+  this.tsPrintPropertyOrMethodName(node);
+  this.print(node.typeAnnotation, node);
+
+  if (initializer) {
+    this.space();
+    this.token('=');
+    this.space();
+    this.print(initializer, node);
+  }
+
+  this.token(';');
+}
+
+function tsPrintPropertyOrMethodName(node) {
+  if (node.computed) {
+    this.token('[');
+  }
+
+  this.print(node.key, node);
+
+  if (node.computed) {
+    this.token(']');
+  }
+
+  if (node.optional) {
+    this.token('?');
+  }
+}
+
+function TSMethodSignature(node) {
+  const { kind } = node;
+
+  if (kind === 'set' || kind === 'get') {
+    this.word(kind);
+    this.space();
+  }
+
+  this.tsPrintPropertyOrMethodName(node);
+  this.tsPrintSignatureDeclarationBase(node);
+  this.token(';');
+}
+
+function TSIndexSignature(node) {
+  const { readonly, static: isStatic } = node;
+
+  if (isStatic) {
+    this.word('static');
+    this.space();
+  }
+
+  if (readonly) {
+    this.word('readonly');
+    this.space();
+  }
+
+  this.token('[');
+
+  this._parameters(node.parameters, node);
+
+  this.token(']');
+  this.print(node.typeAnnotation, node);
+  this.token(';');
+}
+
+function TSAnyKeyword() {
+  this.word('any');
+}
+
+function TSBigIntKeyword() {
+  this.word('bigint');
+}
+
+function TSUnknownKeyword() {
+  this.word('unknown');
+}
+
+function TSNumberKeyword() {
+  this.word('number');
+}
+
+function TSObjectKeyword() {
+  this.word('object');
+}
+
+function TSBooleanKeyword() {
+  this.word('boolean');
+}
+
+function TSStringKeyword() {
+  this.word('string');
+}
+
+function TSSymbolKeyword() {
+  this.word('symbol');
+}
+
+function TSVoidKeyword() {
+  this.word('void');
+}
+
+function TSUndefinedKeyword() {
+  this.word('undefined');
+}
+
+function TSNullKeyword() {
+  this.word('null');
+}
+
+function TSNeverKeyword() {
+  this.word('never');
+}
+
+function TSIntrinsicKeyword() {
+  this.word('intrinsic');
+}
+
+function TSThisType() {
+  this.word('this');
+}
+
+function TSFunctionType(node) {
+  this.tsPrintFunctionOrConstructorType(node);
+}
+
+function TSConstructorType(node) {
+  if (node.abstract) {
+    this.word('abstract');
+    this.space();
+  }
+
+  this.word('new');
+  this.space();
+  this.tsPrintFunctionOrConstructorType(node);
+}
+
+function tsPrintFunctionOrConstructorType(node) {
+  const { typeParameters } = node;
+  const parameters = node.parameters;
+  this.print(typeParameters, node);
+  this.token('(');
+
+  this._parameters(parameters, node);
+
+  this.token(')');
+  this.space();
+  this.token('=>');
+  this.space();
+  const returnType = node.typeAnnotation;
+  this.print(returnType.typeAnnotation, node);
+}
+
+function TSTypeReference(node) {
+  this.print(node.typeName, node);
+  this.print(node.typeParameters, node);
+}
+
+function TSTypePredicate(node) {
+  if (node.asserts) {
+    this.word('asserts');
+    this.space();
+  }
+
+  this.print(node.parameterName);
+
+  if (node.typeAnnotation) {
+    this.space();
+    this.word('is');
+    this.space();
+    this.print(node.typeAnnotation.typeAnnotation);
+  }
+}
+
+function TSTypeQuery(node) {
+  this.word('typeof');
+  this.space();
+  this.print(node.exprName);
+
+  if (node.typeParameters) {
+    this.print(node.typeParameters, node);
+  }
+}
+
+function TSTypeLiteral(node) {
+  this.tsPrintTypeLiteralOrInterfaceBody(node.members, node);
+}
+
+function tsPrintTypeLiteralOrInterfaceBody(members, node) {
+  this.tsPrintBraced(members, node);
+}
+
+function tsPrintBraced(members, node) {
+  this.token('{');
+
+  if (members.length) {
+    this.indent();
+    this.newline();
+
+    for (const member of members) {
+      this.print(member, node);
+      this.newline();
+    }
+
+    this.dedent();
+    this.rightBrace();
+  } else {
+    this.token('}');
+  }
+}
+
+function TSArrayType(node) {
+  this.print(node.elementType, node);
+  this.token('[]');
+}
+
+function TSTupleType(node) {
+  this.token('[');
+  this.printList(node.elementTypes, node);
+  this.token(']');
+}
+
+function TSOptionalType(node) {
+  this.print(node.typeAnnotation, node);
+  this.token('?');
+}
+
+function TSRestType(node) {
+  this.token('...');
+  this.print(node.typeAnnotation, node);
+}
+
+function TSNamedTupleMember(node) {
+  this.print(node.label, node);
+  if (node.optional) this.token('?');
+  this.token(':');
+  this.space();
+  this.print(node.elementType, node);
+}
+
+function TSUnionType(node) {
+  this.tsPrintUnionOrIntersectionType(node, '|');
+}
+
+function TSIntersectionType(node) {
+  this.tsPrintUnionOrIntersectionType(node, '&');
+}
+
+function tsPrintUnionOrIntersectionType(node, sep) {
+  this.printJoin(node.types, node, {
+    separator() {
+      this.space();
+      this.token(sep);
+      this.space();
+    },
+  });
+}
+
+function TSConditionalType(node) {
+  this.print(node.checkType);
+  this.space();
+  this.word('extends');
+  this.space();
+  this.print(node.extendsType);
+  this.space();
+  this.token('?');
+  this.space();
+  this.print(node.trueType);
+  this.space();
+  this.token(':');
+  this.space();
+  this.print(node.falseType);
+}
+
+function TSInferType(node) {
+  this.token('infer');
+  this.space();
+  this.print(node.typeParameter);
+}
+
+function TSParenthesizedType(node) {
+  this.token('(');
+  this.print(node.typeAnnotation, node);
+  this.token(')');
+}
+
+function TSTypeOperator(node) {
+  this.word(node.operator);
+  this.space();
+  this.print(node.typeAnnotation, node);
+}
+
+function TSIndexedAccessType(node) {
+  this.print(node.objectType, node);
+  this.token('[');
+  this.print(node.indexType, node);
+  this.token(']');
+}
+
+function TSMappedType(node) {
+  const { nameType, optional, readonly, typeParameter } = node;
+  this.token('{');
+  this.space();
+
+  if (readonly) {
+    tokenIfPlusMinus(this, readonly);
+    this.word('readonly');
+    this.space();
+  }
+
+  this.token('[');
+  this.word(typeParameter.name);
+  this.space();
+  this.word('in');
+  this.space();
+  this.print(typeParameter.constraint, typeParameter);
+
+  if (nameType) {
+    this.space();
+    this.word('as');
+    this.space();
+    this.print(nameType, node);
+  }
+
+  this.token(']');
+
+  if (optional) {
+    tokenIfPlusMinus(this, optional);
+    this.token('?');
+  }
+
+  this.token(':');
+  this.space();
+  this.print(node.typeAnnotation, node);
+  this.space();
+  this.token('}');
+}
+
+function tokenIfPlusMinus(self, tok) {
+  if (tok !== true) {
+    self.token(tok);
+  }
+}
+
+function TSLiteralType(node) {
+  this.print(node.literal, node);
+}
+
+function TSExpressionWithTypeArguments(node) {
+  this.print(node.expression, node);
+  this.print(node.typeParameters, node);
+}
+
+function TSInterfaceDeclaration(node) {
+  const { declare, id, typeParameters, extends: extendz, body } = node;
+
+  if (declare) {
+    this.word('declare');
+    this.space();
+  }
+
+  this.word('interface');
+  this.space();
+  this.print(id, node);
+  this.print(typeParameters, node);
+
+  if (extendz != null && extendz.length) {
+    this.space();
+    this.word('extends');
+    this.space();
+    this.printList(extendz, node);
+  }
+
+  this.space();
+  this.print(body, node);
+}
+
+function TSInterfaceBody(node) {
+  this.tsPrintTypeLiteralOrInterfaceBody(node.body, node);
+}
+
+function TSTypeAliasDeclaration(node) {
+  const { declare, id, typeParameters, typeAnnotation } = node;
+
+  if (declare) {
+    this.word('declare');
+    this.space();
+  }
+
+  this.word('type');
+  this.space();
+  this.print(id, node);
+  this.print(typeParameters, node);
+  this.space();
+  this.token('=');
+  this.space();
+  this.print(typeAnnotation, node);
+  this.token(';');
+}
+
+function TSAsExpression(node) {
+  const { expression, typeAnnotation } = node;
+  this.print(expression, node);
+  this.space();
+  this.word('as');
+  this.space();
+  this.print(typeAnnotation, node);
+}
+
+function TSTypeAssertion(node) {
+  const { typeAnnotation, expression } = node;
+  this.token('<');
+  this.print(typeAnnotation, node);
+  this.token('>');
+  this.space();
+  this.print(expression, node);
+}
+
+function TSInstantiationExpression(node) {
+  this.print(node.expression, node);
+  this.print(node.typeParameters, node);
+}
+
+function TSEnumDeclaration(node) {
+  const { declare, const: isConst, id, members } = node;
+
+  if (declare) {
+    this.word('declare');
+    this.space();
+  }
+
+  if (isConst) {
+    this.word('const');
+    this.space();
+  }
+
+  this.word('enum');
+  this.space();
+  this.print(id, node);
+  this.space();
+  this.tsPrintBraced(members, node);
+}
+
+function TSEnumMember(node) {
+  const { id, initializer } = node;
+  this.print(id, node);
+
+  if (initializer) {
+    this.space();
+    this.token('=');
+    this.space();
+    this.print(initializer, node);
+  }
+
+  this.token(',');
+}
+
+function TSModuleDeclaration(node) {
+  const { declare, id } = node;
+
+  if (declare) {
+    this.word('declare');
+    this.space();
+  }
+
+  if (!node.global) {
+    this.word(id.type === 'Identifier' ? 'namespace' : 'module');
+    this.space();
+  }
+
+  this.print(id, node);
+
+  if (!node.body) {
+    this.token(';');
+    return;
+  }
+
+  let body = node.body;
+
+  while (body.type === 'TSModuleDeclaration') {
+    this.token('.');
+    this.print(body.id, body);
+    body = body.body;
+  }
+
+  this.space();
+  this.print(body, node);
+}
+
+function TSModuleBlock(node) {
+  this.tsPrintBraced(node.body, node);
+}
+
+function TSImportType(node) {
+  const { argument, qualifier, typeParameters } = node;
+  this.word('import');
+  this.token('(');
+  this.print(argument, node);
+  this.token(')');
+
+  if (qualifier) {
+    this.token('.');
+    this.print(qualifier, node);
+  }
+
+  if (typeParameters) {
+    this.print(typeParameters, node);
+  }
+}
+
+function TSImportEqualsDeclaration(node) {
+  const { isExport, id, moduleReference } = node;
+
+  if (isExport) {
+    this.word('export');
+    this.space();
+  }
+
+  this.word('import');
+  this.space();
+  this.print(id, node);
+  this.space();
+  this.token('=');
+  this.space();
+  this.print(moduleReference, node);
+  this.token(';');
+}
+
+function TSExternalModuleReference(node) {
+  this.token('require(');
+  this.print(node.expression, node);
+  this.token(')');
+}
+
+function TSNonNullExpression(node) {
+  this.print(node.expression, node);
+  this.token('!');
+}
+
+function TSExportAssignment(node) {
+  this.word('export');
+  this.space();
+  this.token('=');
+  this.space();
+  this.print(node.expression, node);
+  this.token(';');
+}
+
+function TSNamespaceExportDeclaration(node) {
+  this.word('export');
+  this.space();
+  this.word('as');
+  this.space();
+  this.word('namespace');
+  this.space();
+  this.print(node.id, node);
+}
+
+function tsPrintSignatureDeclarationBase(node) {
+  const { typeParameters } = node;
+  const parameters = node.parameters;
+  this.print(typeParameters, node);
+  this.token('(');
+
+  this._parameters(parameters, node);
+
+  this.token(')');
+  const returnType = node.typeAnnotation;
+  this.print(returnType, node);
+}
+
+function tsPrintClassMemberModifiers(node, isField) {
+  if (isField && node.declare) {
+    this.word('declare');
+    this.space();
+  }
+
+  if (node.accessibility) {
+    this.word(node.accessibility);
+    this.space();
+  }
+
+  if (node.static) {
+    this.word('static');
+    this.space();
+  }
+
+  if (node.override) {
+    this.word('override');
+    this.space();
+  }
+
+  if (node.abstract) {
+    this.word('abstract');
+    this.space();
+  }
+
+  if (isField && node.readonly) {
+    this.word('readonly');
+    this.space();
+  }
+}

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

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.CodeGenerator = void 0;
+exports.default = generate;
+
+var _sourceMap = require('./source-map');
+
+var _printer = require('./printer');
+
+class Generator extends _printer.default {
+  constructor(ast, opts = {}, code) {
+    const format = normalizeOptions(code, opts);
+    const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
+    super(format, map);
+    this.ast = void 0;
+    this.ast = ast;
+  }
+
+  generate() {
+    return super.generate(this.ast);
+  }
+}
+
+function normalizeOptions(code, opts) {
+  const format = {
+    auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
+    auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
+    shouldPrintComment: opts.shouldPrintComment,
+    retainLines: opts.retainLines,
+    retainFunctionParens: opts.retainFunctionParens,
+    comments: opts.comments == null || opts.comments,
+    compact: opts.compact,
+    minified: opts.minified,
+    concise: opts.concise,
+    indent: {
+      adjustMultilineComment: true,
+      style: '  ',
+      base: 0,
+    },
+    decoratorsBeforeExport: !!opts.decoratorsBeforeExport,
+    jsescOption: Object.assign(
+      {
+        quotes: 'double',
+        wrap: true,
+        minimal: false,
+      },
+      opts.jsescOption
+    ),
+    recordAndTupleSyntaxType: opts.recordAndTupleSyntaxType,
+    topicToken: opts.topicToken,
+  };
+  {
+    format.jsonCompatibleStrings = opts.jsonCompatibleStrings;
+  }
+
+  if (format.minified) {
+    format.compact = true;
+
+    format.shouldPrintComment =
+      format.shouldPrintComment || (() => format.comments);
+  } else {
+    format.shouldPrintComment =
+      format.shouldPrintComment ||
+      ((value) =>
+        format.comments ||
+        value.indexOf('@license') >= 0 ||
+        value.indexOf('@preserve') >= 0);
+  }
+
+  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'}.`
+      );
+    }
+  }
+
+  if (format.compact) {
+    format.indent.adjustMultilineComment = false;
+  }
+
+  return format;
+}
+
+class CodeGenerator {
+  constructor(ast, opts, code) {
+    this._generator = void 0;
+    this._generator = new Generator(ast, opts, code);
+  }
+
+  generate() {
+    return this._generator.generate();
+  }
+}
+
+exports.CodeGenerator = CodeGenerator;
+
+function generate(ast, opts, code) {
+  const gen = new Generator(ast, opts, code);
+  return gen.generate();
+}

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

@@ -0,0 +1,114 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.needsParens = needsParens;
+exports.needsWhitespace = needsWhitespace;
+exports.needsWhitespaceAfter = needsWhitespaceAfter;
+exports.needsWhitespaceBefore = needsWhitespaceBefore;
+
+var whitespace = require('./whitespace');
+
+var parens = require('./parentheses');
+
+var _t = require('@babel/types');
+
+const {
+  FLIPPED_ALIAS_KEYS,
+  isCallExpression,
+  isExpressionStatement,
+  isMemberExpression,
+  isNewExpression,
+} = _t;
+
+function expandAliases(obj) {
+  const newObj = {};
+
+  function add(type, func) {
+    const fn = newObj[type];
+    newObj[type] =
+      fn ?
+        function (node, parent, stack) {
+          const result = fn(node, parent, stack);
+          return result == null ? func(node, parent, stack) : result;
+        }
+      : func;
+  }
+
+  for (const type of Object.keys(obj)) {
+    const aliases = FLIPPED_ALIAS_KEYS[type];
+
+    if (aliases) {
+      for (const alias of aliases) {
+        add(alias, obj[type]);
+      }
+    } else {
+      add(type, obj[type]);
+    }
+  }
+
+  return newObj;
+}
+
+const expandedParens = expandAliases(parens);
+const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
+const expandedWhitespaceList = expandAliases(whitespace.list);
+
+function find(obj, node, parent, printStack) {
+  const fn = obj[node.type];
+  return fn ? fn(node, parent, printStack) : null;
+}
+
+function isOrHasCallExpression(node) {
+  if (isCallExpression(node)) {
+    return true;
+  }
+
+  return isMemberExpression(node) && isOrHasCallExpression(node.object);
+}
+
+function needsWhitespace(node, parent, type) {
+  if (!node) return 0;
+
+  if (isExpressionStatement(node)) {
+    node = node.expression;
+  }
+
+  let linesInfo = find(expandedWhitespaceNodes, node, parent);
+
+  if (!linesInfo) {
+    const items = find(expandedWhitespaceList, node, parent);
+
+    if (items) {
+      for (let i = 0; i < items.length; i++) {
+        linesInfo = needsWhitespace(items[i], node, type);
+        if (linesInfo) break;
+      }
+    }
+  }
+
+  if (typeof linesInfo === 'object' && linesInfo !== null) {
+    return linesInfo[type] || 0;
+  }
+
+  return 0;
+}
+
+function needsWhitespaceBefore(node, parent) {
+  return needsWhitespace(node, parent, 'before');
+}
+
+function needsWhitespaceAfter(node, parent) {
+  return needsWhitespace(node, parent, 'after');
+}
+
+function needsParens(node, parent, printStack) {
+  if (!parent) return false;
+
+  if (isNewExpression(parent) && parent.callee === node) {
+    if (isOrHasCallExpression(node)) return true;
+  }
+
+  return find(expandedParens, node, parent, printStack);
+}

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

@@ -0,0 +1,473 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.AssignmentExpression = AssignmentExpression;
+exports.Binary = Binary;
+exports.BinaryExpression = BinaryExpression;
+exports.ClassExpression = ClassExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.DoExpression = DoExpression;
+exports.FunctionExpression = FunctionExpression;
+exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.Identifier = Identifier;
+exports.LogicalExpression = LogicalExpression;
+exports.NullableTypeAnnotation = NullableTypeAnnotation;
+exports.ObjectExpression = ObjectExpression;
+exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
+exports.OptionalCallExpression = exports.OptionalMemberExpression =
+  OptionalMemberExpression;
+exports.SequenceExpression = SequenceExpression;
+exports.TSAsExpression = TSAsExpression;
+exports.TSInferType = TSInferType;
+exports.TSInstantiationExpression = TSInstantiationExpression;
+exports.TSTypeAssertion = TSTypeAssertion;
+exports.TSIntersectionType = exports.TSUnionType = TSUnionType;
+exports.UnaryLike = UnaryLike;
+exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation =
+  UnionTypeAnnotation;
+exports.UpdateExpression = UpdateExpression;
+exports.AwaitExpression = exports.YieldExpression = YieldExpression;
+
+var _t = require('@babel/types');
+
+const {
+  isArrayTypeAnnotation,
+  isArrowFunctionExpression,
+  isAssignmentExpression,
+  isAwaitExpression,
+  isBinary,
+  isBinaryExpression,
+  isUpdateExpression,
+  isCallExpression,
+  isClassDeclaration,
+  isClassExpression,
+  isConditional,
+  isConditionalExpression,
+  isExportDeclaration,
+  isExportDefaultDeclaration,
+  isExpressionStatement,
+  isFor,
+  isForInStatement,
+  isForOfStatement,
+  isForStatement,
+  isFunctionExpression,
+  isIfStatement,
+  isIndexedAccessType,
+  isIntersectionTypeAnnotation,
+  isLogicalExpression,
+  isMemberExpression,
+  isNewExpression,
+  isNullableTypeAnnotation,
+  isObjectPattern,
+  isOptionalCallExpression,
+  isOptionalMemberExpression,
+  isReturnStatement,
+  isSequenceExpression,
+  isSwitchStatement,
+  isTSArrayType,
+  isTSAsExpression,
+  isTSInstantiationExpression,
+  isTSIntersectionType,
+  isTSNonNullExpression,
+  isTSOptionalType,
+  isTSRestType,
+  isTSTypeAssertion,
+  isTSUnionType,
+  isTaggedTemplateExpression,
+  isThrowStatement,
+  isTypeAnnotation,
+  isUnaryLike,
+  isUnionTypeAnnotation,
+  isVariableDeclarator,
+  isWhileStatement,
+  isYieldExpression,
+} = _t;
+const PRECEDENCE = {
+  '||': 0,
+  '??': 0,
+  '&&': 1,
+  '|': 2,
+  '^': 3,
+  '&': 4,
+  '==': 5,
+  '===': 5,
+  '!=': 5,
+  '!==': 5,
+  '<': 6,
+  '>': 6,
+  '<=': 6,
+  '>=': 6,
+  in: 6,
+  instanceof: 6,
+  '>>': 7,
+  '<<': 7,
+  '>>>': 7,
+  '+': 8,
+  '-': 8,
+  '*': 9,
+  '/': 9,
+  '%': 9,
+  '**': 10,
+};
+
+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);
+
+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]))
+  );
+}
+
+function UpdateExpression(node, parent) {
+  return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
+}
+
+function ObjectExpression(node, parent, printStack) {
+  return isFirstInContext(printStack, {
+    expressionStatement: true,
+    arrowBody: true,
+  });
+}
+
+function DoExpression(node, parent, printStack) {
+  return (
+    !node.async &&
+    isFirstInContext(printStack, {
+      expressionStatement: true,
+    })
+  );
+}
+
+function Binary(node, parent) {
+  if (
+    node.operator === '**' &&
+    isBinaryExpression(parent, {
+      operator: '**',
+    })
+  ) {
+    return parent.left === node;
+  }
+
+  if (isClassExtendsClause(node, parent)) {
+    return true;
+  }
+
+  if (
+    hasPostfixPart(node, parent) ||
+    isUnaryLike(parent) ||
+    isAwaitExpression(parent)
+  ) {
+    return true;
+  }
+
+  if (isBinary(parent)) {
+    const parentOp = parent.operator;
+    const parentPos = PRECEDENCE[parentOp];
+    const nodeOp = node.operator;
+    const nodePos = PRECEDENCE[nodeOp];
+
+    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)
+  );
+}
+
+function OptionalIndexedAccessType(node, parent) {
+  return isIndexedAccessType(parent, {
+    objectType: node,
+  });
+}
+
+function TSAsExpression() {
+  return true;
+}
+
+function TSTypeAssertion() {
+  return true;
+}
+
+function TSUnionType(node, parent) {
+  return (
+    isTSArrayType(parent) ||
+    isTSOptionalType(parent) ||
+    isTSIntersectionType(parent) ||
+    isTSUnionType(parent) ||
+    isTSRestType(parent)
+  );
+}
+
+function TSInferType(node, parent) {
+  return isTSArrayType(parent) || isTSOptionalType(parent);
+}
+
+function TSInstantiationExpression(node, parent) {
+  return (
+    (isCallExpression(parent) ||
+      isOptionalCallExpression(parent) ||
+      isNewExpression(parent) ||
+      isTSInstantiationExpression(parent)) &&
+    !!parent.typeParameters
+  );
+}
+
+function BinaryExpression(node, 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)
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function YieldExpression(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,
+  });
+}
+
+function UnaryLike(node, parent) {
+  return (
+    hasPostfixPart(node, parent) ||
+    isBinaryExpression(parent, {
+      operator: '**',
+      left: node,
+    }) ||
+    isClassExtendsClause(node, parent)
+  );
+}
+
+function FunctionExpression(node, parent, printStack) {
+  return isFirstInContext(printStack, {
+    expressionStatement: true,
+    exportDefault: true,
+  });
+}
+
+function ArrowFunctionExpression(node, parent) {
+  return isExportDeclaration(parent) || ConditionalExpression(node, parent);
+}
+
+function ConditionalExpression(node, parent) {
+  if (
+    isUnaryLike(parent) ||
+    isBinary(parent) ||
+    isConditionalExpression(parent, {
+      test: node,
+    }) ||
+    isAwaitExpression(parent) ||
+    isTSTypeAssertion(parent) ||
+    isTSAsExpression(parent)
+  ) {
+    return true;
+  }
+
+  return UnaryLike(node, parent);
+}
+
+function OptionalMemberExpression(node, parent) {
+  return (
+    isCallExpression(parent, {
+      callee: node,
+    }) ||
+    isMemberExpression(parent, {
+      object: node,
+    })
+  );
+}
+
+function AssignmentExpression(node, parent) {
+  if (isObjectPattern(node.left)) {
+    return true;
+  } else {
+    return ConditionalExpression(node, parent);
+  }
+}
+
+function LogicalExpression(node, parent) {
+  switch (node.operator) {
+    case '||':
+      if (!isLogicalExpression(parent)) return false;
+      return parent.operator === '??' || parent.operator === '&&';
+
+    case '&&':
+      return isLogicalExpression(parent, {
+        operator: '??',
+      });
+
+    case '??':
+      return isLogicalExpression(parent) && parent.operator !== '??';
+  }
+}
+
+function Identifier(node, parent, printStack) {
+  var _node$extra;
+
+  if (
+    (_node$extra = node.extra) != null &&
+    _node$extra.parenthesized &&
+    isAssignmentExpression(parent, {
+      left: node,
+    }) &&
+    (isFunctionExpression(parent.right) || isClassExpression(parent.right)) &&
+    parent.right.id == null
+  ) {
+    return true;
+  }
+
+  if (node.name === 'let') {
+    const isFollowedByBracket =
+      isMemberExpression(parent, {
+        object: node,
+        computed: true,
+      }) ||
+      isOptionalMemberExpression(parent, {
+        object: node,
+        computed: true,
+        optional: false,
+      });
+    return isFirstInContext(printStack, {
+      expressionStatement: isFollowedByBracket,
+      forHead: isFollowedByBracket,
+      forInHead: isFollowedByBracket,
+      forOfHead: true,
+    });
+  }
+
+  return (
+    node.name === 'async' && isForOfStatement(parent) && node === parent.left
+  );
+}
+
+function isFirstInContext(
+  printStack,
+  {
+    expressionStatement = false,
+    arrowBody = false,
+    exportDefault = false,
+    forHead = false,
+    forInHead = false,
+    forOfHead = false,
+  }
+) {
+  let i = printStack.length - 1;
+  let node = printStack[i];
+  i--;
+  let parent = printStack[i];
+
+  while (i >= 0) {
+    if (
+      (expressionStatement &&
+        isExpressionStatement(parent, {
+          expression: node,
+        })) ||
+      (exportDefault &&
+        isExportDefaultDeclaration(parent, {
+          declaration: node,
+        })) ||
+      (arrowBody &&
+        isArrowFunctionExpression(parent, {
+          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, {
+        test: node,
+      }) ||
+      isBinary(parent, {
+        left: node,
+      }) ||
+      isAssignmentExpression(parent, {
+        left: node,
+      })
+    ) {
+      node = parent;
+      i--;
+      parent = printStack[i];
+    } else {
+      return false;
+    }
+  }
+
+  return false;
+}

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

@@ -0,0 +1,259 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.nodes = exports.list = void 0;
+
+var _t = require('@babel/types');
+
+const {
+  FLIPPED_ALIAS_KEYS,
+  isArrayExpression,
+  isAssignmentExpression,
+  isBinary,
+  isBlockStatement,
+  isCallExpression,
+  isFunction,
+  isIdentifier,
+  isLiteral,
+  isMemberExpression,
+  isObjectExpression,
+  isOptionalCallExpression,
+  isOptionalMemberExpression,
+  isStringLiteral,
+} = _t;
+
+function crawl(node, state = {}) {
+  if (isMemberExpression(node) || isOptionalMemberExpression(node)) {
+    crawl(node.object, state);
+    if (node.computed) crawl(node.property, state);
+  } else if (isBinary(node) || isAssignmentExpression(node)) {
+    crawl(node.left, state);
+    crawl(node.right, state);
+  } else if (isCallExpression(node) || isOptionalCallExpression(node)) {
+    state.hasCall = true;
+    crawl(node.callee, state);
+  } else if (isFunction(node)) {
+    state.hasFunction = true;
+  } else if (isIdentifier(node)) {
+    state.hasHelper = state.hasHelper || isHelper(node.callee);
+  }
+
+  return state;
+}
+
+function isHelper(node) {
+  if (isMemberExpression(node)) {
+    return isHelper(node.object) || isHelper(node.property);
+  } else if (isIdentifier(node)) {
+    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)
+    );
+  } else {
+    return false;
+  }
+}
+
+function isType(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) {
+      return {
+        before: state.hasFunction,
+        after: true,
+      };
+    }
+  },
+
+  SwitchCase(node, parent) {
+    return {
+      before: !!node.consequent.length || parent.cases[0] === node,
+      after:
+        !node.consequent.length &&
+        parent.cases[parent.cases.length - 1] === node,
+    };
+  },
+
+  LogicalExpression(node) {
+    if (isFunction(node.left) || isFunction(node.right)) {
+      return {
+        after: true,
+      };
+    }
+  },
+
+  Literal(node) {
+    if (isStringLiteral(node) && node.value === 'use strict') {
+      return {
+        after: true,
+      };
+    }
+  },
+
+  CallExpression(node) {
+    if (isFunction(node.callee) || isHelper(node)) {
+      return {
+        before: true,
+        after: true,
+      };
+    }
+  },
+
+  OptionalCallExpression(node) {
+    if (isFunction(node.callee)) {
+      return {
+        before: true,
+        after: true,
+      };
+    }
+  },
+
+  VariableDeclaration(node) {
+    for (let i = 0; i < node.declarations.length; i++) {
+      const declar = node.declarations[i];
+      let enabled = isHelper(declar.id) && !isType(declar.init);
+
+      if (!enabled) {
+        const state = crawl(declar.init);
+        enabled = (isHelper(declar.init) && state.hasCall) || state.hasFunction;
+      }
+
+      if (enabled) {
+        return {
+          before: true,
+          after: true,
+        };
+      }
+    }
+  },
+
+  IfStatement(node) {
+    if (isBlockStatement(node.consequent)) {
+      return {
+        before: true,
+        after: true,
+      };
+    }
+  },
+};
+exports.nodes = nodes;
+
+nodes.ObjectProperty =
+  nodes.ObjectTypeProperty =
+  nodes.ObjectMethod =
+    function (node, parent) {
+      if (parent.properties[0] === node) {
+        return {
+          before: true,
+        };
+      }
+    };
+
+nodes.ObjectTypeCallProperty = function (node, parent) {
+  var _parent$properties;
+
+  if (
+    parent.callProperties[0] === node &&
+    !(
+      (_parent$properties = parent.properties) != null &&
+      _parent$properties.length
+    )
+  ) {
+    return {
+      before: true,
+    };
+  }
+};
+
+nodes.ObjectTypeIndexer = function (node, parent) {
+  var _parent$properties2, _parent$callPropertie;
+
+  if (
+    parent.indexers[0] === node &&
+    !(
+      (_parent$properties2 = parent.properties) != null &&
+      _parent$properties2.length
+    ) &&
+    !(
+      (_parent$callPropertie = parent.callProperties) != null &&
+      _parent$callPropertie.length
+    )
+  ) {
+    return {
+      before: true,
+    };
+  }
+};
+
+nodes.ObjectTypeInternalSlot = function (node, parent) {
+  var _parent$properties3, _parent$callPropertie2, _parent$indexers;
+
+  if (
+    parent.internalSlots[0] === node &&
+    !(
+      (_parent$properties3 = parent.properties) != null &&
+      _parent$properties3.length
+    ) &&
+    !(
+      (_parent$callPropertie2 = parent.callProperties) != null &&
+      _parent$callPropertie2.length
+    ) &&
+    !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)
+  ) {
+    return {
+      before: true,
+    };
+  }
+};
+
+const list = {
+  VariableDeclaration(node) {
+    return node.declarations.map((decl) => decl.init);
+  },
+
+  ArrayExpression(node) {
+    return node.elements;
+  },
+
+  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') {
+    amounts = {
+      after: amounts,
+      before: amounts,
+    };
+  }
+
+  [type].concat(FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) {
+    nodes[type] = function () {
+      return amounts;
+    };
+  });
+});

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

@@ -0,0 +1,582 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.default = void 0;
+
+var _buffer = require('./buffer');
+
+var n = require('./node');
+
+var _t = require('@babel/types');
+
+var generatorFunctions = require('./generators');
+
+const { 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 { needsParens, needsWhitespaceAfter, needsWhitespaceBefore } = n;
+
+class Printer {
+  constructor(format, map) {
+    this.inForStatementInitCounter = 0;
+    this._printStack = [];
+    this._indent = 0;
+    this._insideAux = false;
+    this._parenPushNewlineState = null;
+    this._noLineTerminator = false;
+    this._printAuxAfterOnNextUserNode = false;
+    this._printedComments = new WeakSet();
+    this._endsWithInteger = false;
+    this._endsWithWord = false;
+    this.format = format;
+    this._buf = new _buffer.default(map);
+  }
+
+  generate(ast) {
+    this.print(ast);
+
+    this._maybeAddAuxComment();
+
+    return this._buf.get();
+  }
+
+  indent() {
+    if (this.format.compact || this.format.concise) return;
+    this._indent++;
+  }
+
+  dedent() {
+    if (this.format.compact || this.format.concise) return;
+    this._indent--;
+  }
+
+  semicolon(force = false) {
+    this._maybeAddAuxComment();
+
+    this._append(';', !force);
+  }
+
+  rightBrace() {
+    if (this.format.minified) {
+      this._buf.removeLastSemicolon();
+    }
+
+    this.token('}');
+  }
+
+  space(force = false) {
+    if (this.format.compact) return;
+
+    if (force) {
+      this._space();
+    } else if (this._buf.hasContent()) {
+      const lastCp = this.getLastChar();
+
+      if (lastCp !== 32 && lastCp !== 10) {
+        this._space();
+      }
+    }
+  }
+
+  word(str) {
+    if (this._endsWithWord || (this.endsWith(47) && str.charCodeAt(0) === 47)) {
+      this._space();
+    }
+
+    this._maybeAddAuxComment();
+
+    this._append(str);
+
+    this._endsWithWord = true;
+  }
+
+  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;
+  }
+
+  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)
+    ) {
+      this._space();
+    }
+
+    this._maybeAddAuxComment();
+
+    this._append(str);
+  }
+
+  newline(i = 1) {
+    if (this.format.retainLines || this.format.compact) return;
+
+    if (this.format.concise) {
+      this.space();
+      return;
+    }
+
+    const charBeforeNewline = this.endsWithCharAndNewline();
+    if (charBeforeNewline === 10) return;
+
+    if (charBeforeNewline === 123 || charBeforeNewline === 58) {
+      i--;
+    }
+
+    if (i <= 0) return;
+
+    for (let j = 0; j < i; j++) {
+      this._newline();
+    }
+  }
+
+  endsWith(char) {
+    return this.getLastChar() === char;
+  }
+
+  getLastChar() {
+    return this._buf.getLastChar();
+  }
+
+  endsWithCharAndNewline() {
+    return this._buf.endsWithCharAndNewline();
+  }
+
+  removeTrailingNewline() {
+    this._buf.removeTrailingNewline();
+  }
+
+  exactSource(loc, cb) {
+    this._catchUp('start', loc);
+
+    this._buf.exactSource(loc, cb);
+  }
+
+  source(prop, loc) {
+    this._catchUp(prop, loc);
+
+    this._buf.source(prop, loc);
+  }
+
+  withSource(prop, loc, cb) {
+    this._catchUp(prop, loc);
+
+    this._buf.withSource(prop, loc, cb);
+  }
+
+  _space() {
+    this._append(' ', true);
+  }
+
+  _newline() {
+    this._append('\n', true);
+  }
+
+  _append(str, queue = false) {
+    this._maybeAddParen(str);
+
+    this._maybeIndent(str);
+
+    if (queue) this._buf.queue(str);
+    else this._buf.append(str);
+    this._endsWithWord = false;
+    this._endsWithInteger = false;
+  }
+
+  _maybeIndent(str) {
+    if (this._indent && this.endsWith(10) && str.charCodeAt(0) !== 10) {
+      this._buf.queueIndentation(this._getIndent());
+    }
+  }
+
+  _maybeAddParen(str) {
+    const parenPushNewlineState = this._parenPushNewlineState;
+    if (!parenPushNewlineState) return;
+    let i;
+
+    for (i = 0; i < str.length && str[i] === ' '; i++) continue;
+
+    if (i === str.length) {
+      return;
+    }
+
+    const cha = str[i];
+
+    if (cha !== '\n') {
+      if (cha !== '/' || i + 1 === str.length) {
+        this._parenPushNewlineState = null;
+        return;
+      }
+
+      const chaPost = str[i + 1];
+
+      if (chaPost === '*') {
+        if (PURE_ANNOTATION_RE.test(str.slice(i + 2, str.length - 2))) {
+          return;
+        }
+      } else if (chaPost !== '/') {
+        this._parenPushNewlineState = null;
+        return;
+      }
+    }
+
+    this.token('(');
+    this.indent();
+    parenPushNewlineState.printed = true;
+  }
+
+  _catchUp(prop, loc) {
+    if (!this.format.retainLines) return;
+    const pos = loc ? loc[prop] : null;
+
+    if ((pos == null ? void 0 : pos.line) != null) {
+      const count = pos.line - this._buf.getCurrentLine();
+
+      for (let i = 0; i < count; i++) {
+        this._newline();
+      }
+    }
+  }
+
+  _getIndent() {
+    return this.format.indent.style.repeat(this._indent);
+  }
+
+  startTerminatorless(isLabel = false) {
+    if (isLabel) {
+      this._noLineTerminator = true;
+      return null;
+    } else {
+      return (this._parenPushNewlineState = {
+        printed: false,
+      });
+    }
+  }
+
+  endTerminatorless(state) {
+    this._noLineTerminator = false;
+
+    if (state != null && state.printed) {
+      this.dedent();
+      this.newline();
+      this.token(')');
+    }
+  }
+
+  print(node, parent) {
+    if (!node) return;
+    const oldConcise = this.format.concise;
+
+    if (node._compact) {
+      this.format.concise = true;
+    }
+
+    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)}`
+      );
+    }
+
+    this._printStack.push(node);
+
+    const oldInAux = this._insideAux;
+    this._insideAux = !node.loc;
+
+    this._maybeAddAuxComment(this._insideAux && !oldInAux);
+
+    let shouldPrintParens = needsParens(node, parent, this._printStack);
+
+    if (
+      this.format.retainFunctionParens &&
+      node.type === 'FunctionExpression' &&
+      node.extra &&
+      node.extra.parenthesized
+    ) {
+      shouldPrintParens = true;
+    }
+
+    if (shouldPrintParens) this.token('(');
+
+    this._printLeadingComments(node);
+
+    const loc = isProgram(node) || isFile(node) ? null : node.loc;
+    this.withSource('start', loc, () => {
+      printMethod.call(this, node, parent);
+    });
+
+    this._printTrailingComments(node);
+
+    if (shouldPrintParens) this.token(')');
+
+    this._printStack.pop();
+
+    this.format.concise = oldConcise;
+    this._insideAux = oldInAux;
+  }
+
+  _maybeAddAuxComment(enteredPositionlessNode) {
+    if (enteredPositionlessNode) this._printAuxBeforeComment();
+    if (!this._insideAux) this._printAuxAfterComment();
+  }
+
+  _printAuxBeforeComment() {
+    if (this._printAuxAfterOnNextUserNode) return;
+    this._printAuxAfterOnNextUserNode = true;
+    const comment = this.format.auxiliaryCommentBefore;
+
+    if (comment) {
+      this._printComment({
+        type: 'CommentBlock',
+        value: comment,
+      });
+    }
+  }
+
+  _printAuxAfterComment() {
+    if (!this._printAuxAfterOnNextUserNode) return;
+    this._printAuxAfterOnNextUserNode = false;
+    const comment = this.format.auxiliaryCommentAfter;
+
+    if (comment) {
+      this._printComment({
+        type: 'CommentBlock',
+        value: comment,
+      });
+    }
+  }
+
+  getPossibleRaw(node) {
+    const extra = node.extra;
+
+    if (
+      extra &&
+      extra.raw != null &&
+      extra.rawValue != null &&
+      node.value === extra.rawValue
+    ) {
+      return extra.raw;
+    }
+  }
+
+  printJoin(nodes, parent, opts = {}) {
+    if (!(nodes != null && nodes.length)) return;
+    if (opts.indent) this.indent();
+    const newlineOpts = {
+      addNewlines: opts.addNewlines,
+    };
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (!node) continue;
+      if (opts.statement) this._printNewline(true, node, parent, newlineOpts);
+      this.print(node, parent);
+
+      if (opts.iterator) {
+        opts.iterator(node, i);
+      }
+
+      if (opts.separator && i < nodes.length - 1) {
+        opts.separator.call(this);
+      }
+
+      if (opts.statement) this._printNewline(false, node, parent, newlineOpts);
+    }
+
+    if (opts.indent) this.dedent();
+  }
+
+  printAndIndentOnComments(node, parent) {
+    const indent = node.leadingComments && node.leadingComments.length > 0;
+    if (indent) this.indent();
+    this.print(node, parent);
+    if (indent) this.dedent();
+  }
+
+  printBlock(parent) {
+    const node = parent.body;
+
+    if (!isEmptyStatement(node)) {
+      this.space();
+    }
+
+    this.print(node, parent);
+  }
+
+  _printTrailingComments(node) {
+    this._printComments(this._getComments(false, node));
+  }
+
+  _printLeadingComments(node) {
+    this._printComments(this._getComments(true, node), true);
+  }
+
+  printInnerComments(node, indent = true) {
+    var _node$innerComments;
+
+    if (
+      !(
+        (_node$innerComments = node.innerComments) != null &&
+        _node$innerComments.length
+      )
+    )
+      return;
+    if (indent) this.indent();
+
+    this._printComments(node.innerComments);
+
+    if (indent) this.dedent();
+  }
+
+  printSequence(nodes, parent, opts = {}) {
+    opts.statement = true;
+    return this.printJoin(nodes, parent, opts);
+  }
+
+  printList(items, parent, opts = {}) {
+    if (opts.separator == null) {
+      opts.separator = commaSeparator;
+    }
+
+    return this.printJoin(items, parent, opts);
+  }
+
+  _printNewline(leading, node, parent, opts) {
+    if (this.format.retainLines || this.format.compact) return;
+
+    if (this.format.concise) {
+      this.space();
+      return;
+    }
+
+    let lines = 0;
+
+    if (this._buf.hasContent()) {
+      if (!leading) lines++;
+      if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
+      const needs = leading ? needsWhitespaceBefore : needsWhitespaceAfter;
+      if (needs(node, parent)) lines++;
+    }
+
+    this.newline(Math.min(2, lines));
+  }
+
+  _getComments(leading, node) {
+    return (
+      (node && (leading ? node.leadingComments : node.trailingComments)) || []
+    );
+  }
+
+  _printComment(comment, skipNewLines) {
+    if (!this.format.shouldPrintComment(comment.value)) return;
+    if (comment.ignore) return;
+    if (this._printedComments.has(comment)) return;
+
+    this._printedComments.add(comment);
+
+    const isBlockComment = comment.type === 'CommentBlock';
+    const printNewLines =
+      isBlockComment && !skipNewLines && !this._noLineTerminator;
+    if (printNewLines && this._buf.hasContent()) this.newline(1);
+    const lastCharCode = this.getLastChar();
+
+    if (lastCharCode !== 91 && lastCharCode !== 123) {
+      this.space();
+    }
+
+    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;
+
+      if (offset) {
+        const newlineRegex = new RegExp('\\n\\s{1,' + offset + '}', 'g');
+        val = val.replace(newlineRegex, '\n');
+      }
+
+      const indentSize = Math.max(
+        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._append(val);
+    });
+    if (printNewLines) this.newline(1);
+  }
+
+  _printComments(comments, inlinePureAnnotation) {
+    if (!(comments != null && comments.length)) return;
+
+    if (
+      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);
+      }
+    }
+  }
+
+  printAssertions(node) {
+    var _node$assertions;
+
+    if (
+      (_node$assertions = node.assertions) != null &&
+      _node$assertions.length
+    ) {
+      this.space();
+      this.word('assert');
+      this.space();
+      this.token('{');
+      this.space();
+      this.printList(node.assertions, node);
+      this.space();
+      this.token('}');
+    }
+  }
+}
+
+Object.assign(Printer.prototype, generatorFunctions);
+{
+  Printer.prototype.Noop = function Noop() {};
+}
+var _default = Printer;
+exports.default = _default;
+
+function commaSeparator() {
+  this.token(',');
+  this.space();
+}

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

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

node_modules/@babel/generator/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@babel/generator",
+  "version": "7.18.2",
+  "description": "Turns an AST into code.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-generator"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-generator",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen",
+  "main": "./lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@babel/types": "^7.18.2",
+    "@jridgewell/gen-mapping": "^0.3.0",
+    "jsesc": "^2.5.1"
+  },
+  "devDependencies": {
+    "@babel/helper-fixtures": "^7.17.10",
+    "@babel/parser": "^7.18.0",
+    "@jridgewell/trace-mapping": "^0.3.8",
+    "@types/jsesc": "^2.5.0",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  }
+}

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

@@ -0,0 +1,362 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.readCodePoint = readCodePoint;
+exports.readInt = readInt;
+exports.readStringContents = readStringContents;
+var _isDigit = function isDigit(code) {
+  return code >= 48 && code <= 57;
+};
+const forbiddenNumericSeparatorSiblings = {
+  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
+  hex: new Set([46, 88, 95, 120]),
+};
+const isAllowedNumericSeparatorSibling = {
+  bin: (ch) => ch === 48 || ch === 49,
+  oct: (ch) => ch >= 48 && ch <= 55,
+  dec: (ch) => ch >= 48 && ch <= 57,
+  hex: (ch) =>
+    (ch >= 48 && ch <= 57) || (ch >= 65 && ch <= 70) || (ch >= 97 && ch <= 102),
+};
+function readStringContents(type, input, pos, lineStart, curLine, errors) {
+  const initialPos = pos;
+  const initialLineStart = lineStart;
+  const initialCurLine = curLine;
+  let out = '';
+  let firstInvalidLoc = null;
+  let chunkStart = pos;
+  const { length } = input;
+  for (;;) {
+    if (pos >= length) {
+      errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    const ch = input.charCodeAt(pos);
+    if (isStringEnd(type, ch, input, pos)) {
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    if (ch === 92) {
+      out += input.slice(chunkStart, pos);
+      const res = readEscapedChar(
+        input,
+        pos,
+        lineStart,
+        curLine,
+        type === 'template',
+        errors
+      );
+      if (res.ch === null && !firstInvalidLoc) {
+        firstInvalidLoc = {
+          pos,
+          lineStart,
+          curLine,
+        };
+      } else {
+        out += res.ch;
+      }
+      ({ pos, lineStart, curLine } = res);
+      chunkStart = pos;
+    } else if (ch === 8232 || ch === 8233) {
+      ++pos;
+      ++curLine;
+      lineStart = pos;
+    } else if (ch === 10 || ch === 13) {
+      if (type === 'template') {
+        out += input.slice(chunkStart, pos) + '\n';
+        ++pos;
+        if (ch === 13 && input.charCodeAt(pos) === 10) {
+          ++pos;
+        }
+        ++curLine;
+        chunkStart = lineStart = pos;
+      } else {
+        errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      }
+    } else {
+      ++pos;
+    }
+  }
+  return {
+    pos,
+    str: out,
+    firstInvalidLoc,
+    lineStart,
+    curLine,
+    containsInvalid: !!firstInvalidLoc,
+  };
+}
+function isStringEnd(type, ch, input, pos) {
+  if (type === 'template') {
+    return ch === 96 || (ch === 36 && input.charCodeAt(pos + 1) === 123);
+  }
+  return ch === (type === 'double' ? 34 : 39);
+}
+function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
+  const throwOnInvalid = !inTemplate;
+  pos++;
+  const res = (ch) => ({
+    pos,
+    ch,
+    lineStart,
+    curLine,
+  });
+  const ch = input.charCodeAt(pos++);
+  switch (ch) {
+    case 110:
+      return res('\n');
+    case 114:
+      return res('\r');
+    case 120: {
+      let code;
+      ({ code, pos } = readHexChar(
+        input,
+        pos,
+        lineStart,
+        curLine,
+        2,
+        false,
+        throwOnInvalid,
+        errors
+      ));
+      return res(code === null ? null : String.fromCharCode(code));
+    }
+    case 117: {
+      let code;
+      ({ code, pos } = readCodePoint(
+        input,
+        pos,
+        lineStart,
+        curLine,
+        throwOnInvalid,
+        errors
+      ));
+      return res(code === null ? null : String.fromCodePoint(code));
+    }
+    case 116:
+      return res('\t');
+    case 98:
+      return res('\b');
+    case 118:
+      return res('\u000b');
+    case 102:
+      return res('\f');
+    case 13:
+      if (input.charCodeAt(pos) === 10) {
+        ++pos;
+      }
+    case 10:
+      lineStart = pos;
+      ++curLine;
+    case 8232:
+    case 8233:
+      return res('');
+    case 56:
+    case 57:
+      if (inTemplate) {
+        return res(null);
+      } else {
+        errors.strictNumericEscape(pos - 1, lineStart, curLine);
+      }
+    default:
+      if (ch >= 48 && ch <= 55) {
+        const startPos = pos - 1;
+        const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));
+        let octalStr = match[0];
+        let octal = parseInt(octalStr, 8);
+        if (octal > 255) {
+          octalStr = octalStr.slice(0, -1);
+          octal = parseInt(octalStr, 8);
+        }
+        pos += octalStr.length - 1;
+        const next = input.charCodeAt(pos);
+        if (octalStr !== '0' || next === 56 || next === 57) {
+          if (inTemplate) {
+            return res(null);
+          } else {
+            errors.strictNumericEscape(startPos, lineStart, curLine);
+          }
+        }
+        return res(String.fromCharCode(octal));
+      }
+      return res(String.fromCharCode(ch));
+  }
+}
+function readHexChar(
+  input,
+  pos,
+  lineStart,
+  curLine,
+  len,
+  forceLen,
+  throwOnInvalid,
+  errors
+) {
+  const initialPos = pos;
+  let n;
+  ({ n, pos } = readInt(
+    input,
+    pos,
+    lineStart,
+    curLine,
+    16,
+    len,
+    forceLen,
+    false,
+    errors,
+    !throwOnInvalid
+  ));
+  if (n === null) {
+    if (throwOnInvalid) {
+      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
+    } else {
+      pos = initialPos - 1;
+    }
+  }
+  return {
+    code: n,
+    pos,
+  };
+}
+function readInt(
+  input,
+  pos,
+  lineStart,
+  curLine,
+  radix,
+  len,
+  forceLen,
+  allowNumSeparator,
+  errors,
+  bailOnError
+) {
+  const start = pos;
+  const forbiddenSiblings =
+    radix === 16 ?
+      forbiddenNumericSeparatorSiblings.hex
+    : forbiddenNumericSeparatorSiblings.decBinOct;
+  const isAllowedSibling =
+    radix === 16 ? isAllowedNumericSeparatorSibling.hex
+    : radix === 10 ? isAllowedNumericSeparatorSibling.dec
+    : radix === 8 ? isAllowedNumericSeparatorSibling.oct
+    : isAllowedNumericSeparatorSibling.bin;
+  let invalid = false;
+  let total = 0;
+  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    const code = input.charCodeAt(pos);
+    let val;
+    if (code === 95 && allowNumSeparator !== 'bail') {
+      const prev = input.charCodeAt(pos - 1);
+      const next = input.charCodeAt(pos + 1);
+      if (!allowNumSeparator) {
+        if (bailOnError)
+          return {
+            n: null,
+            pos,
+          };
+        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
+      } else if (
+        Number.isNaN(next) ||
+        !isAllowedSibling(next) ||
+        forbiddenSiblings.has(prev) ||
+        forbiddenSiblings.has(next)
+      ) {
+        if (bailOnError)
+          return {
+            n: null,
+            pos,
+          };
+        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
+      }
+      ++pos;
+      continue;
+    }
+    if (code >= 97) {
+      val = code - 97 + 10;
+    } else if (code >= 65) {
+      val = code - 65 + 10;
+    } else if (_isDigit(code)) {
+      val = code - 48;
+    } else {
+      val = Infinity;
+    }
+    if (val >= radix) {
+      if (val <= 9 && bailOnError) {
+        return {
+          n: null,
+          pos,
+        };
+      } else if (
+        val <= 9 &&
+        errors.invalidDigit(pos, lineStart, curLine, radix)
+      ) {
+        val = 0;
+      } else if (forceLen) {
+        val = 0;
+        invalid = true;
+      } else {
+        break;
+      }
+    }
+    ++pos;
+    total = total * radix + val;
+  }
+  if (pos === start || (len != null && pos - start !== len) || invalid) {
+    return {
+      n: null,
+      pos,
+    };
+  }
+  return {
+    n: total,
+    pos,
+  };
+}
+function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+  const ch = input.charCodeAt(pos);
+  let code;
+  if (ch === 123) {
+    ++pos;
+    ({ code, pos } = readHexChar(
+      input,
+      pos,
+      lineStart,
+      curLine,
+      input.indexOf('}', pos) - pos,
+      true,
+      throwOnInvalid,
+      errors
+    ));
+    ++pos;
+    if (code !== null && code > 0x10ffff) {
+      if (throwOnInvalid) {
+        errors.invalidCodePoint(pos, lineStart, curLine);
+      } else {
+        return {
+          code: null,
+          pos,
+        };
+      }
+    }
+  } else {
+    ({ code, pos } = readHexChar(
+      input,
+      pos,
+      lineStart,
+      curLine,
+      4,
+      false,
+      throwOnInvalid,
+      errors
+    ));
+  }
+  return {
+    code,
+    pos,
+  };
+}
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/helper-string-parser/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-string-parser",
+  "version": "7.25.9",
+  "description": "A utility package to parse strings",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-string-parser"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-string-parser",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "devDependencies": {
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "commonjs"
+}

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["_identifier","require","_keyword"],"sources":["../src/index.ts"],"sourcesContent":["export {\n  isIdentifierName,\n  isIdentifierChar,\n  isIdentifierStart,\n} from \"./identifier.ts\";\nexport {\n  isReservedWord,\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n  isStrictReservedWord,\n  isKeyword,\n} from \"./keyword.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAKA,IAAAC,QAAA,GAAAD,OAAA","ignoreList":[]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["reservedWords","keyword","strict","strictBind","keywords","Set","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword"],"sources":["../src/keyword.ts"],"sourcesContent":["const reservedWords = {\n  keyword: [\n    \"break\",\n    \"case\",\n    \"catch\",\n    \"continue\",\n    \"debugger\",\n    \"default\",\n    \"do\",\n    \"else\",\n    \"finally\",\n    \"for\",\n    \"function\",\n    \"if\",\n    \"return\",\n    \"switch\",\n    \"throw\",\n    \"try\",\n    \"var\",\n    \"const\",\n    \"while\",\n    \"with\",\n    \"new\",\n    \"this\",\n    \"super\",\n    \"class\",\n    \"extends\",\n    \"export\",\n    \"import\",\n    \"null\",\n    \"true\",\n    \"false\",\n    \"in\",\n    \"instanceof\",\n    \"typeof\",\n    \"void\",\n    \"delete\",\n  ],\n  strict: [\n    \"implements\",\n    \"interface\",\n    \"let\",\n    \"package\",\n    \"private\",\n    \"protected\",\n    \"public\",\n    \"static\",\n    \"yield\",\n  ],\n  strictBind: [\"eval\", \"arguments\"],\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\n/**\n * Checks if word is a reserved word in non-strict mode\n */\nexport function isReservedWord(word: string, inModule: boolean): boolean {\n  return (inModule && word === \"await\") || word === \"enum\";\n}\n\n/**\n * Checks if word is a reserved word in non-binding strict mode\n *\n * Includes non-strict reserved words\n */\nexport function isStrictReservedWord(word: string, inModule: boolean): boolean {\n  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode, but it is allowed as\n * a normal identifier.\n */\nexport function isStrictBindOnlyReservedWord(word: string): boolean {\n  return reservedWordsStrictBindSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode\n *\n * Includes non-strict reserved words and non-binding strict reserved words\n */\nexport function isStrictBindReservedWord(\n  word: string,\n  inModule: boolean,\n): boolean {\n  return (\n    isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word)\n  );\n}\n\nexport function isKeyword(word: string): boolean {\n  return keywords.has(word);\n}\n"],"mappings":";;;;;;;;;;AAAA,MAAMA,aAAa,GAAG;EACpBC,OAAO,EAAE,CACP,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,KAAK,EACL,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,CACT;EACDC,MAAM,EAAE,CACN,YAAY,EACZ,WAAW,EACX,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,CACR;EACDC,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW;AAClC,CAAC;AACD,MAAMC,QAAQ,GAAG,IAAIC,GAAG,CAACL,aAAa,CAACC,OAAO,CAAC;AAC/C,MAAMK,sBAAsB,GAAG,IAAID,GAAG,CAACL,aAAa,CAACE,MAAM,CAAC;AAC5D,MAAMK,0BAA0B,GAAG,IAAIF,GAAG,CAACL,aAAa,CAACG,UAAU,CAAC;AAK7D,SAASK,cAAcA,CAACC,IAAY,EAAEC,QAAiB,EAAW;EACvE,OAAQA,QAAQ,IAAID,IAAI,KAAK,OAAO,IAAKA,IAAI,KAAK,MAAM;AAC1D;AAOO,SAASE,oBAAoBA,CAACF,IAAY,EAAEC,QAAiB,EAAW;EAC7E,OAAOF,cAAc,CAACC,IAAI,EAAEC,QAAQ,CAAC,IAAIJ,sBAAsB,CAACM,GAAG,CAACH,IAAI,CAAC;AAC3E;AAMO,SAASI,4BAA4BA,CAACJ,IAAY,EAAW;EAClE,OAAOF,0BAA0B,CAACK,GAAG,CAACH,IAAI,CAAC;AAC7C;AAOO,SAASK,wBAAwBA,CACtCL,IAAY,EACZC,QAAiB,EACR;EACT,OACEC,oBAAoB,CAACF,IAAI,EAAEC,QAAQ,CAAC,IAAIG,4BAA4B,CAACJ,IAAI,CAAC;AAE9E;AAEO,SAASM,SAASA,CAACN,IAAY,EAAW;EAC/C,OAAOL,QAAQ,CAACQ,GAAG,CAACH,IAAI,CAAC;AAC3B","ignoreList":[]}

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

@@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-validator-identifier",
+  "version": "7.25.9",
+  "description": "Validate identifier/keywords name",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-validator-identifier"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@unicode/unicode-16.0.0": "^1.0.0",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

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

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

node_modules/@babel/parser/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@babel/parser",
+  "version": "7.18.4",
+  "description": "A JavaScript parser",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "main": "./lib/index.js",
+  "types": "./typings/babel-parser.d.ts",
+  "files": [
+    "bin",
+    "lib",
+    "typings"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^7.16.7",
+    "@babel/helper-check-duplicate-nodes": "^7.18.4",
+    "@babel/helper-fixtures": "^7.17.10",
+    "@babel/helper-validator-identifier": "^7.16.7",
+    "charcodes": "^0.2.0"
+  },
+  "bin": "./bin/babel-parser.js"
+}

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

@@ -0,0 +1,214 @@
+// Type definitions for @babel/parser
+// Project: https://github.com/babel/babel/tree/main/packages/babel-parser
+// Definitions by: Troy Gerwien <https://github.com/yortus>
+//                 Marvin Hagemeister <https://github.com/marvinhagemeister>
+//                 Avi Vahl <https://github.com/AviVahl>
+// TypeScript Version: 2.9
+
+/**
+ * Parse the provided code as an entire ECMAScript program.
+ */
+export function parse(
+  input: string,
+  options?: ParserOptions
+): ParseResult<import('@babel/types').File>;
+
+/**
+ * Parse the provided code as a single expression.
+ */
+export function parseExpression(
+  input: string,
+  options?: ParserOptions
+): ParseResult<import('@babel/types').Expression>;
+
+export interface ParserOptions {
+  /**
+   * By default, import and export declarations can only appear at a program's top level.
+   * Setting this option to true allows them anywhere where a statement is allowed.
+   */
+  allowImportExportEverywhere?: boolean;
+
+  /**
+   * By default, await use is not allowed outside of an async function.
+   * Set this to true to accept such code.
+   */
+  allowAwaitOutsideFunction?: boolean;
+
+  /**
+   * By default, a return statement at the top level raises an error.
+   * Set this to true to accept such code.
+   */
+  allowReturnOutsideFunction?: boolean;
+
+  allowSuperOutsideMethod?: boolean;
+
+  /**
+   * By default, exported identifiers must refer to a declared variable.
+   * Set this to true to allow export statements to reference undeclared variables.
+   */
+  allowUndeclaredExports?: boolean;
+
+  /**
+   * By default, Babel attaches comments to adjacent AST nodes.
+   * When this option is set to false, comments are not attached.
+   * It can provide up to 30% performance improvement when the input code has many comments.
+   * @babel/eslint-parser will set it for you.
+   * It is not recommended to use attachComment: false with Babel transform,
+   * as doing so removes all the comments in output code, and renders annotations such as
+   * /* istanbul ignore next *\/ nonfunctional.
+   */
+  attachComment?: boolean;
+
+  /**
+   * By default, Babel always throws an error when it finds some invalid code.
+   * When this option is set to true, it will store the parsing error and
+   * try to continue parsing the invalid input file.
+   */
+  errorRecovery?: boolean;
+
+  /**
+   * Indicate the mode the code should be parsed in.
+   * Can be one of "script", "module", or "unambiguous". Defaults to "script".
+   * "unambiguous" will make @babel/parser attempt to guess, based on the presence
+   * of ES6 import or export statements.
+   * Files with ES6 imports and exports are considered "module" and are otherwise "script".
+   */
+  sourceType?: 'script' | 'module' | 'unambiguous';
+
+  /**
+   * Correlate output AST nodes with their source filename.
+   * Useful when generating code and source maps from the ASTs of multiple input files.
+   */
+  sourceFilename?: string;
+
+  /**
+   * By default, the first line of code parsed is treated as line 1.
+   * You can provide a line number to alternatively start with.
+   * Useful for integration with other source tools.
+   */
+  startLine?: number;
+
+  /**
+   * By default, the parsed code is treated as if it starts from line 1, column 0.
+   * You can provide a column number to alternatively start with.
+   * Useful for integration with other source tools.
+   */
+  startColumn?: number;
+
+  /**
+   * Array containing the plugins that you want to enable.
+   */
+  plugins?: ParserPlugin[];
+
+  /**
+   * Should the parser work in strict mode.
+   * Defaults to true if sourceType === 'module'. Otherwise, false.
+   */
+  strictMode?: boolean;
+
+  /**
+   * Adds a ranges property to each node: [node.start, node.end]
+   */
+  ranges?: boolean;
+
+  /**
+   * Adds all parsed tokens to a tokens property on the File node.
+   */
+  tokens?: boolean;
+
+  /**
+   * By default, the parser adds information about parentheses by setting
+   * `extra.parenthesized` to `true` as needed.
+   * When this option is `true` the parser creates `ParenthesizedExpression`
+   * AST nodes instead of using the `extra` property.
+   */
+  createParenthesizedExpressions?: boolean;
+}
+
+export type ParserPlugin =
+  | 'asyncDoExpressions'
+  | 'asyncGenerators'
+  | 'bigInt'
+  | 'classPrivateMethods'
+  | 'classPrivateProperties'
+  | 'classProperties'
+  | 'classStaticBlock' // Enabled by default
+  | 'decimal'
+  | 'decorators'
+  | 'decorators-legacy'
+  | 'decoratorAutoAccessors'
+  | 'destructuringPrivate'
+  | 'doExpressions'
+  | 'dynamicImport'
+  | 'estree'
+  | 'exportDefaultFrom'
+  | 'exportNamespaceFrom' // deprecated
+  | 'flow'
+  | 'flowComments'
+  | 'functionBind'
+  | 'functionSent'
+  | 'importMeta'
+  | 'jsx'
+  | 'logicalAssignment'
+  | 'importAssertions'
+  | 'moduleBlocks'
+  | 'moduleStringNames'
+  | 'nullishCoalescingOperator'
+  | 'numericSeparator'
+  | 'objectRestSpread'
+  | 'optionalCatchBinding'
+  | 'optionalChaining'
+  | 'partialApplication'
+  | 'pipelineOperator'
+  | 'placeholders'
+  | 'privateIn' // Enabled by default
+  | 'regexpUnicodeSets'
+  | 'throwExpressions'
+  | 'topLevelAwait'
+  | 'typescript'
+  | 'v8intrinsic'
+  | ParserPluginWithOptions;
+
+export type ParserPluginWithOptions =
+  | ['decorators', DecoratorsPluginOptions]
+  | ['pipelineOperator', PipelineOperatorPluginOptions]
+  | ['recordAndTuple', RecordAndTuplePluginOptions]
+  | ['flow', FlowPluginOptions]
+  | ['typescript', TypeScriptPluginOptions];
+
+export interface DecoratorsPluginOptions {
+  decoratorsBeforeExport?: boolean;
+}
+
+export interface PipelineOperatorPluginOptions {
+  proposal: 'minimal' | 'fsharp' | 'hack' | 'smart';
+  topicToken?: '%' | '#' | '@@' | '^^' | '^';
+}
+
+export interface RecordAndTuplePluginOptions {
+  syntaxType: 'bar' | 'hash';
+}
+
+export interface FlowPluginOptions {
+  all?: boolean;
+  enums?: boolean;
+}
+
+export interface TypeScriptPluginOptions {
+  dts?: boolean;
+  disallowAmbiguousJSXLike?: boolean;
+}
+
+export const tokTypes: {
+  // todo(flow->ts) real token type
+  [name: string]: any;
+};
+
+export interface ParseError {
+  code: string;
+  reasonCode: string;
+}
+
+type ParseResult<Result> = Result & {
+  errors: ParseError[];
+};

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

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.default = assertNode;
+
+var _isNode = require('../validators/isNode');
+
+function assertNode(node) {
+  if (!(0, _isNode.default)(node)) {
+    var _node$type;
+
+    const type =
+      (_node$type = node == null ? void 0 : node.type) != null ?
+        _node$type
+      : JSON.stringify(node);
+    throw new TypeError(`Not a valid node of type "${type}"`);
+  }
+}
+
+//# sourceMappingURL=assertNode.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["assertNode","node","isNode","type","JSON","stringify","TypeError"],"sources":["../../src/asserts/assertNode.ts"],"sourcesContent":["import isNode from \"../validators/isNode\";\nimport type * as t from \"..\";\n\nexport default function assertNode(node?: any): asserts node is t.Node {\n  if (!isNode(node)) {\n    const type = node?.type ?? JSON.stringify(node);\n    throw new TypeError(`Not a valid node of type \"${type as any}\"`);\n  }\n}\n"],"mappings":";;;;;;;AAAA;;AAGe,SAASA,UAAT,CAAoBC,IAApB,EAAwD;EACrE,IAAI,CAAC,IAAAC,eAAA,EAAOD,IAAP,CAAL,EAAmB;IAAA;;IACjB,MAAME,IAAI,iBAAGF,IAAH,oBAAGA,IAAI,CAAEE,IAAT,yBAAiBC,IAAI,CAACC,SAAL,CAAeJ,IAAf,CAA3B;IACA,MAAM,IAAIK,SAAJ,CAAe,6BAA4BH,IAAY,GAAvD,CAAN;EACD;AACF"}

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

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

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

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.default = createFlowUnionType;
+
+var _generated = require('../generated');
+
+var _removeTypeDuplicates = require('../../modifications/flow/removeTypeDuplicates');
+
+function createFlowUnionType(types) {
+  const flattened = (0, _removeTypeDuplicates.default)(types);
+
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return (0, _generated.unionTypeAnnotation)(flattened);
+  }
+}
+
+//# sourceMappingURL=createFlowUnionType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFlowUnionType","types","flattened","removeTypeDuplicates","length","unionTypeAnnotation"],"sources":["../../../src/builders/flow/createFlowUnionType.ts"],"sourcesContent":["import { unionTypeAnnotation } from \"../generated\";\nimport removeTypeDuplicates from \"../../modifications/flow/removeTypeDuplicates\";\nimport type * as t from \"../..\";\n\n/**\n * Takes an array of `types` and flattens them, removing duplicates and\n * returns a `UnionTypeAnnotation` node containing them.\n */\nexport default function createFlowUnionType<T extends t.FlowType>(\n  types: [T] | Array<T>,\n): T | t.UnionTypeAnnotation {\n  const flattened = removeTypeDuplicates(types);\n\n  if (flattened.length === 1) {\n    return flattened[0] as T;\n  } else {\n    return unionTypeAnnotation(flattened);\n  }\n}\n"],"mappings":";;;;;;;AAAA;;AACA;;AAOe,SAASA,mBAAT,CACbC,KADa,EAEc;EAC3B,MAAMC,SAAS,GAAG,IAAAC,6BAAA,EAAqBF,KAArB,CAAlB;;EAEA,IAAIC,SAAS,CAACE,MAAV,KAAqB,CAAzB,EAA4B;IAC1B,OAAOF,SAAS,CAAC,CAAD,CAAhB;EACD,CAFD,MAEO;IACL,OAAO,IAAAG,8BAAA,EAAoBH,SAApB,CAAP;EACD;AACF"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createTypeAnnotationBasedOnTypeof","type","stringTypeAnnotation","numberTypeAnnotation","voidTypeAnnotation","booleanTypeAnnotation","genericTypeAnnotation","identifier","anyTypeAnnotation","Error"],"sources":["../../../src/builders/flow/createTypeAnnotationBasedOnTypeof.ts"],"sourcesContent":["import {\n  anyTypeAnnotation,\n  stringTypeAnnotation,\n  numberTypeAnnotation,\n  voidTypeAnnotation,\n  booleanTypeAnnotation,\n  genericTypeAnnotation,\n  identifier,\n} from \"../generated\";\nimport type * as t from \"../..\";\n\nexport default createTypeAnnotationBasedOnTypeof as {\n  (type: \"string\"): t.StringTypeAnnotation;\n  (type: \"number\"): t.NumberTypeAnnotation;\n  (type: \"undefined\"): t.VoidTypeAnnotation;\n  (type: \"boolean\"): t.BooleanTypeAnnotation;\n  (type: \"function\"): t.GenericTypeAnnotation;\n  (type: \"object\"): t.GenericTypeAnnotation;\n  (type: \"symbol\"): t.GenericTypeAnnotation;\n  (type: \"bigint\"): t.AnyTypeAnnotation;\n};\n\n/**\n * Create a type annotation based on typeof expression.\n */\nfunction createTypeAnnotationBasedOnTypeof(type: string): t.FlowType {\n  switch (type) {\n    case \"string\":\n      return stringTypeAnnotation();\n    case \"number\":\n      return numberTypeAnnotation();\n    case \"undefined\":\n      return voidTypeAnnotation();\n    case \"boolean\":\n      return booleanTypeAnnotation();\n    case \"function\":\n      return genericTypeAnnotation(identifier(\"Function\"));\n    case \"object\":\n      return genericTypeAnnotation(identifier(\"Object\"));\n    case \"symbol\":\n      return genericTypeAnnotation(identifier(\"Symbol\"));\n    case \"bigint\":\n      // todo: use BigInt annotation when Flow supports BigInt\n      // https://github.com/facebook/flow/issues/6639\n      return anyTypeAnnotation();\n  }\n  throw new Error(\"Invalid typeof value: \" + type);\n}\n"],"mappings":";;;;;;;AAAA;;eAWeA,iC;;;AAcf,SAASA,iCAAT,CAA2CC,IAA3C,EAAqE;EACnE,QAAQA,IAAR;IACE,KAAK,QAAL;MACE,OAAO,IAAAC,+BAAA,GAAP;;IACF,KAAK,QAAL;MACE,OAAO,IAAAC,+BAAA,GAAP;;IACF,KAAK,WAAL;MACE,OAAO,IAAAC,6BAAA,GAAP;;IACF,KAAK,SAAL;MACE,OAAO,IAAAC,gCAAA,GAAP;;IACF,KAAK,UAAL;MACE,OAAO,IAAAC,gCAAA,EAAsB,IAAAC,qBAAA,EAAW,UAAX,CAAtB,CAAP;;IACF,KAAK,QAAL;MACE,OAAO,IAAAD,gCAAA,EAAsB,IAAAC,qBAAA,EAAW,QAAX,CAAtB,CAAP;;IACF,KAAK,QAAL;MACE,OAAO,IAAAD,gCAAA,EAAsB,IAAAC,qBAAA,EAAW,QAAX,CAAtB,CAAP;;IACF,KAAK,QAAL;MAGE,OAAO,IAAAC,4BAAA,GAAP;EAlBJ;;EAoBA,MAAM,IAAIC,KAAJ,CAAU,2BAA2BR,IAArC,CAAN;AACD"}

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

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.default = buildChildren;
+
+var _generated = require('../../validators/generated');
+
+var _cleanJSXElementLiteralChild = require('../../utils/react/cleanJSXElementLiteralChild');
+
+function buildChildren(node) {
+  const elements = [];
+
+  for (let i = 0; i < node.children.length; i++) {
+    let child = node.children[i];
+
+    if ((0, _generated.isJSXText)(child)) {
+      (0, _cleanJSXElementLiteralChild.default)(child, elements);
+      continue;
+    }
+
+    if ((0, _generated.isJSXExpressionContainer)(child))
+      child = child.expression;
+    if ((0, _generated.isJSXEmptyExpression)(child)) continue;
+    elements.push(child);
+  }
+
+  return elements;
+}
+
+//# sourceMappingURL=buildChildren.js.map